SingleSeedVertexFinder.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file SingleSeedVertexFinder.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2023 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Definitions/Units.hpp"
#include "Acts/Utilities/Logger.hpp"
#include "Acts/Utilities/Ray.hpp"
#include "Acts/Utilities/Result.hpp"
#include "Acts/Utilities/detail/periodic.hpp"

#include <algorithm>
#include <string>
#include <utility>
#include <vector>

namespace Acts {

template <typename spacepoint_t>
class SingleSeedVertexFinder {
 public:
  struct Config {
    Acts::ActsScalar maxPhideviation = 0.08;
    Acts::ActsScalar maxXYdeviation = 0.08;
    Acts::ActsScalar maxXYZdeviation = 0.08;

    Acts::ActsScalar minTheta = 1.;

    Acts::ActsScalar rMinNear = 20.f * Acts::UnitConstants::mm;
    Acts::ActsScalar rMaxNear = 60.f * Acts::UnitConstants::mm;
    Acts::ActsScalar rMinMiddle = 150.f * Acts::UnitConstants::mm;
    Acts::ActsScalar rMaxMiddle = 190.f * Acts::UnitConstants::mm;
    Acts::ActsScalar rMinFar = 280.f * Acts::UnitConstants::mm;
    Acts::ActsScalar rMaxFar = 320.f * Acts::UnitConstants::mm;

    std::uint32_t numPhiSlices = 60;
    Acts::ActsScalar useFracPhiSlices = 0.5;

    std::uint32_t numZSlices = 150;
    Acts::ActsScalar useFracZSlices = 0.5;
    Acts::ActsScalar maxAbsZ = 450. * Acts::UnitConstants::mm;

    Acts::ActsScalar maxZPosition = 200.f * Acts::UnitConstants::mm;
    Acts::ActsScalar maxRPosition = 10.f * Acts::UnitConstants::mm;

    std::string minimalizeWRT = "planes";

    std::uint32_t maxIterations = 20;
    Acts::ActsScalar removeFraction = 0.10;
    Acts::ActsScalar minVtxShift = 0.3f * Acts::UnitConstants::mm;
  };

  const Config& config() const { return m_cfg; }

  SingleSeedVertexFinder(const Config& cfg,
                         std::unique_ptr<const Logger> lgr = getDefaultLogger(
                             "SingleSeedVertexFinder", Logging::INFO));

  ~SingleSeedVertexFinder() = default;

  Acts::Result<Acts::Vector3> findVertex(
      const std::vector<spacepoint_t>& spacepoints) const;

 private:
  struct Triplet {
    Triplet(const spacepoint_t& aa, const spacepoint_t& bb,
            const spacepoint_t& cc)
        : a(aa), b(bb), c(cc), ray(Acts::Vector3::Zero(), {1., 1., 1.}) {}

    const spacepoint_t &a, &b, &c;
    Acts::Ray3D ray;
  };

  struct SortedSpacepoints {
    SortedSpacepoints(const int phiSize, const int zSize) {
      std::vector<std::pair<spacepoint_t const*, Acts::ActsScalar>> helper = {};
      std::vector<std::vector<std::pair<spacepoint_t const*, Acts::ActsScalar>>>
          helperZ(zSize, helper);
      std::vector<std::vector<
          std::vector<std::pair<spacepoint_t const*, Acts::ActsScalar>>>>
          helperPhi(phiSize, helperZ);
      sortedSP.fill(helperPhi);
    }

    inline std::vector<std::pair<spacepoint_t const*, Acts::ActsScalar>>& addSP(
        int layer, int phi, int z) {
      return sortedSP[layer][phi][z];
    }

    inline const std::vector<std::pair<spacepoint_t const*, Acts::ActsScalar>>&
    getSP(int layer, int phi, int z) const {
      return sortedSP[layer][phi][z];
    }

    std::array<std::vector<std::vector<std::vector<
                   std::pair<spacepoint_t const*, Acts::ActsScalar>>>>,
               3>
        sortedSP;
  };

  Config m_cfg;

  Acts::SingleSeedVertexFinder<spacepoint_t>::SortedSpacepoints sortSpacepoints(
      const std::vector<spacepoint_t>& spacepoints) const;

  std::vector<Triplet> findTriplets(
      const Acts::SingleSeedVertexFinder<spacepoint_t>::SortedSpacepoints&
          sortedSpacepoints) const;

  bool tripletValidationAndUpdate(Triplet& triplet) const;

  static std::pair<Acts::Vector3, Acts::ActsScalar> makePlaneFromTriplet(
      const Triplet& triplet);

  Acts::Vector3 findClosestPointFromPlanes(
      const std::vector<Triplet>& triplets) const;

  static Acts::Ray3D makeRayFromTriplet(const Triplet& triplet);

  Acts::Vector3 findClosestPointFromRays(
      const std::vector<Triplet>& triplets) const;

  std::unique_ptr<const Logger> m_logger;

  const Logger& logger() const { return *m_logger; }
};

}  // namespace Acts

#include "Acts/Vertexing/SingleSeedVertexFinder.ipp"