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/TripletSeeder.hpp"
 
// Other
#include <memory>
#include <optional>
#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"};
 
  // Cylindrical 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"};
  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_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, ""};
 
  // 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<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]"};
 
  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:
  Acts::CylindricalSpacePointGrid::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;
 
  SG::ReadHandleKey<xAOD::VertexContainer> m_inputHoughVtxKey{this, "inputHoughVtx", "", "input vertex container"};
};
 
}  // namespace ActsTrk
 
#endif