ActsTrk::GridTripletSeedingTool Class Reference

#include <GridTripletSeedingTool.h>

Inheritance diagram for ActsTrk::GridTripletSeedingTool:

Collaboration diagram for ActsTrk::GridTripletSeedingTool:

Public Member Functions
	GridTripletSeedingTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
StatusCode	createSeeds2 (const EventContext &ctx, const std::vector< const xAOD::SpacePointContainer * > &spacePointCollections, const Eigen::Vector3f &beamSpotPos, float bFieldInZ, ActsTrk::SeedContainer &seedContainer) const override

Protected Attributes
Gaudi::Property< bool >	m_seedQualitySelection
Gaudi::Property< float >	m_minPt
Gaudi::Property< float >	m_cotThetaMax
Gaudi::Property< float >	m_zMin
Gaudi::Property< float >	m_zMax
Gaudi::Property< float >	m_deltaRMax
Gaudi::Property< float >	m_impactMax
Gaudi::Property< std::vector< float > >	m_zBinEdges
Gaudi::Property< std::vector< float > >	m_rBinEdges
Gaudi::Property< float >	m_gridRMax
Gaudi::Property< float >	m_gridPhiMin
Gaudi::Property< float >	m_gridPhiMax
Gaudi::Property< int >	m_phiBinDeflectionCoverage
Gaudi::Property< int >	m_maxPhiBins
Gaudi::Property< float >	m_rMax
Gaudi::Property< float >	m_binSizeR
Gaudi::Property< float >	m_deltaRMin
Gaudi::Property< float >	m_deltaRMinTopSP
Gaudi::Property< float >	m_deltaRMaxTopSP
Gaudi::Property< float >	m_deltaRMinBottomSP
Gaudi::Property< float >	m_deltaRMaxBottomSP
Gaudi::Property< float >	m_deltaZMax
Gaudi::Property< float >	m_collisionRegionMin
Gaudi::Property< float >	m_collisionRegionMax
Gaudi::Property< float >	m_sigmaScattering
Gaudi::Property< float >	m_maxPtScattering
Gaudi::Property< float >	m_radLengthPerSeed
Gaudi::Property< int >	m_maxSeedsPerSpM
Gaudi::Property< bool >	m_interactionPointCut
Gaudi::Property< std::vector< size_t > >	m_zBinsCustomLooping
Gaudi::Property< std::vector< std::size_t > >	m_rBinsCustomLooping
Gaudi::Property< bool >	m_useVariableMiddleSPRange
Gaudi::Property< std::vector< std::vector< double > > >	m_rRangeMiddleSP
Gaudi::Property< float >	m_deltaRMiddleMinSPRange
Gaudi::Property< float >	m_deltaRMiddleMaxSPRange
Gaudi::Property< bool >	m_seedConfirmation
Gaudi::Property< float >	m_seedConfCentralZMin
Gaudi::Property< float >	m_seedConfCentralZMax
Gaudi::Property< float >	m_seedConfCentralRMax
Gaudi::Property< size_t >	m_seedConfCentralNTopLargeR
Gaudi::Property< size_t >	m_seedConfCentralNTopSmallR
Gaudi::Property< float >	m_seedConfCentralMinBottomRadius
Gaudi::Property< float >	m_seedConfCentralMaxZOrigin
Gaudi::Property< float >	m_seedConfCentralMinImpact
Gaudi::Property< float >	m_seedConfForwardZMin
Gaudi::Property< float >	m_seedConfForwardZMax
Gaudi::Property< float >	m_seedConfForwardRMax
Gaudi::Property< size_t >	m_seedConfForwardNTopLargeR
Gaudi::Property< size_t >	m_seedConfForwardNTopSmallR
Gaudi::Property< float >	m_seedConfForwardMinBottomRadius
Gaudi::Property< float >	m_seedConfForwardMaxZOrigin
Gaudi::Property< float >	m_seedConfForwardMinImpact
Gaudi::Property< bool >	m_useDetailedDoubleMeasurementInfo
Gaudi::Property< float >	m_toleranceParam
Gaudi::Property< float >	m_phiMin
Gaudi::Property< float >	m_phiMax
Gaudi::Property< float >	m_rMin {this, "rMin", 0 * Acts::UnitConstants::mm, ""}
Gaudi::Property< float >	m_zAlign
Gaudi::Property< float >	m_rAlign
Gaudi::Property< float >	m_sigmaError {this, "sigmaError", 5, ""}
Gaudi::Property< float >	m_impactWeightFactor
Gaudi::Property< float >	m_zOriginWeightFactor {this, "zOriginWeightFactor", 1.}
Gaudi::Property< float >	m_compatSeedWeight
Gaudi::Property< std::size_t >	m_compatSeedLimit
Gaudi::Property< float >	m_seedWeightIncrement
Gaudi::Property< float >	m_numSeedIncrement
Gaudi::Property< bool >	m_seedConfirmationInFilter
Gaudi::Property< std::size_t >	m_maxSeedsPerSpMConf
Gaudi::Property< std::size_t >	m_maxQualitySeedsPerSpMConf
Gaudi::Property< bool >	m_useDeltaRorTopRadius
Gaudi::Property< float >	m_deltaInvHelixDiameter
Gaudi::Property< std::vector< std::pair< int, int > > >	m_zBinNeighborsTop
Gaudi::Property< std::vector< std::pair< int, int > > >	m_zBinNeighborsBottom
Gaudi::Property< std::vector< std::pair< int, int > > >	m_rBinNeighborsTop
Gaudi::Property< std::vector< std::pair< int, int > > >	m_rBinNeighborsBottom
Gaudi::Property< int >	m_numPhiNeighbors
Gaudi::Property< bool >	m_useExperimentCuts
Gaudi::Property< int >	m_stateVectorReserveSize
Gaudi::Property< float >	m_expCutrMin

Private Member Functions
const Acts::Logger &	logger () const
	Private access to the logger. More...
bool	spacePointSelectionFunction (const xAOD::SpacePoint *sp, float r) const
bool	doubletSelectionFunction (const Acts::Experimental::ConstSpacePointProxy2 &middle, const Acts::Experimental::ConstSpacePointProxy2 &other, float cotTheta, bool isBottomCandidate) const
std::pair< float, float >	retrieveRadiusRangeForMiddle (const Acts::Experimental::ConstSpacePointProxy2 &spM, const Acts::Range1D< float > &rMiddleSpRange) const

Private Attributes
Acts::Experimental::CylindricalSpacePointGrid2::Config	m_gridCfg
Acts::Experimental::DoubletSeedFinder::Config	m_bottomDoubletFinderCfg
Acts::Experimental::DoubletSeedFinder::Config	m_topDoubletFinderCfg
Acts::Experimental::TripletSeedFinder::Config	m_tripletFinderCfg
Acts::Experimental::BroadTripletSeedFilter::Config	m_filterCfg
std::optional< Acts::Experimental::TripletSeeder >	m_finder
std::unique_ptr< const Acts::Logger >	m_logger
	logging instance More...
std::unique_ptr< const Acts::Logger >	m_loggerFilter
const PixelID *	m_pixelId {nullptr}

Detailed Description

Definition at line 27 of file GridTripletSeedingTool.h.

Constructor & Destructor Documentation

GridTripletSeedingTool()

ActsTrk::GridTripletSeedingTool::GridTripletSeedingTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 9 of file GridTripletSeedingTool.cxx.

    : base_class(type, name, parent) {}

Member Function Documentation

createSeeds2()

StatusCode ActsTrk::GridTripletSeedingTool::createSeeds2 ( const EventContext &  ctx, const std::vector< const xAOD::SpacePointContainer * > &  spacePointCollections, const Eigen::Vector3f &  beamSpotPos, float  bFieldInZ, ActsTrk::SeedContainer &  seedContainer  ) const

override

