GridTripletSeedingTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ACTSTRK_GRIDTRIPLETSEEDINGTOOL_GRIDTRIPLETSEEDINGTOOL_H
#define ACTSTRK_GRIDTRIPLETSEEDINGTOOL_GRIDTRIPLETSEEDINGTOOL_H
 
// ATHENA
#include "ActsInterop/Logger.h"
#include "ActsToolInterfaces/ISeedingTool.h"
#include "AthenaBaseComps/AthAlgTool.h"
#include "InDetIdentifier/PixelID.h"
#include "StoreGate/ReadHandleKey.h"
#include "xAODTracking/VertexContainer.h"
 
// ACTS CORE
#include "Acts/EventData/SeedContainer.hpp"
#include "Acts/EventData/SpacePointContainer.hpp"
#include "Acts/Seeding/BroadTripletSeedFilter.hpp"
#include "Acts/Seeding/CylindricalSpacePointGrid.hpp"
#include "Acts/Seeding/SphericalSpacePointGrid.hpp"
#include "Acts/Seeding/TripletSeeder.hpp"
 
// Other
#include <memory>
#include <optional>
#include <variant>
#include <vector>
 
namespace ActsTrk {
 
class GridTripletSeedingTool
    : public extends<AthAlgTool, ActsTrk::ISeedingTool> {
public:
  GridTripletSeedingTool(const std::string &type, const std::string &name,
                         const IInterface *parent);
 
  virtual StatusCode initialize() override;
 
  StatusCode createSeeds(const EventContext &ctx,
                         const std::vector<const xAOD::SpacePointContainer *>
                             &spacePointCollections,
                         const Eigen::Vector3f &beamSpotPos, float bFieldInZ,
                         ActsTrk::SeedContainer &seedContainer) const override;
 
protected:
  Gaudi::Property<bool> m_seedQualitySelection{
      this, "doSeedQualitySelection", true,
      "Select seed according to quality criteria"};
 
  // Use spherical grid. Most of the configs are shared with Cylindrical
  Gaudi::Property<bool> m_sphericalGrid{
      this, "sphericalGrid", false,
      "Use spherical grid instead of cylindrical grid for seeding"};
 
  // Space point grid properties. Some are also used for the seed
  // finder.
  Gaudi::Property<float> m_minPt{this, "minPt", 900. * Acts::UnitConstants::MeV,
                                 "lower pT cutoff for seeds"};
  Gaudi::Property<float> m_cotThetaMax{this, "cotThetaMax", 27.2899,
                                       "cot of maximum theta angle"};
  Gaudi::Property<float> m_zMin{this, "zMin", -3000. * Acts::UnitConstants::mm,
                                "limiting location of measurements"};
  Gaudi::Property<float> m_zMax{this, "zMax", 3000. * Acts::UnitConstants::mm,
                                "limiting location of measurements"};
  // Spherical grid specialities
  Gaudi::Property<float> m_etaMin{
      this, "etaMin", -3., "Eta range minimum (for spherical grid only)"};
  Gaudi::Property<float> m_etaMax{
      this, "etaMax", 3., "Eta range maximum (for spherical grid only)"};
  //
  Gaudi::Property<float> m_deltaRMax{
      this, "deltaRMax", 280. * Acts::UnitConstants::mm,
      "maximum distance in r between two measurements within one "
      "seed"};
  Gaudi::Property<float> m_impactMax{this, "impactMax",
                                     2. * Acts::UnitConstants::mm,
                                     "maximum impact parameter"};
  Gaudi::Property<std::vector<float>> m_zBinEdges{
      this,
      "zBinEdges",
      {-3000., -2700., -2500., -1400., -925., -500., -250., 250., 500., 925.,
       1400., 2500., 2700, 3000.},
      "enable non equidistant binning in z"};
  Gaudi::Property<std::vector<float>> m_etaBinEdges{
      this,
      "etaBinEdges",
      {-3., -1.8, -0.6, 0.6, 1.8, 3.},
      "enable non equidistant binning in eta (for spherical grid only)"};
  Gaudi::Property<std::vector<float>> m_rBinEdges{
      this,
      "rBinEdges",
      {0., 1100 * Acts::UnitConstants::mm},
      "enable non equidistant binning in radius"};
  Gaudi::Property<float> m_gridRMax{
      this, "gridRMax", 320. * Acts::UnitConstants::mm,
      "radial extension of subdetector to be used in grid building"};
  Gaudi::Property<float> m_gridPhiMin{this, "gridPhiMin",
                                      -std::numbers::pi_v<float>,
                                      "phi min for space point grid formation"};
  Gaudi::Property<float> m_gridPhiMax{this, "gridPhiMax",
                                      std::numbers::pi_v<float>,
                                      "phi max for space point grid formation"};
  Gaudi::Property<int> m_phiBinDeflectionCoverage{
      this, "phiBinDeflectionCoverage", 3,
      "sets of consecutive phi bins to cover full deflection of minimum pT "
      "particle"};
  Gaudi::Property<int> m_maxPhiBins{this, "maxPhiBins", 200,
                                    "max number of bins"};
 
  // Seed finder properties. Some are also used for the seed filter.
  Gaudi::Property<float> m_rMax{this, "rMax", 320. * Acts::UnitConstants::mm,
                                "limiting location of measurements"};
  Gaudi::Property<float> m_binSizeR{
      this, "binSizeR", 1. * Acts::UnitConstants::mm,
      "defining radial bin for space point sorting"};
  Gaudi::Property<float> m_deltaRMin{
      this, "deltaRMin", 20. * Acts::UnitConstants::mm,
      "minimum distance in r between two measurements within one "
      "seed"};
  Gaudi::Property<float> m_deltaRMinTopSP{
      this, "deltaRMinTopSP", 6. * Acts::UnitConstants::mm,
      "minimum distance in r between middle and top SP"};
  Gaudi::Property<float> m_deltaRMaxTopSP{
      this, "deltaRMaxTopSP", 280. * Acts::UnitConstants::mm,
      "maximum distance in r between middle and top SP"};
  Gaudi::Property<float> m_deltaRMinBottomSP{
      this, "deltaRMinBottomSP", 6. * Acts::UnitConstants::mm,
      "minimum distance in r between middle and top SP"};
  Gaudi::Property<float> m_deltaRMaxBottomSP{
      this, "deltaRMaxBottomSP", 150. * Acts::UnitConstants::mm,
      "maximum distance in r between middle and top SP"};
  Gaudi::Property<float> m_deltaZMax{
      this, "deltaZMax", 600,
      "maximum distance in z between two measurements within one seed"};
  Gaudi::Property<float> m_collisionRegionMin{
      this, "collisionRegionMin", -200. * Acts::UnitConstants::mm,
      "limiting location of collision region in z"};
  Gaudi::Property<float> m_collisionRegionMax{
      this, "collisionRegionMax", 200. * Acts::UnitConstants::mm,
      "limiting location of collision region in z"};
  Gaudi::Property<bool> m_useHVCollisionRegion{
      this, "useHVCollisionRegion", false,
      "restrict collision region by Hough vertex position"};
  Gaudi::Property<float> m_hvCollisionRegionTolerance{
      this, "hvCollisionRegionTolerance", 10. * Acts::UnitConstants::mm,
      "size of collision region when using Hough vertex"};
  Gaudi::Property<float> m_sigmaScattering{
      this, "sigmaScattering", 2.,
      "how many sigmas of scattering angle should be considered"};
  Gaudi::Property<float> m_maxPtScattering{
      this, "maxPtScattering", 10e6,
      "Upper pt limit for scattering calculation"};
  Gaudi::Property<float> m_radLengthPerSeed{
      this, "radLengthPerSeed", 0.098045,
      "average radiation lengths of material on the length of a seed. used for "
      "scattering"};
  Gaudi::Property<int> m_maxSeedsPerSpM{
      this, "maxSeedsPerSpM", 4,
      "In dense environments many seeds may be found per middle space point. "
      "Only seeds with the highest weight will be kept if this limit is "
      "reached."};
  Gaudi::Property<bool> m_interactionPointCut{
      this, "interactionPointCut", true,
      "Enable cut on the compatibility between interaction point and SPs"};
  Gaudi::Property<std::vector<size_t>> m_zBinsCustomLooping{
      this,
      "zBinsCustomLooping",
      {2, 3, 4, 5, 12, 11, 10, 9, 7, 6, 8},
      "defines order of z bins for looping; entries are 1-based local bin "
      "indices, i.e. within 1..(zBinEdges.size()-1), and must not repeat. "
      "Listing a subset skips the remaining bins, empty means all bins in "
      "their natural order"};
  Gaudi::Property<std::vector<std::size_t>> m_rBinsCustomLooping{
      this,
      "rBinsCustomLooping",
      {},
      "defines order of r bins for looping; entries are 1-based local bin "
      "indices, i.e. within 1..(rBinEdges.size()-1), and must not repeat. "
      "Listing a subset skips the remaining bins, empty means all bins in "
      "their natural order"};
  Gaudi::Property<bool> m_useVariableMiddleSPRange{
      this, "useVariableMiddleSPRange", true,
      "Enable variable range to search for middle SPs"};
  Gaudi::Property<std::vector<std::vector<double>>> m_rRangeMiddleSP{
      this,
      "rRangeMiddleSP",
      {{40.0, 90.0},
       {40.0, 90.0},
       {40.0, 200.0},
       {46.0, 200.0},
       {46.0, 200.0},
       {46.0, 250.0},
       {46.0, 250.0},
       {46.0, 250.0},
       {46.0, 200.0},
       {46.0, 200.0},
       {40.0, 200.0},
       {40.0, 90.0},
       {40.0, 90.0}},
      "radial range for middle SP"};
  Gaudi::Property<float> m_deltaRMiddleMinSPRange{
      this, "deltaRMiddleMinSPRange", 10., "delta R for middle SP range (min)"};
  Gaudi::Property<float> m_deltaRMiddleMaxSPRange{
      this, "deltaRMiddleMaxSPRange", 10., "delta R for middle SP range (max)"};
  Gaudi::Property<bool> m_seedConfirmation{this, "seedConfirmation", true,
                                           "run seed confirmation"};
  Gaudi::Property<float> m_seedConfCentralZMin{
      this, "seedConfCentralZMin", -250. * Acts::UnitConstants::mm,
      "minimum z for central seed confirmation "};
  Gaudi::Property<float> m_seedConfCentralZMax{
      this, "seedConfCentralZMax", 250. * Acts::UnitConstants::mm,
      "maximum z for central seed confirmation "};
  Gaudi::Property<float> m_seedConfCentralRMax{
      this, "seedConfCentralRMax", 140. * Acts::UnitConstants::mm,
      "maximum r for central seed confirmation "};
  Gaudi::Property<size_t> m_seedConfCentralNTopLargeR{
      this, "seedConfCentralNTopLargeR", 1,
      "nTop for large R central seed confirmation"};
  Gaudi::Property<size_t> m_seedConfCentralNTopSmallR{
      this, "seedConfCentralNTopSmallR", 2,
      "nTop for small R central seed confirmation"};
  Gaudi::Property<float> m_seedConfCentralMinBottomRadius{
      this, "seedConfCentralMinBottomRadius", 60 * Acts::UnitConstants::mm,
      "Minimum radius for bottom SP in seed confirmation"};
  Gaudi::Property<float> m_seedConfCentralMaxZOrigin{
      this, "seedConfCentralMaxZOrigin", 150 * Acts::UnitConstants::mm,
      "Maximum zOrigin in seed confirmation"};
  Gaudi::Property<float> m_seedConfCentralMinImpact{
      this, "seedConfCentralMinImpact", 1. * Acts::UnitConstants::mm,
      "Minimum impact parameter for seed confirmation"};
  Gaudi::Property<float> m_seedConfForwardZMin{
      this, "seedConfForwardZMin", -3000. * Acts::UnitConstants::mm,
      "minimum z for forward seed confirmation "};
  Gaudi::Property<float> m_seedConfForwardZMax{
      this, "seedConfForwardZMax", 3000. * Acts::UnitConstants::mm,
      "maximum z for forward seed confirmation "};
  Gaudi::Property<float> m_seedConfForwardRMax{
      this, "seedConfForwardRMax", 140. * Acts::UnitConstants::mm,
      "maximum r for forward seed confirmation "};
  Gaudi::Property<size_t> m_seedConfForwardNTopLargeR{
      this, "seedConfForwardNTopLargeR", 1,
      "nTop for large R forward seed confirmation"};
  Gaudi::Property<size_t> m_seedConfForwardNTopSmallR{
      this, "seedConfForwardNTopSmallR", 2,
      "nTop for small R forward seed confirmation"};
  Gaudi::Property<float> m_seedConfForwardMinBottomRadius{
      this, "seedConfForwardMinBottomRadius", 60 * Acts::UnitConstants::mm,
      "Minimum radius for bottom SP in seed confirmation"};
  Gaudi::Property<float> m_seedConfForwardMaxZOrigin{
      this, "seedConfForwardMaxZOrigin", 150 * Acts::UnitConstants::mm,
      "Maximum zOrigin in seed confirmation"};
  Gaudi::Property<float> m_seedConfForwardMinImpact{
      this, "seedConfForwardMinImpact", 1. * Acts::UnitConstants::mm,
      "Minimum impact parameter for seed confirmation"};
  Gaudi::Property<bool> m_useDetailedDoubleMeasurementInfo{
      this, "useDetailedDoubleMeasurementInfo", false,
      "enable use of double measurement details"};
 
  Gaudi::Property<float> m_toleranceParam{
      this, "toleranceParam", 1.1 * Acts::UnitConstants::mm,
      "tolerance parameter used to check the compatibility of SPs coordinates "
      "in xyz"};
  Gaudi::Property<float> m_maxStripDeltaCotTheta{
      this, "maxStripDeltaCotTheta", 1e10f,
      "maximum allowed |cotTheta_bottom - cotTheta_top| pre-filter for strip "
      "triplets before expensive coordinate checks"};
 
  Gaudi::Property<float> m_phiMin{this, "phiMin", -std::numbers::pi_v<float>,
                                  ""};
  Gaudi::Property<float> m_phiMax{this, "phiMax", std::numbers::pi_v<float>,
                                  ""};
  Gaudi::Property<float> m_rMin{this, "rMin", 0 * Acts::UnitConstants::mm, ""};
  Gaudi::Property<float> m_zAlign{this, "zAlign", 0 * Acts::UnitConstants::mm,
                                  ""};
  Gaudi::Property<float> m_rAlign{this, "rAlign", 0 * Acts::UnitConstants::mm,
                                  ""};
  Gaudi::Property<float> m_sigmaError{this, "sigmaError", 5, ""};
  Gaudi::Property<float> m_spacePointVarianceScale{
      this, "spacePointVarianceScale", 1.,
      "scale factor applied to the space point varianceR and varianceZ before "
      "they enter the triplet compatibility check"};
 
  // Seed filter properties
  Gaudi::Property<float> m_impactWeightFactor{
      this, "impactWeightFactor", 100.,
      "the impact parameters (d0) is multiplied by this factor and subtracted "
      "from weight"};
  Gaudi::Property<float> m_zOriginWeightFactor{this, "zOriginWeightFactor", 1.};
  Gaudi::Property<float> m_compatSeedWeight{
      this, "compatSeedWeight", 100.,
      "seed weight increased by this value if a compatible seed has been "
      "found"};
  Gaudi::Property<std::size_t> m_compatSeedLimit{
      this, "compatSeedLimit", 3,
      "how often do you want to increase the weight of a seed for finding a "
      "compatible seed"};
  Gaudi::Property<float> m_seedWeightIncrement{
      this, "seedWeightIncrement", 0., "increment in seed weight if needed"};
  Gaudi::Property<float> m_numSeedIncrement{
      this, "numSeedIncrement", 10e6,
      "increment in seed weight is applied if the number of compatible seeds "
      "is larger than numSeedIncrement"};
  Gaudi::Property<bool> m_seedConfirmationInFilter{
      this, "seedConfirmationInFilter", true, "run seed confirmation"};
  Gaudi::Property<std::size_t> m_maxSeedsPerSpMConf{
      this, "maxSeedsPerSpMConf", 5,
      "Maximum number of lower quality seeds in seed confirmation."};
  Gaudi::Property<std::size_t> m_maxQualitySeedsPerSpMConf{
      this, "maxQualitySeedsPerSpMConf", 5,
      "Maximum number of quality seeds for each middle-bottom SP-duplet in "
      "seed confirmation."};
  Gaudi::Property<bool> m_useDeltaRorTopRadius{
      this, "useDeltaRorTopRadius", true,
      "use deltaR (top radius - middle radius) instead of top radius"};
  Gaudi::Property<float> m_deltaInvHelixDiameter{
      this, "deltaInvHelixDiameter", 0.00003 * 1. / Acts::UnitConstants::mm,
      "the allowed delta between two inverted seed radii for them to be "
      "considered compatible"};
  Gaudi::Property<float> m_absDeltaEtaWeightFactor{
      this, "absDeltaEtaWeightFactor", 0.,
      "weight factor for abs(delta-eta) penalty between seed direction and "
      "beamspot-to-PCA direction (0 = disabled, typical LRT value: 10)"};
  Gaudi::Property<float> m_absDeltaEtaMinImpact{
      this, "absDeltaEtaMinImpact", 2. * Acts::UnitConstants::mm,
      "minimum impact parameter to apply abs(delta-eta) weight"};
 
  // Properties to set other objects used in seeding algorithm
  Gaudi::Property<std::vector<std::pair<int, int>>> m_zBinNeighborsTop{
      this,
      "zBinNeighborsTop",
      {{0, 0},
       {-1, 0},
       {-2, 0},
       {-1, 0},
       {-1, 0},
       {-1, 0},
       {-1, 1},
       {0, 1},
       {0, 1},
       {0, 1},
       {0, 2},
       {0, 1},
       {0, 0}},
      "vector containing the map of z bins in the top layers"};
  Gaudi::Property<std::vector<std::pair<int, int>>> m_zBinNeighborsBottom{
      this,
      "zBinNeighborsBottom",
      {{0, 0},
       {0, 1},
       {0, 1},
       {0, 1},
       {0, 1},
       {0, 1},
       {0, 0},
       {-1, 0},
       {-1, 0},
       {-1, 0},
       {-1, 0},
       {-1, 0},
       {0, 0}},
      "vector containing the map of z bins in the top layers"};
 
  Gaudi::Property<int> m_numEtaNeighbors{
      this, "numPhiNeighbors", 0,
      "number of eta bin neighbors at each side of the current bin that will "
      "be used to search for SPs"};
 
  Gaudi::Property<std::vector<std::pair<int, int>>> m_rBinNeighborsTop{
      this,
      "rBinNeighborsTop",
      {{0, 0}},
      "vector containing the map of radius bins in the top layers"};
  Gaudi::Property<std::vector<std::pair<int, int>>> m_rBinNeighborsBottom{
      this,
      "rBinNeighborsBottom",
      {{0, 0}},
      "vector containing the map of radius bins in the bottom layers"};
  Gaudi::Property<int> m_numPhiNeighbors{
      this, "numPhiNeighbors", 1,
      "number of phi bin neighbors at each side of the current bin that will "
      "be used to search for SPs"};
 
  Gaudi::Property<bool> m_useExperimentCuts{this, "useExperimentCuts", false,
                                            ""};
 
  // per-pair azimuthal-swing doublet cut (displaced-aware, same physics as
  // the GBTS phi window): independent of useExperimentCuts so that the
  // pixel-specific experiment cuts stay off for strip instances
  Gaudi::Property<bool> m_doubletDPhiCut{
      this, "doubletDPhiCut", false,
      "apply the per-pair azimuthal-swing doublet cut"};
  Gaudi::Property<float> m_doubletDPhiD0Max{
      this, "doubletDPhiD0Max", -1.,
      "impact parameter bounding the doublet phi swing; negative uses "
      "impactMax"};
  Gaudi::Property<float> m_doubletDPhiCap{
      this, "doubletDPhiCap", 10., "cap on the displaced phi-swing term [rad]"};
  Gaudi::Property<float> m_doubletDPhiConst{
      this, "doubletDPhiConst", 0.015,
      "constant term of the prompt doublet phi window [rad]"};
  Gaudi::Property<float> m_doubletDPhiSlope{
      this, "doubletDPhiSlope", 2.0e-4,
      "curvature term of the prompt doublet phi window [rad/mm]"};
 
  // strip calibration doublet cut, with the doublet chord as direction
  Gaudi::Property<bool> m_doubletStripCalibrationCut{
      this, "doubletStripCalibrationCut", false,
      "reject strip doublets whose chord misses either strip pair"};
  Gaudi::Property<float> m_doubletStripCalibrationTolerance{
      this, "doubletStripCalibrationTolerance", 2.,
      "strip calibration doublet cut tolerance [half strip lengths]"};
  Gaudi::Property<float> m_stripCalibrationTolerance{
      this, "stripCalibrationTolerance", -1.,
      "if positive, ACTS calibrates both strip SPs of a doublet against their "
      "chord with this tolerance [half strip lengths] and uses the calibrated "
      "positions for the doublet. Negative values disable it"};
 
  Gaudi::Property<int> m_stateVectorReserveSize{
      this, "stateVectorReserveSize", 500,
      "Size of the initial Seeding State internal vectors"};
 
  Gaudi::Property<float> m_expCutrMin{this, "SpSelectionExpCutrMin",
                                      45. * Acts::UnitConstants::mm};
 
private:
  std::variant<Acts::CylindricalSpacePointGrid::Config,
               Acts::Experimental::SphericalSpacePointGrid::Config>
      m_gridCfg;
  Acts::DoubletSeedFinder::Config m_bottomDoubletFinderCfg;
  Acts::DoubletSeedFinder::Config m_topDoubletFinderCfg;
  Acts::TripletSeedFinder::Config m_tripletFinderCfg;
  Acts::BroadTripletSeedFilter::Config m_filterCfg;
 
  std::optional<Acts::TripletSeeder> m_finder;

  std::unique_ptr<const Acts::Logger> m_logger;
  std::unique_ptr<const Acts::Logger> m_loggerFilter;
 
  const PixelID *m_pixelId{nullptr};

  const Acts::Logger &logger() const { return *m_logger; }
 
  bool spacePointSelectionFunction(const xAOD::SpacePoint *sp, float r) const;

  bool doubletSelectionFunction(const std::vector<float> &spPhi,
                                const std::vector<float> &spAsinD0OverR,
                                const Acts::ConstSpacePointProxy &middle,
                                const Acts::ConstSpacePointProxy &other,
                                float cotTheta, bool isBottomCandidate) const;
 
  std::pair<float, float> retrieveRadiusRangeForMiddle(
      const Acts::ConstSpacePointProxy &spM,
      const Acts::Range1D<float> &rMiddleSpRange) const;
 
  template <typename GridType>
  StatusCode createSeedsImpl(const EventContext &ctx,
                             const std::vector<const xAOD::SpacePointContainer *>
                             &spacePointCollections,
                             const Eigen::Vector3f &beamSpotPos, float bFieldInZ,
                             ActsTrk::SeedContainer &seedContainer,
                             GridType::Config gridCfg) const;
 
  SG::ReadHandleKey<xAOD::VertexContainer> m_inputHoughVtxKey{
    this, "inputHoughVtx", "", "input vertex container"};
 
};
 
} // namespace ActsTrk
 
#endif