Definition at line 388 of file GridTripletSeedingTool.cxx.

                                               {
  (void)ctx;
 
  auto gridCfg = m_gridCfg;
  gridCfg.bFieldInZ = bFieldInZ;
 
  Acts::Experimental::CylindricalSpacePointGrid2 grid(
      gridCfg, logger().cloneWithSuffix("Grid"));
 
  std::size_t totalSpacePoints = 0;
  for (const xAOD::SpacePointContainer* spacePoints : spacePointCollections) {
    totalSpacePoints += spacePoints->size();
  }
 
  std::vector<const xAOD::SpacePoint*> selectedXAODSpacePoints;
  std::vector<float> selectedSpacePointsR;
  selectedXAODSpacePoints.reserve(totalSpacePoints);
  selectedSpacePointsR.reserve(totalSpacePoints);
 
  for (const xAOD::SpacePointContainer* spacePoints : spacePointCollections) {
    for (const xAOD::SpacePoint* sp : *spacePoints) {
      float x = static_cast<float>(sp->x() - beamSpotPos[0]);
      float y = static_cast<float>(sp->y() - beamSpotPos[1]);
      float z = static_cast<float>(sp->z());
      float r = std::hypot(x, y);
      float phi = std::atan2(y, x);
 
      if (m_useExperimentCuts && !spacePointSelectionFunction(sp, r)) {
        continue;
      }
 
      grid.insert(selectedXAODSpacePoints.size(), phi, z, r);
      selectedXAODSpacePoints.push_back(sp);
      selectedSpacePointsR.push_back(r);
    }
  }
 
  for (std::size_t i = 0; i < grid.numberOfBins(); ++i) {
    std::ranges::sort(
        grid.at(i), [&](const Acts::Experimental::SpacePointIndex2& a,
                        const Acts::Experimental::SpacePointIndex2& b) {
          return selectedSpacePointsR[a] < selectedSpacePointsR[b];
        });
  }
 
  Acts::Experimental::SpacePointContainer2 selectedSpacePoints;
  selectedSpacePoints.createColumns(
      Acts::Experimental::SpacePointColumns::SourceLinks |
      Acts::Experimental::SpacePointColumns::XY |
      Acts::Experimental::SpacePointColumns::ZR |
      Acts::Experimental::SpacePointColumns::VarianceZ |
      Acts::Experimental::SpacePointColumns::VarianceR);
  if (m_useDetailedDoubleMeasurementInfo) {
    selectedSpacePoints.createColumns(
        Acts::Experimental::SpacePointColumns::Strip);
  }
  selectedSpacePoints.reserve(grid.numberOfSpacePoints());
  std::vector<Acts::Experimental::SpacePointIndex2> copyFromIndices;
  copyFromIndices.reserve(grid.numberOfSpacePoints());
  std::vector<Acts::Experimental::SpacePointIndexRange2> gridSpacePointRanges;
  gridSpacePointRanges.reserve(grid.numberOfBins());
  for (std::size_t i = 0; i < grid.numberOfBins(); ++i) {
    std::uint32_t begin = selectedSpacePoints.size();
    for (const Acts::Experimental::SpacePointIndex2 spIndex : grid.at(i)) {
      const xAOD::SpacePoint* sp = selectedXAODSpacePoints[spIndex];
 
      auto newSp = selectedSpacePoints.createSpacePoint();
      newSp.assignSourceLinks(
          std::array<Acts::SourceLink, 1>{Acts::SourceLink(sp)});
      newSp.xy() = std::array<float, 2>{static_cast<float>(sp->x() - beamSpotPos[0]),
                                        static_cast<float>(sp->y() - beamSpotPos[1])};
      newSp.zr() = std::array<float, 2>{static_cast<float>(sp->z()),
                                        selectedSpacePointsR[spIndex]};
      newSp.varianceZ() = static_cast<float>(sp->varianceZ());
      newSp.varianceR() = static_cast<float>(sp->varianceR());
      if (m_useDetailedDoubleMeasurementInfo) {
        newSp.topStripVector() =
            sp->topHalfStripLength() * sp->topStripDirection();
        newSp.bottomStripVector() =
            sp->bottomHalfStripLength() * sp->bottomStripDirection();
        newSp.stripCenterDistance() = sp->stripCenterDistance();
        newSp.topStripCenter() = sp->topStripCenter();
      }
 
      copyFromIndices.push_back(spIndex);
    }
    std::uint32_t end = selectedSpacePoints.size();
    gridSpacePointRanges.emplace_back(begin, end);
  }
 
  // clear temporary
  selectedXAODSpacePoints = {};
  selectedSpacePointsR = {};
 
  ACTS_VERBOSE("Number of space points after selection "
               << selectedSpacePoints.size() << " out of " << totalSpacePoints);
 
  // Compute radius range. We rely on the fact the grid is storing the proxies
  // with a sorting in the radius
  const Acts::Range1D<float> rRange = [&]() -> Acts::Range1D<float> {
    float minRange = std::numeric_limits<float>::max();
    float maxRange = std::numeric_limits<float>::lowest();
    for (const Acts::Experimental::SpacePointIndexRange2& range :
         gridSpacePointRanges) {
      if (range.first == range.second) {
        continue;
      }
      auto first = selectedSpacePoints[range.first];
      auto last = selectedSpacePoints[range.second - 1];
      minRange = std::min(first.zr()[1], minRange);
      maxRange = std::max(last.zr()[1], maxRange);
    }
    return {minRange, maxRange};
  }();
 
  auto bottomDoubletFinder = Acts::Experimental::DoubletSeedFinder::create(
      Acts::Experimental::DoubletSeedFinder::DerivedConfig(
          m_bottomDoubletFinderCfg, bFieldInZ));
  auto topDoubletFinder = Acts::Experimental::DoubletSeedFinder::create(
      Acts::Experimental::DoubletSeedFinder::DerivedConfig(
          m_topDoubletFinderCfg, bFieldInZ));
  auto tripletFinder = Acts::Experimental::TripletSeedFinder::create(
      Acts::Experimental::TripletSeedFinder::DerivedConfig(m_tripletFinderCfg,
                                                           bFieldInZ));
 
  // variable middle SP radial region of interest
  const Acts::Range1D<float> rMiddleSpRange(
      std::floor(rRange.min() / 2) * 2 + m_deltaRMiddleMinSPRange,
      std::floor(rRange.max() / 2) * 2 - m_deltaRMiddleMaxSPRange);
 
  Acts::Experimental::BroadTripletSeedFilter::State filterState;
  Acts::Experimental::BroadTripletSeedFilter::Cache filterCache;
  Acts::Experimental::TripletSeeder::Cache cache;
 
  Acts::Experimental::BroadTripletSeedFilter filter(
      m_filterCfg, filterState, filterCache, *m_loggerFilter);
 
  std::vector<Acts::Experimental::SpacePointContainer2::ConstRange>
      bottomSpRanges;
  std::optional<Acts::Experimental::SpacePointContainer2::ConstRange>
      middleSpRange;
  std::vector<Acts::Experimental::SpacePointContainer2::ConstRange> topSpRanges;
 
  Acts::Experimental::SeedContainer2 tmpSeedContainer;
  tmpSeedContainer.reserve(seedContainer.capacity());
 
  for (const auto [bottom, middle, top] : grid.binnedGroup()) {
    ACTS_VERBOSE("Process middle bin " << middle);
    if (middle >= gridSpacePointRanges.size()) {
      ATH_MSG_ERROR("Grid Binned Group returned an unreasonable middle bin");
      return StatusCode::FAILURE;
    }
 
    bottomSpRanges.clear();
    topSpRanges.clear();
 
    std::ranges::transform(
        bottom, std::back_inserter(bottomSpRanges),
        [&](std::size_t b)
            -> Acts::Experimental::SpacePointContainer2::ConstRange {
          return selectedSpacePoints.range(gridSpacePointRanges[b]).asConst();
        });
    middleSpRange =
        selectedSpacePoints.range(gridSpacePointRanges[middle]).asConst();
    std::ranges::transform(
        top, std::back_inserter(topSpRanges),
        [&](std::size_t t)
            -> Acts::Experimental::SpacePointContainer2::ConstRange {
          return selectedSpacePoints.range(gridSpacePointRanges[t]).asConst();
        });
 
    // we compute this here since all middle space point candidates belong to
    // the same z-bin
    auto firstMiddleSp = middleSpRange->front();
    auto radiusRangeForMiddle =
        retrieveRadiusRangeForMiddle(firstMiddleSp, rMiddleSpRange);
 
    ACTS_VERBOSE("Validity range (radius) for the middle space point is ["
                 << radiusRangeForMiddle.first << ", "
                 << radiusRangeForMiddle.second << "]");
 
    m_finder->createSeedsFromGroups(
        cache, *bottomDoubletFinder, *topDoubletFinder, *tripletFinder, filter,
        selectedSpacePoints, bottomSpRanges, *middleSpRange, topSpRanges,
        radiusRangeForMiddle, tmpSeedContainer);
  }
 
  // Selection function - temporary implementation
  // need change from ACTS for final implementation
  // To be used only on PPP
  auto selectionFunction =
      [&filterState](
          const Acts::Experimental::MutableSeedProxy2& seed) -> bool {
    float seedQuality = seed.quality();
    float bottomQuality =
        filterState.bestSeedQualityMap.at(seed.spacePointIndices()[0]);
    float middleQuality =
        filterState.bestSeedQualityMap.at(seed.spacePointIndices()[1]);
    float topQuality =
        filterState.bestSeedQualityMap.at(seed.spacePointIndices()[2]);
 
    return bottomQuality <= seedQuality || middleQuality <= seedQuality ||
           topQuality <= seedQuality;
  };
 
  seedContainer.reserve(tmpSeedContainer.size());
 
  // Select the seeds
  for (Acts::Experimental::MutableSeedProxy2 seed : tmpSeedContainer) {
    if (m_seedQualitySelection && !selectionFunction(seed)) {
      continue;
    }
 
    const xAOD::SpacePoint* bottom =
        selectedSpacePoints.at(seed.spacePointIndices()[0])
            .sourceLinks()[0]
            .get<const xAOD::SpacePoint*>();
    const xAOD::SpacePoint* middle =
        selectedSpacePoints.at(seed.spacePointIndices()[1])
            .sourceLinks()[0]
            .get<const xAOD::SpacePoint*>();
    const xAOD::SpacePoint* top =
        selectedSpacePoints.at(seed.spacePointIndices()[2])
            .sourceLinks()[0]
            .get<const xAOD::SpacePoint*>();
 
    auto outputSeed = std::make_unique<ActsTrk::Seed>(*bottom, *middle, *top);
    outputSeed->setVertexZ(seed.vertexZ());
    outputSeed->setQuality(seed.quality());
    seedContainer.push_back(std::move(outputSeed));
  }
 
  return StatusCode::SUCCESS;
}

doubletSelectionFunction()

bool ActsTrk::GridTripletSeedingTool::doubletSelectionFunction ( const Acts::Experimental::ConstSpacePointProxy2 &  middle, const Acts::Experimental::ConstSpacePointProxy2 &  other, float  cotTheta, bool  isBottomCandidate  ) const

private

Definition at line 337 of file GridTripletSeedingTool.cxx.

                                  {
  // We remove some doublets that have the middle space point in some specific areas
  // This should eventually be moved inside ACTS and allow a veto mechanism according
  // to the user desire.
  // As of now we cannot really do this since we define a range of validity of the middle
  // candidate, and if we want to veto some sub-regions inside it, we need to do it here.
  if (std::abs(middle.zr()[0]) > 1500 and
      middle.zr()[1] > 100 and middle.zr()[1] < 150) {
    return false;
  }
  
  // We remove here some seeds, in case the bottom space point radius is
  // too small (i.e. < fastTrackingRMin)
 
  // This operation is done only within a specific eta window
  // Instead of eta we use the doublet cottheta
  static constexpr float cotThetaEta120 = 1.5095;
  static constexpr float cotThetaEta360 = 18.2855;
 
  float absCotTheta = std::abs(cotTheta);
  if (isBottomCandidate && other.zr()[1] < m_expCutrMin &&
      absCotTheta > cotThetaEta120 && absCotTheta < cotThetaEta360) {
    return false;
  }
 
  return true;
}

initialize()

StatusCode ActsTrk::GridTripletSeedingTool::initialize ( )

overridevirtual

Definition at line 14 of file GridTripletSeedingTool.cxx.

                                              {
  ATH_MSG_DEBUG("Initializing " << name() << "...");
 
  ATH_MSG_DEBUG("Properties Summary:");
  ATH_MSG_DEBUG("   " << m_zBinNeighborsTop);
  ATH_MSG_DEBUG("   " << m_zBinNeighborsBottom);
  ATH_MSG_DEBUG("   " << m_rBinNeighborsTop);
  ATH_MSG_DEBUG("   " << m_rBinNeighborsBottom);
  ATH_MSG_DEBUG("   " << m_numPhiNeighbors);
 
  ATH_MSG_DEBUG(" *  Used by space point grid config:");
  ATH_MSG_DEBUG("   " << m_minPt);
  ATH_MSG_DEBUG("   " << m_cotThetaMax);
  ATH_MSG_DEBUG("   " << m_impactMax);
  ATH_MSG_DEBUG("   " << m_zMin);
  ATH_MSG_DEBUG("   " << m_zMax);
  ATH_MSG_DEBUG("   " << m_gridPhiMin);
  ATH_MSG_DEBUG("   " << m_gridPhiMax);
  ATH_MSG_DEBUG("   " << m_zBinEdges);
  ATH_MSG_DEBUG("   " << m_rBinEdges);
  ATH_MSG_DEBUG("   " << m_deltaRMax);
  ATH_MSG_DEBUG("   " << m_gridRMax);
  ATH_MSG_DEBUG("   " << m_phiBinDeflectionCoverage);
 
  ATH_MSG_DEBUG(" * Used by seed finder config:");
  ATH_MSG_DEBUG("   " << m_minPt);
  ATH_MSG_DEBUG("   " << m_cotThetaMax);
  ATH_MSG_DEBUG("   " << m_impactMax);
  ATH_MSG_DEBUG("   " << m_zMin);
  ATH_MSG_DEBUG("   " << m_zMax);
  ATH_MSG_DEBUG("   " << m_zBinEdges);
  ATH_MSG_DEBUG("   " << m_rMax);
  ATH_MSG_DEBUG("   " << m_deltaRMin);
  ATH_MSG_DEBUG("   " << m_deltaRMax);
  ATH_MSG_DEBUG("   " << m_deltaRMinTopSP);
  ATH_MSG_DEBUG("   " << m_deltaRMaxTopSP);
  ATH_MSG_DEBUG("   " << m_deltaRMinBottomSP);
  ATH_MSG_DEBUG("   " << m_deltaRMaxBottomSP);
  ATH_MSG_DEBUG("   " << m_deltaZMax);
  ATH_MSG_DEBUG("   " << m_collisionRegionMin);
  ATH_MSG_DEBUG("   " << m_collisionRegionMax);
  ATH_MSG_DEBUG("   " << m_sigmaScattering);
  ATH_MSG_DEBUG("   " << m_maxPtScattering);
  ATH_MSG_DEBUG("   " << m_radLengthPerSeed);
  ATH_MSG_DEBUG("   " << m_maxSeedsPerSpM);
  ATH_MSG_DEBUG("   " << m_interactionPointCut);
  ATH_MSG_DEBUG("   " << m_zBinsCustomLooping);
  ATH_MSG_DEBUG("   " << m_rBinsCustomLooping);
  ATH_MSG_DEBUG("   " << m_useVariableMiddleSPRange);
  if (m_useVariableMiddleSPRange) {
    ATH_MSG_DEBUG("   " << m_deltaRMiddleMinSPRange);
    ATH_MSG_DEBUG("   " << m_deltaRMiddleMaxSPRange);
  } else if (not m_rRangeMiddleSP.empty())
    ATH_MSG_DEBUG("   " << m_rRangeMiddleSP);
  ATH_MSG_DEBUG("   " << m_seedConfirmation);
  if (m_seedConfirmation) {
    ATH_MSG_DEBUG("   " << m_seedConfCentralZMin);
    ATH_MSG_DEBUG("   " << m_seedConfCentralZMax);
    ATH_MSG_DEBUG("   " << m_seedConfCentralRMax);
    ATH_MSG_DEBUG("   " << m_seedConfCentralNTopLargeR);
    ATH_MSG_DEBUG("   " << m_seedConfCentralNTopSmallR);
    ATH_MSG_DEBUG("   " << m_seedConfCentralMinBottomRadius);
    ATH_MSG_DEBUG("   " << m_seedConfCentralMaxZOrigin);
    ATH_MSG_DEBUG("   " << m_seedConfCentralMinImpact);
    ATH_MSG_DEBUG("   " << m_seedConfForwardZMin);
    ATH_MSG_DEBUG("   " << m_seedConfForwardZMax);
    ATH_MSG_DEBUG("   " << m_seedConfForwardRMax);
    ATH_MSG_DEBUG("   " << m_seedConfForwardNTopLargeR);
    ATH_MSG_DEBUG("   " << m_seedConfForwardNTopSmallR);
    ATH_MSG_DEBUG("   " << m_seedConfForwardMinBottomRadius);
    ATH_MSG_DEBUG("   " << m_seedConfForwardMaxZOrigin);
    ATH_MSG_DEBUG("   " << m_seedConfForwardMinImpact);
  }
  ATH_MSG_DEBUG("   " << m_useDetailedDoubleMeasurementInfo);
  ATH_MSG_DEBUG("   " << m_toleranceParam);
  ATH_MSG_DEBUG("   " << m_phiMin);
  ATH_MSG_DEBUG("   " << m_phiMax);
  ATH_MSG_DEBUG("   " << m_rMin);
  ATH_MSG_DEBUG("   " << m_zAlign);
  ATH_MSG_DEBUG("   " << m_rAlign);
  ATH_MSG_DEBUG("   " << m_sigmaError);
 
  ATH_MSG_DEBUG(" * Used by seed filter config:");
  ATH_MSG_DEBUG("   " << m_deltaRMin);
  ATH_MSG_DEBUG("   " << m_maxSeedsPerSpM);
  ATH_MSG_DEBUG("   " << m_useDeltaRorTopRadius);
  ATH_MSG_DEBUG("   " << m_seedConfirmationInFilter);
  if (m_seedConfirmationInFilter) {
    ATH_MSG_DEBUG("   " << m_maxSeedsPerSpMConf);
    ATH_MSG_DEBUG("   " << m_maxQualitySeedsPerSpMConf);
    ATH_MSG_DEBUG("   " << m_seedConfCentralZMin);
    ATH_MSG_DEBUG("   " << m_seedConfCentralZMax);
    ATH_MSG_DEBUG("   " << m_seedConfCentralRMax);
    ATH_MSG_DEBUG("   " << m_seedConfCentralNTopLargeR);
    ATH_MSG_DEBUG("   " << m_seedConfCentralNTopSmallR);
    ATH_MSG_DEBUG("   " << m_seedConfCentralMinBottomRadius);
    ATH_MSG_DEBUG("   " << m_seedConfCentralMaxZOrigin);
    ATH_MSG_DEBUG("   " << m_seedConfCentralMinImpact);
    ATH_MSG_DEBUG("   " << m_seedConfForwardZMin);
    ATH_MSG_DEBUG("   " << m_seedConfForwardZMax);
    ATH_MSG_DEBUG("   " << m_seedConfForwardRMax);
    ATH_MSG_DEBUG("   " << m_seedConfForwardNTopLargeR);
    ATH_MSG_DEBUG("   " << m_seedConfForwardNTopSmallR);
    ATH_MSG_DEBUG("   " << m_seedConfForwardMinBottomRadius);
    ATH_MSG_DEBUG("   " << m_seedConfForwardMaxZOrigin);
    ATH_MSG_DEBUG("   " << m_seedConfForwardMinImpact);
  }
  ATH_MSG_DEBUG("   " << m_impactWeightFactor);
  ATH_MSG_DEBUG("   " << m_compatSeedWeight);
  ATH_MSG_DEBUG("   " << m_compatSeedLimit);
  ATH_MSG_DEBUG("   " << m_seedWeightIncrement);
  ATH_MSG_DEBUG("   " << m_numSeedIncrement);
  ATH_MSG_DEBUG("   " << m_deltaInvHelixDiameter);
 
  // Make the logger && Propagate to ACTS routines
  m_logger = makeActsAthenaLogger(this, "Acts");
 
  if (m_zBinEdges.size() - 1 != m_zBinNeighborsTop.size() &&
      not m_zBinNeighborsTop.empty()) {
    ATH_MSG_ERROR("Inconsistent config zBinNeighborsTop");
    return StatusCode::FAILURE;
  }
 
  if (m_zBinEdges.size() - 1 != m_zBinNeighborsBottom.size() &&
      not m_zBinNeighborsBottom.empty()) {
    ATH_MSG_ERROR("Inconsistent config zBinNeighborsBottom");
    return StatusCode::FAILURE;
  }
 
  if (m_rBinEdges.size() - 1 != m_rBinNeighborsTop.size() &&
      not m_rBinNeighborsTop.empty()) {
    ATH_MSG_ERROR("Inconsistent config rBinNeighborsTop");
    return StatusCode::FAILURE;
  }
 
  if (m_rBinEdges.size() - 1 != m_rBinNeighborsBottom.size() &&
      not m_rBinNeighborsBottom.empty()) {
    ATH_MSG_ERROR("Inconsistent config rBinNeighborsBottom");
    return StatusCode::FAILURE;
  }
 
  if (m_zBinsCustomLooping.size() != 0) {
    // zBinsCustomLooping can contain a number of elements <= to the total
    // number of bin in zBinEdges
    for (std::size_t i : m_zBinsCustomLooping) {
      if (i >= m_zBinEdges.size()) {
        ATH_MSG_ERROR(
            "Inconsistent config zBinsCustomLooping contains bins that are not "
            "in zBinEdges");
        return StatusCode::FAILURE;
      }
    }
  }
 
  if (m_rBinsCustomLooping.size() != 0) {
    for (std::size_t i : m_rBinsCustomLooping) {
      if (i >= m_rBinEdges.size()) {
        ATH_MSG_ERROR(
            "Inconsistent config rBinsCustomLooping contains bins that are not "
            "in rBinEdges");
        return StatusCode::FAILURE;
      }
    }
  }
 
  m_gridCfg.minPt = m_minPt;
  m_gridCfg.rMin = 0;
  m_gridCfg.rMax = m_gridRMax;
  m_gridCfg.zMin = m_zMin;
  m_gridCfg.zMax = m_zMax;
  m_gridCfg.deltaRMax = m_deltaRMax;
  m_gridCfg.cotThetaMax = m_cotThetaMax;
  m_gridCfg.impactMax = m_impactMax;
  m_gridCfg.phiMin = m_gridPhiMin;
  m_gridCfg.phiMax = m_gridPhiMax;
  m_gridCfg.phiBinDeflectionCoverage = m_phiBinDeflectionCoverage;
  m_gridCfg.maxPhiBins = m_maxPhiBins;
  m_gridCfg.zBinEdges = m_zBinEdges;
  m_gridCfg.rBinEdges = m_rBinEdges;
  m_gridCfg.bFieldInZ = 0;  // will be set later
  m_gridCfg.bottomBinFinder = Acts::GridBinFinder<3ul>(
      m_numPhiNeighbors.value(), m_zBinNeighborsBottom.value(),
      m_rBinNeighborsBottom.value());
  m_gridCfg.topBinFinder = Acts::GridBinFinder<3ul>(m_numPhiNeighbors.value(),
                                                    m_zBinNeighborsTop.value(),
                                                    m_rBinNeighborsTop.value());
  m_gridCfg.navigation[0ul] = {};
  m_gridCfg.navigation[1ul] = m_zBinsCustomLooping;
  m_gridCfg.navigation[2ul] = m_rBinsCustomLooping;
 
  m_bottomDoubletFinderCfg.spacePointsSortedByRadius = true;
  m_bottomDoubletFinderCfg.candidateDirection = Acts::Direction::Backward();
  m_bottomDoubletFinderCfg.deltaRMin = m_deltaRMinBottomSP;
  m_bottomDoubletFinderCfg.deltaRMax = m_deltaRMaxBottomSP;
  m_bottomDoubletFinderCfg.deltaZMin = -m_deltaZMax;
  m_bottomDoubletFinderCfg.deltaZMax = m_deltaZMax;
  m_bottomDoubletFinderCfg.impactMax = m_impactMax;
  m_bottomDoubletFinderCfg.interactionPointCut = m_interactionPointCut;
  m_bottomDoubletFinderCfg.collisionRegionMin = m_collisionRegionMin;
  m_bottomDoubletFinderCfg.collisionRegionMax = m_collisionRegionMax;
  m_bottomDoubletFinderCfg.cotThetaMax = m_cotThetaMax;
  m_bottomDoubletFinderCfg.minPt = m_minPt;
  m_bottomDoubletFinderCfg.helixCutTolerance = 1.;
  if (m_useExperimentCuts) {
    m_bottomDoubletFinderCfg.experimentCuts
        .connect<&ActsTrk::GridTripletSeedingTool::doubletSelectionFunction>(
            this);
  }
 
  m_topDoubletFinderCfg = m_bottomDoubletFinderCfg;  // copy the bottom cuts
  m_topDoubletFinderCfg.candidateDirection = Acts::Direction::Forward();
  m_topDoubletFinderCfg.deltaRMin = m_deltaRMinTopSP;
  m_topDoubletFinderCfg.deltaRMax = m_deltaRMaxTopSP;
 
  m_tripletFinderCfg.useStripInfo = m_useDetailedDoubleMeasurementInfo;
  m_tripletFinderCfg.sortedByCotTheta = !m_useDetailedDoubleMeasurementInfo;
  m_tripletFinderCfg.minPt = m_minPt;
  m_tripletFinderCfg.sigmaScattering = m_sigmaScattering;
  m_tripletFinderCfg.radLengthPerSeed = m_radLengthPerSeed;
  m_tripletFinderCfg.maxPtScattering = m_maxPtScattering;
  m_tripletFinderCfg.impactMax = m_impactMax;
  m_tripletFinderCfg.helixCutTolerance = 1.;
  m_tripletFinderCfg.toleranceParam = m_toleranceParam;
 
  m_filterCfg.deltaInvHelixDiameter = m_deltaInvHelixDiameter;
  m_filterCfg.deltaRMin = m_deltaRMin;
  m_filterCfg.compatSeedWeight = m_compatSeedWeight;
  m_filterCfg.impactWeightFactor = m_impactWeightFactor;
  m_filterCfg.zOriginWeightFactor = m_zOriginWeightFactor;
  m_filterCfg.maxSeedsPerSpM = m_maxSeedsPerSpM;
  m_filterCfg.compatSeedLimit = m_compatSeedLimit;
  m_filterCfg.seedWeightIncrement = m_seedWeightIncrement;
  m_filterCfg.numSeedIncrement = m_numSeedIncrement;
  m_filterCfg.seedConfirmation = m_seedConfirmationInFilter;
  m_filterCfg.centralSeedConfirmationRange.zMinSeedConf = m_seedConfCentralZMin;
  m_filterCfg.centralSeedConfirmationRange.zMaxSeedConf = m_seedConfCentralZMax;
  m_filterCfg.centralSeedConfirmationRange.rMaxSeedConf = m_seedConfCentralRMax;
  m_filterCfg.centralSeedConfirmationRange.nTopForLargeR =
      m_seedConfCentralNTopLargeR;
  m_filterCfg.centralSeedConfirmationRange.nTopForSmallR =
      m_seedConfCentralNTopSmallR;
  m_filterCfg.centralSeedConfirmationRange.seedConfMinBottomRadius =
      m_seedConfCentralMinBottomRadius;
  m_filterCfg.centralSeedConfirmationRange.seedConfMaxZOrigin =
      m_seedConfCentralMaxZOrigin;
  m_filterCfg.centralSeedConfirmationRange.minImpactSeedConf =
      m_seedConfCentralMinImpact;
  m_filterCfg.forwardSeedConfirmationRange.zMinSeedConf = m_seedConfForwardZMin;
  m_filterCfg.forwardSeedConfirmationRange.zMaxSeedConf = m_seedConfForwardZMax;
  m_filterCfg.forwardSeedConfirmationRange.rMaxSeedConf = m_seedConfForwardRMax;
  m_filterCfg.forwardSeedConfirmationRange.nTopForLargeR =
      m_seedConfForwardNTopLargeR;
  m_filterCfg.forwardSeedConfirmationRange.nTopForSmallR =
      m_seedConfForwardNTopSmallR;
  m_filterCfg.forwardSeedConfirmationRange.seedConfMinBottomRadius =
      m_seedConfForwardMinBottomRadius;
  m_filterCfg.forwardSeedConfirmationRange.seedConfMaxZOrigin =
      m_seedConfForwardMaxZOrigin;
  m_filterCfg.forwardSeedConfirmationRange.minImpactSeedConf =
      m_seedConfForwardMinImpact;
  m_filterCfg.maxSeedsPerSpMConf = m_maxSeedsPerSpMConf;
  m_filterCfg.maxQualitySeedsPerSpMConf = m_maxQualitySeedsPerSpMConf;
  m_filterCfg.useDeltaRinsteadOfTopRadius = m_useDeltaRorTopRadius;
 
  m_finder =
      Acts::Experimental::TripletSeeder(logger().cloneWithSuffix("Finder"));
 
  m_loggerFilter = logger().cloneWithSuffix("Filter");
 
  ATH_CHECK(detStore()->retrieve(m_pixelId, "PixelID"));
 
  return StatusCode::SUCCESS;
}

logger()

const Acts::Logger& ActsTrk::GridTripletSeedingTool::logger ( ) const

inlineprivate

Private access to the logger.

Definition at line 352 of file GridTripletSeedingTool.h.

{ return *m_logger; }

retrieveRadiusRangeForMiddle()

std::pair< float, float > ActsTrk::GridTripletSeedingTool::retrieveRadiusRangeForMiddle ( const Acts::Experimental::ConstSpacePointProxy2 &  spM, const Acts::Range1D< float > &  rMiddleSpRange  ) const

private

Definition at line 368 of file GridTripletSeedingTool.cxx.

                                                    {
  if (m_useVariableMiddleSPRange) {
    return {rMiddleSpRange.min(), rMiddleSpRange.max()};
  }
  if (m_rRangeMiddleSP.empty()) {
    throw std::runtime_error(
        "m_rRangeMiddleSP is empty, please check the configuration.");
  }
 
  // get zBin position of the middle SP
  auto pVal =
      std::lower_bound(m_zBinEdges.begin(), m_zBinEdges.end(), spM.zr()[0]);
  int zBin = std::distance(m_zBinEdges.begin(), pVal);
  // protects against zM at the limit of zBinEdges
  zBin == 0 ? zBin : --zBin;
  return {m_rRangeMiddleSP[zBin][0], m_rRangeMiddleSP[zBin][1]};
}

spacePointSelectionFunction()

bool ActsTrk::GridTripletSeedingTool::spacePointSelectionFunction ( const xAOD::SpacePoint *  sp, float  r  ) const

private

Definition at line 288 of file GridTripletSeedingTool.cxx.

                                             {
  float zabs = std::abs(sp->z());
  float absCotTheta = zabs / r;
 
  // checking configuration to remove pixel space points
  Identifier identifier = m_pixelId->wafer_id(sp->elementIdList().at(0));
  if (m_pixelId->is_barrel(identifier)) {
    if (zabs > 200 && r < 40)
      return false;
 
    return true;
  }
 
  // Inner layers
  // Below 1.20 - accept all
  static constexpr float cotThetaEta120 = 1.5095;
  if (absCotTheta < cotThetaEta120)
    return true;
 
  // Below 3.40 - remove if too close to beamline
  static constexpr float cotThetaEta340 = 14.9654;
  if (absCotTheta < cotThetaEta340 && r < m_expCutrMin)
    return false;
 
  // Outer layers
  // Above 2.20
  static constexpr float cotThetaEta220 = 4.4571;
  if (absCotTheta > cotThetaEta220 && r > 260.)
    return false;
 
  // Above 2.60
  static constexpr float cotThetaEta260 = 6.6947;
  if (absCotTheta > cotThetaEta260 && r > 200.)
    return false;
 
  // Above 3.20
  static constexpr float cotThetaEta320 = 12.2459;
  if (absCotTheta > cotThetaEta320 && r > 140.)
    return false;
 
  // Above 4.00
  static constexpr float cotThetaEta400 = 27.2899;
  if (absCotTheta > cotThetaEta400)
    return false;
 
  return true;
}

Member Data Documentation

m_binSizeR

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_binSizeR

protected

Initial value:

{
      this, "binSizeR", 1. * Acts::UnitConstants::mm,
      "defining radial bin for space point sorting"}

Definition at line 93 of file GridTripletSeedingTool.h.

m_bottomDoubletFinderCfg

Acts::Experimental::DoubletSeedFinder::Config ActsTrk::GridTripletSeedingTool::m_bottomDoubletFinderCfg

private

Definition at line 338 of file GridTripletSeedingTool.h.

m_collisionRegionMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_collisionRegionMax

protected

Initial value:

{
      this, "collisionRegionMax", 200. * Acts::UnitConstants::mm,
      "limiting location of collision region in z"}

Definition at line 118 of file GridTripletSeedingTool.h.

m_collisionRegionMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_collisionRegionMin

protected

Initial value:

{
      this, "collisionRegionMin", -200. * Acts::UnitConstants::mm,
      "limiting location of collision region in z"}

Definition at line 115 of file GridTripletSeedingTool.h.

m_compatSeedLimit

Gaudi::Property<std::size_t> ActsTrk::GridTripletSeedingTool::m_compatSeedLimit

protected

Initial value:

{
      this, "compatSeedLimit", 3,
      "how often do you want to increase the weight of a seed for finding a "
      "compatible seed"}

Definition at line 249 of file GridTripletSeedingTool.h.

m_compatSeedWeight

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_compatSeedWeight

protected

Initial value:

{
      this, "compatSeedWeight", 100.,
      "seed weight increased by this value if a compatible seed has been "
      "found"}

Definition at line 245 of file GridTripletSeedingTool.h.

m_cotThetaMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_cotThetaMax

protected

Initial value:

{this, "cotThetaMax", 27.2899,
                                       "cot of maximum theta angle"}

Definition at line 50 of file GridTripletSeedingTool.h.

m_deltaInvHelixDiameter

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaInvHelixDiameter

protected

Initial value:

{
      this, "deltaInvHelixDiameter", 0.00003 * 1. / Acts::UnitConstants::mm,
      "the allowed delta between two inverted seed radii for them to be "
      "considered compatible"}

Definition at line 271 of file GridTripletSeedingTool.h.

m_deltaRMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaRMax

protected

Initial value:

{
      this, "deltaRMax", 280. * Acts::UnitConstants::mm,
      "maximum distance in r between two measurements within one "
      "seed"}

Definition at line 56 of file GridTripletSeedingTool.h.

m_deltaRMaxBottomSP

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaRMaxBottomSP

protected

Initial value:

{
      this, "deltaRMaxBottomSP", 150. * Acts::UnitConstants::mm,
      "maximum distance in r between middle and top SP"}

Definition at line 109 of file GridTripletSeedingTool.h.

m_deltaRMaxTopSP

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaRMaxTopSP

protected

Initial value:

{
      this, "deltaRMaxTopSP", 280. * Acts::UnitConstants::mm,
      "maximum distance in r between middle and top SP"}

Definition at line 103 of file GridTripletSeedingTool.h.

m_deltaRMiddleMaxSPRange

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaRMiddleMaxSPRange

protected

Initial value:

{
      this, "deltaRMiddleMaxSPRange", 10., "delta R for middle SP range (max)"}

Definition at line 168 of file GridTripletSeedingTool.h.

m_deltaRMiddleMinSPRange

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaRMiddleMinSPRange

protected

Initial value:

{
      this, "deltaRMiddleMinSPRange", 10., "delta R for middle SP range (min)"}

Definition at line 166 of file GridTripletSeedingTool.h.

m_deltaRMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaRMin

protected

Initial value:

{
      this, "deltaRMin", 20. * Acts::UnitConstants::mm,
      "minimum distance in r between two measurements within one "
      "seed"}

Definition at line 96 of file GridTripletSeedingTool.h.

m_deltaRMinBottomSP

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaRMinBottomSP

protected

Initial value:

{
      this, "deltaRMinBottomSP", 6. * Acts::UnitConstants::mm,
      "minimum distance in r between middle and top SP"}

Definition at line 106 of file GridTripletSeedingTool.h.

m_deltaRMinTopSP

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaRMinTopSP

protected

Initial value:

{
      this, "deltaRMinTopSP", 6. * Acts::UnitConstants::mm,
      "minimum distance in r between middle and top SP"}

Definition at line 100 of file GridTripletSeedingTool.h.

m_deltaZMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_deltaZMax

protected

Initial value:

{
      this, "deltaZMax", 600,
      "maximum distance in z between two measurements within one seed"}

Definition at line 112 of file GridTripletSeedingTool.h.

m_expCutrMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_expCutrMin

protected

Initial value:

{this, "SpSelectionExpCutrMin",
                                      45. * Acts::UnitConstants::mm}

Definition at line 333 of file GridTripletSeedingTool.h.

m_filterCfg

Acts::Experimental::BroadTripletSeedFilter::Config ActsTrk::GridTripletSeedingTool::m_filterCfg

private

Definition at line 341 of file GridTripletSeedingTool.h.

m_finder

std::optional<Acts::Experimental::TripletSeeder> ActsTrk::GridTripletSeedingTool::m_finder

private

Definition at line 343 of file GridTripletSeedingTool.h.

m_gridCfg

Acts::Experimental::CylindricalSpacePointGrid2::Config ActsTrk::GridTripletSeedingTool::m_gridCfg

private

Definition at line 337 of file GridTripletSeedingTool.h.

m_gridPhiMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_gridPhiMax

protected

Initial value:

{this, "gridPhiMax",
                                      std::numbers::pi_v<float>,
                                      "phi max for space point grid formation"}

Definition at line 80 of file GridTripletSeedingTool.h.

m_gridPhiMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_gridPhiMin

protected

Initial value:

{this, "gridPhiMin",
                                      -std::numbers::pi_v<float>,
                                      "phi min for space point grid formation"}

Definition at line 77 of file GridTripletSeedingTool.h.

m_gridRMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_gridRMax

protected

Initial value:

{
      this, "gridRMax", 320. * Acts::UnitConstants::mm,
      "radial extension of subdetector to be used in grid building"}

Definition at line 74 of file GridTripletSeedingTool.h.

m_impactMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_impactMax

protected

Initial value:

{this, "impactMax",
                                     2. * Acts::UnitConstants::mm,
                                     "maximum impact parameter"}

Definition at line 60 of file GridTripletSeedingTool.h.

m_impactWeightFactor

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_impactWeightFactor

protected

Initial value:

{
      this, "impactWeightFactor", 100.,
      "the impact parameters (d0) is multiplied by this factor and subtracted "
      "from weight"}

Definition at line 240 of file GridTripletSeedingTool.h.

m_interactionPointCut

Gaudi::Property<bool> ActsTrk::GridTripletSeedingTool::m_interactionPointCut

protected

Initial value:

{
      this, "interactionPointCut", true,
      "Enable cut on the compatibility between interaction point and SPs"}

Definition at line 136 of file GridTripletSeedingTool.h.

m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::GridTripletSeedingTool::m_logger

private

logging instance

Definition at line 346 of file GridTripletSeedingTool.h.

m_loggerFilter

std::unique_ptr<const Acts::Logger> ActsTrk::GridTripletSeedingTool::m_loggerFilter

private

Definition at line 347 of file GridTripletSeedingTool.h.

m_maxPhiBins

Gaudi::Property<int> ActsTrk::GridTripletSeedingTool::m_maxPhiBins

protected

Initial value:

{this, "maxPhiBins", 200,
                                    "max number of bins"}

Definition at line 87 of file GridTripletSeedingTool.h.

m_maxPtScattering

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_maxPtScattering

protected

Initial value:

{
      this, "maxPtScattering", 10e6,
      "Upper pt limit for scattering calculation"}

Definition at line 124 of file GridTripletSeedingTool.h.

m_maxQualitySeedsPerSpMConf

Gaudi::Property<std::size_t> ActsTrk::GridTripletSeedingTool::m_maxQualitySeedsPerSpMConf

protected

Initial value:

{
      this, "maxQualitySeedsPerSpMConf", 5,
      "Maximum number of quality seeds for each middle-bottom SP-duplet in "
      "seed confirmation."}

Definition at line 264 of file GridTripletSeedingTool.h.

m_maxSeedsPerSpM

Gaudi::Property<int> ActsTrk::GridTripletSeedingTool::m_maxSeedsPerSpM

protected

Initial value:

{
      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."}

Definition at line 131 of file GridTripletSeedingTool.h.

m_maxSeedsPerSpMConf

Gaudi::Property<std::size_t> ActsTrk::GridTripletSeedingTool::m_maxSeedsPerSpMConf

protected

Initial value:

{
      this, "maxSeedsPerSpMConf", 5,
      "Maximum number of lower quality seeds in seed confirmation."}

Definition at line 261 of file GridTripletSeedingTool.h.

m_minPt

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_minPt

protected

Initial value:

{this, "minPt", 900. * Acts::UnitConstants::MeV,
                                 "lower pT cutoff for seeds"}

Definition at line 48 of file GridTripletSeedingTool.h.

m_numPhiNeighbors

Gaudi::Property<int> ActsTrk::GridTripletSeedingTool::m_numPhiNeighbors

protected

Initial value:

{
      this, "numPhiNeighbors", 1,
      "number of phi bin neighbors at each side of the current bin that will "
      "be used to search for SPs"}

Definition at line 321 of file GridTripletSeedingTool.h.

m_numSeedIncrement

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_numSeedIncrement

protected

Initial value:

{
      this, "numSeedIncrement", 10e6,
      "increment in seed weight is applied if the number of compatible seeds "
      "is larger than numSeedIncrement"}

Definition at line 255 of file GridTripletSeedingTool.h.

m_phiBinDeflectionCoverage

Gaudi::Property<int> ActsTrk::GridTripletSeedingTool::m_phiBinDeflectionCoverage

protected

Initial value:

{
      this, "phiBinDeflectionCoverage", 3,
      "sets of consecutive phi bins to cover full deflection of minimum pT "
      "particle"}

Definition at line 83 of file GridTripletSeedingTool.h.

m_phiMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_phiMax

protected

Initial value:

{this, "phiMax", std::numbers::pi_v<float>,
                                  ""}

Definition at line 230 of file GridTripletSeedingTool.h.

m_phiMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_phiMin

protected

Initial value:

{this, "phiMin", -std::numbers::pi_v<float>,
                                  ""}

Definition at line 228 of file GridTripletSeedingTool.h.

m_pixelId

const PixelID* ActsTrk::GridTripletSeedingTool::m_pixelId {nullptr}

private

Definition at line 349 of file GridTripletSeedingTool.h.

m_radLengthPerSeed

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_radLengthPerSeed

protected

Initial value:

{
      this, "radLengthPerSeed", 0.098045,
      "average radiation lengths of material on the length of a seed. used for "
      "scattering"}

Definition at line 127 of file GridTripletSeedingTool.h.

m_rAlign

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_rAlign

protected

Initial value:

{this, "rAlign", 0 * Acts::UnitConstants::mm,
                                  ""}

Definition at line 235 of file GridTripletSeedingTool.h.

m_rBinEdges

Gaudi::Property<std::vector<float> > ActsTrk::GridTripletSeedingTool::m_rBinEdges

protected

Initial value:

{
      this,
      "rBinEdges",
      {0., 1100 * Acts::UnitConstants::mm},
      "enable non equidistant binning in radius"}

Definition at line 69 of file GridTripletSeedingTool.h.

m_rBinNeighborsBottom

Gaudi::Property<std::vector<std::pair<int, int> > > ActsTrk::GridTripletSeedingTool::m_rBinNeighborsBottom

protected

Initial value:

{
      this,
      "rBinNeighborsBottom",
      {{0, 0}},
      "vector containing the map of radius bins in the bottom layers"}

Definition at line 316 of file GridTripletSeedingTool.h.

m_rBinNeighborsTop

Gaudi::Property<std::vector<std::pair<int, int> > > ActsTrk::GridTripletSeedingTool::m_rBinNeighborsTop

protected

Initial value:

{
      this,
      "rBinNeighborsTop",
      {{0, 0}},
      "vector containing the map of radius bins in the top layers"}

Definition at line 311 of file GridTripletSeedingTool.h.

m_rBinsCustomLooping

Gaudi::Property<std::vector<std::size_t> > ActsTrk::GridTripletSeedingTool::m_rBinsCustomLooping

protected

Initial value:

{
      this, "rBinsCustomLooping", {1}, "defines order of r bins for looping"}

Definition at line 144 of file GridTripletSeedingTool.h.

m_rMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_rMax

protected

Initial value:

{this, "rMax", 320. * Acts::UnitConstants::mm,
                                "limiting location of measurements"}

Definition at line 91 of file GridTripletSeedingTool.h.

m_rMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_rMin {this, "rMin", 0 * Acts::UnitConstants::mm, ""}

protected

Definition at line 232 of file GridTripletSeedingTool.h.

m_rRangeMiddleSP

Gaudi::Property<std::vector<std::vector<double> > > ActsTrk::GridTripletSeedingTool::m_rRangeMiddleSP

protected

Initial value:

{
      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"}

Definition at line 149 of file GridTripletSeedingTool.h.

m_seedConfCentralMaxZOrigin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfCentralMaxZOrigin

protected

Initial value:

{
      this, "seedConfCentralMaxZOrigin", 150 * Acts::UnitConstants::mm,
      "Maximum zOrigin in seed confirmation"}

Definition at line 190 of file GridTripletSeedingTool.h.

m_seedConfCentralMinBottomRadius

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfCentralMinBottomRadius

protected

Initial value:

{
      this, "seedConfCentralMinBottomRadius", 60 * Acts::UnitConstants::mm,
      "Minimum radius for bottom SP in seed confirmation"}

Definition at line 187 of file GridTripletSeedingTool.h.

m_seedConfCentralMinImpact

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfCentralMinImpact

protected

Initial value:

{
      this, "seedConfCentralMinImpact", 1. * Acts::UnitConstants::mm,
      "Minimum impact parameter for seed confirmation"}

Definition at line 193 of file GridTripletSeedingTool.h.

m_seedConfCentralNTopLargeR

Gaudi::Property<size_t> ActsTrk::GridTripletSeedingTool::m_seedConfCentralNTopLargeR

protected

Initial value:

{
      this, "seedConfCentralNTopLargeR", 1,
      "nTop for large R central seed confirmation"}

Definition at line 181 of file GridTripletSeedingTool.h.

m_seedConfCentralNTopSmallR

Gaudi::Property<size_t> ActsTrk::GridTripletSeedingTool::m_seedConfCentralNTopSmallR

protected

Initial value:

{
      this, "seedConfCentralNTopSmallR", 2,
      "nTop for small R central seed confirmation"}

Definition at line 184 of file GridTripletSeedingTool.h.

m_seedConfCentralRMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfCentralRMax

protected

Initial value:

{
      this, "seedConfCentralRMax", 140. * Acts::UnitConstants::mm,
      "maximum r for central seed confirmation "}

Definition at line 178 of file GridTripletSeedingTool.h.

m_seedConfCentralZMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfCentralZMax

protected

Initial value:

{
      this, "seedConfCentralZMax", 250. * Acts::UnitConstants::mm,
      "maximum z for central seed confirmation "}

Definition at line 175 of file GridTripletSeedingTool.h.

m_seedConfCentralZMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfCentralZMin

protected

Initial value:

{
      this, "seedConfCentralZMin", -250. * Acts::UnitConstants::mm,
      "minimum z for central seed confirmation "}

Definition at line 172 of file GridTripletSeedingTool.h.

m_seedConfForwardMaxZOrigin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfForwardMaxZOrigin

protected

Initial value:

{
      this, "seedConfForwardMaxZOrigin", 150 * Acts::UnitConstants::mm,
      "Maximum zOrigin in seed confirmation"}

Definition at line 214 of file GridTripletSeedingTool.h.

m_seedConfForwardMinBottomRadius

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfForwardMinBottomRadius

protected

Initial value:

{
      this, "seedConfForwardMinBottomRadius", 60 * Acts::UnitConstants::mm,
      "Minimum radius for bottom SP in seed confirmation"}

Definition at line 211 of file GridTripletSeedingTool.h.

m_seedConfForwardMinImpact

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfForwardMinImpact

protected

Initial value:

{
      this, "seedConfForwardMinImpact", 1. * Acts::UnitConstants::mm,
      "Minimum impact parameter for seed confirmation"}

Definition at line 217 of file GridTripletSeedingTool.h.

m_seedConfForwardNTopLargeR

Gaudi::Property<size_t> ActsTrk::GridTripletSeedingTool::m_seedConfForwardNTopLargeR

protected

Initial value:

{
      this, "seedConfForwardNTopLargeR", 1,
      "nTop for large R forward seed confirmation"}

Definition at line 205 of file GridTripletSeedingTool.h.

m_seedConfForwardNTopSmallR

Gaudi::Property<size_t> ActsTrk::GridTripletSeedingTool::m_seedConfForwardNTopSmallR

protected

Initial value:

{
      this, "seedConfForwardNTopSmallR", 2,
      "nTop for small R forward seed confirmation"}

Definition at line 208 of file GridTripletSeedingTool.h.

m_seedConfForwardRMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfForwardRMax

protected

Initial value:

{
      this, "seedConfForwardRMax", 140. * Acts::UnitConstants::mm,
      "maximum r for forward seed confirmation "}

Definition at line 202 of file GridTripletSeedingTool.h.

m_seedConfForwardZMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfForwardZMax

protected

Initial value:

{
      this, "seedConfForwardZMax", 3000. * Acts::UnitConstants::mm,
      "maximum z for forward seed confirmation "}

Definition at line 199 of file GridTripletSeedingTool.h.

m_seedConfForwardZMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedConfForwardZMin

protected

Initial value:

{
      this, "seedConfForwardZMin", -3000. * Acts::UnitConstants::mm,
      "minimum z for forward seed confirmation "}

Definition at line 196 of file GridTripletSeedingTool.h.

m_seedConfirmation

Gaudi::Property<bool> ActsTrk::GridTripletSeedingTool::m_seedConfirmation

protected

Initial value:

{this, "seedConfirmation", true,
                                           "run seed confirmation"}

Definition at line 170 of file GridTripletSeedingTool.h.

m_seedConfirmationInFilter

Gaudi::Property<bool> ActsTrk::GridTripletSeedingTool::m_seedConfirmationInFilter

protected

Initial value:

{
      this, "seedConfirmationInFilter", true, "run seed confirmation"}

Definition at line 259 of file GridTripletSeedingTool.h.

m_seedQualitySelection

Gaudi::Property<bool> ActsTrk::GridTripletSeedingTool::m_seedQualitySelection

protected

Initial value:

{
      this, "doSeedQualitySelection", true,
      "Select seed according to quality criteria"}

Definition at line 42 of file GridTripletSeedingTool.h.

m_seedWeightIncrement

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_seedWeightIncrement

protected

Initial value:

{
      this, "seedWeightIncrement", 0., "increment in seed weight if needed"}

Definition at line 253 of file GridTripletSeedingTool.h.

m_sigmaError

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_sigmaError {this, "sigmaError", 5, ""}

protected

Definition at line 237 of file GridTripletSeedingTool.h.

m_sigmaScattering

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_sigmaScattering

protected

Initial value:

{
      this, "sigmaScattering", 2.,
      "how many sigmas of scattering angle should be considered"}

Definition at line 121 of file GridTripletSeedingTool.h.

m_stateVectorReserveSize

Gaudi::Property<int> ActsTrk::GridTripletSeedingTool::m_stateVectorReserveSize

protected

Initial value:

{
      this, "stateVectorReserveSize", 500,
      "Size of the initial Seeding State internal vectors"}

Definition at line 329 of file GridTripletSeedingTool.h.

m_toleranceParam

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_toleranceParam

protected

Initial value:

{
      this, "toleranceParam", 1.1 * Acts::UnitConstants::mm,
      "tolerance parameter used to check the compatibility of SPs coordinates "
      "in xyz"}

Definition at line 224 of file GridTripletSeedingTool.h.

m_topDoubletFinderCfg

Acts::Experimental::DoubletSeedFinder::Config ActsTrk::GridTripletSeedingTool::m_topDoubletFinderCfg

private

Definition at line 339 of file GridTripletSeedingTool.h.

m_tripletFinderCfg

Acts::Experimental::TripletSeedFinder::Config ActsTrk::GridTripletSeedingTool::m_tripletFinderCfg

private

Definition at line 340 of file GridTripletSeedingTool.h.

m_useDeltaRorTopRadius

Gaudi::Property<bool> ActsTrk::GridTripletSeedingTool::m_useDeltaRorTopRadius

protected

Initial value:

{
      this, "useDeltaRorTopRadius", true,
      "use deltaR (top radius - middle radius) instead of top radius"}

Definition at line 268 of file GridTripletSeedingTool.h.

m_useDetailedDoubleMeasurementInfo

Gaudi::Property<bool> ActsTrk::GridTripletSeedingTool::m_useDetailedDoubleMeasurementInfo

protected

Initial value:

{
      this, "useDetailedDoubleMeasurementInfo", false,
      "enable use of double measurement details"}

Definition at line 220 of file GridTripletSeedingTool.h.

m_useExperimentCuts

Gaudi::Property<bool> ActsTrk::GridTripletSeedingTool::m_useExperimentCuts

protected

Initial value:

{this, "useExperimentCuts", false,
                                            ""}

Definition at line 326 of file GridTripletSeedingTool.h.

m_useVariableMiddleSPRange

Gaudi::Property<bool> ActsTrk::GridTripletSeedingTool::m_useVariableMiddleSPRange

protected

Initial value:

{
      this, "useVariableMiddleSPRange", true,
      "Enable variable range to search for middle SPs"}

Definition at line 146 of file GridTripletSeedingTool.h.

m_zAlign

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_zAlign

protected

Initial value:

{this, "zAlign", 0 * Acts::UnitConstants::mm,
                                  ""}

Definition at line 233 of file GridTripletSeedingTool.h.

m_zBinEdges

Gaudi::Property<std::vector<float> > ActsTrk::GridTripletSeedingTool::m_zBinEdges

protected

Initial value:

{
      this,
      "zBinEdges",
      {-3000., -2700., -2500., -1400., -925., -500., -250., 250., 500., 925.,
       1400., 2500., 2700, 3000.},
      "enable non equidistant binning in z"}

Definition at line 63 of file GridTripletSeedingTool.h.

m_zBinNeighborsBottom

Gaudi::Property<std::vector<std::pair<int, int> > > ActsTrk::GridTripletSeedingTool::m_zBinNeighborsBottom

protected

Initial value:

{
      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"}

Definition at line 294 of file GridTripletSeedingTool.h.

m_zBinNeighborsTop

Gaudi::Property<std::vector<std::pair<int, int> > > ActsTrk::GridTripletSeedingTool::m_zBinNeighborsTop

protected

Initial value:

{
      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"}

Definition at line 277 of file GridTripletSeedingTool.h.

m_zBinsCustomLooping

Gaudi::Property<std::vector<size_t> > ActsTrk::GridTripletSeedingTool::m_zBinsCustomLooping

protected

Initial value:

{
      this,
      "zBinsCustomLooping",
      {2, 3, 4, 5, 12, 11, 10, 9, 7, 6, 8},
      "defines order of z bins for looping"}

Definition at line 139 of file GridTripletSeedingTool.h.

m_zMax

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_zMax

protected

Initial value:

{this, "zMax", 3000. * Acts::UnitConstants::mm,
                                "limiting location of measurements"}

Definition at line 54 of file GridTripletSeedingTool.h.

m_zMin

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_zMin

protected

Initial value:

{this, "zMin", -3000. * Acts::UnitConstants::mm,
                                "limiting location of measurements"}

Definition at line 52 of file GridTripletSeedingTool.h.

m_zOriginWeightFactor

Gaudi::Property<float> ActsTrk::GridTripletSeedingTool::m_zOriginWeightFactor {this, "zOriginWeightFactor", 1.}

protected

Definition at line 244 of file GridTripletSeedingTool.h.

---

The documentation for this class was generated from the following files:

• GridTripletSeedingTool.h
• GridTripletSeedingTool.cxx