#include <SeedingTool.h>

Inheritance diagram for ActsTrk::SeedingTool:

Collaboration diagram for ActsTrk::SeedingTool:

Classes
struct	external_spacepoint

Public Types
using	value_type = xAOD::SpacePoint

using	seed_type = Acts::Seed< xAOD::SpacePoint >

Public Member Functions
	SeedingTool (const std::string &type, const std::string &name, const IInterface *parent)

virtual	~SeedingTool ()=default

virtual StatusCode	initialize () override

virtual StatusCode	createSeeds (const EventContext &ctx, const std::vector< const xAOD::SpacePoint * > &spContainer, const Acts::Vector3 &beamSpotPos, const Acts::Vector3 &bField, ActsTrk::SeedContainer &seedContainer) const override

Protected Member Functions
template<typename external_iterator_t >
StatusCode	createSeeds (external_iterator_t spBegin, external_iterator_t spEnd, const Acts::Vector3 &beamSpotPos, const Acts::Vector3 &bField, std::vector< seed_type > &seeds) const

StatusCode	prepareConfiguration ()

Protected Attributes
Acts::SeedFinder< value_type, Acts::CylindricalSpacePointGrid< value_type > >	m_finder

Acts::SeedFinderConfig< value_type >	m_finderCfg

Acts::CylindricalSpacePointGridConfig	m_gridCfg

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< float >	m_gridRMax

Gaudi::Property< float >	m_gridPhiMin

Gaudi::Property< float >	m_gridPhiMax

Gaudi::Property< int >	m_phiBinDeflectionCoverage

Gaudi::Property< int >	m_maxPhiBins {this, "maxPhiBins", 200, "max number of bins"}

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< 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 {this, "phiMin", -M_PI, ""}

Gaudi::Property< float >	m_phiMax {this, "phiMax", M_PI, ""}

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_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< int >	m_numPhiNeighbors

Gaudi::Property< bool >	m_useExperimentCuts {this, "useExperimentCuts", false, ""}

Private Attributes
std::unique_ptr< Acts::GridBinFinder< 2ul > >	m_bottomBinFinder {nullptr}

std::unique_ptr< Acts::GridBinFinder< 2ul > >	m_topBinFinder {nullptr}

std::array< std::vector< std::size_t >, 2ul >	m_navigation {}

Detailed Description

Definition at line 36 of file SeedingTool.h.

Member Typedef Documentation

◆ seed_type

using ActsTrk::SeedingTool::seed_type = Acts::Seed< xAOD::SpacePoint >

Definition at line 40 of file SeedingTool.h.

◆ value_type

using ActsTrk::SeedingTool::value_type = xAOD::SpacePoint

Definition at line 39 of file SeedingTool.h.

Constructor & Destructor Documentation

◆ SeedingTool()

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

Definition at line 17 of file SeedingTool.cxx.

20 : base_class(type, name, parent)

21 {}

◆ ~SeedingTool()

virtual ActsTrk::SeedingTool::~SeedingTool ( )

virtualdefault

Member Function Documentation

◆ createSeeds() [1/2]

StatusCode ActsTrk::SeedingTool::createSeeds	(	const EventContext &	ctx,
		const std::vector< const xAOD::SpacePoint * > &	spContainer,
		const Acts::Vector3 &	beamSpotPos,
		const Acts::Vector3 &	bField,
		ActsTrk::SeedContainer &	seedContainer
	)		const

overridevirtual

Definition at line 171 of file SeedingTool.cxx.

   {
     // Create Seeds
     //TODO POSSIBLE OPTIMISATION come back here: see MR !52399 ( i.e. use static thread_local)
     std::vector<Acts::Seed< xAOD::SpacePoint >> groupSeeds;
     ATH_CHECK(createSeeds(spContainer.begin(),
               spContainer.end(),
               beamSpotPos,
               bField,
               groupSeeds));
     
     // Store seeds
     seedContainer.reserve(groupSeeds.size());
     for( const auto& seed: groupSeeds) {
       std::unique_ptr< seed_type > to_add = 
     std::make_unique< seed_type >(seed);
       seedContainer.push_back(std::move(to_add));  
     }
     
     return StatusCode::SUCCESS;
   }

◆ createSeeds() [2/2]

template<typename external_iterator_t >

StatusCode ActsTrk::SeedingTool::createSeeds	(	external_iterator_t	spBegin,
		external_iterator_t	spEnd,
		const Acts::Vector3 &	beamSpotPos,
		const Acts::Vector3 &	bField,
		std::vector< seed_type > &	seeds
	)		const

protected

Do not convert coordinates w.r.t. beam spot Coordinates are converted internally when constructing InternalSpacePoints

Definition at line 199 of file SeedingTool.cxx.

   {
     static_assert(std::is_same<typename external_spacepoint< external_iterator_t >::type, value_type>::value,
           "Inconsistent type");
     
     seeds.clear();
     if (spBegin == spEnd)
       return StatusCode::SUCCESS;
  
     // Space Point Grid Options
     Acts::CylindricalSpacePointGridOptions gridOpts;
     gridOpts.bFieldInZ = bField[2];
     gridOpts = gridOpts.toInternalUnits();
     
     // Seed Finder Options
     Acts::SeedFinderOptions finderOpts;
     finderOpts.beamPos = Acts::Vector2(beamSpotPos[Amg::x], 
                                    beamSpotPos[Amg::y]);
     finderOpts.bFieldInZ = bField[2];
     finderOpts = finderOpts.toInternalUnits().calculateDerivedQuantities(m_finderCfg);
     
     auto extractCovariance = [](const value_type& sp, 
                 float, float, float) -> std::tuple<Acts::Vector3, Acts::Vector2, std::optional<Acts::ActsScalar>> 
       {
     Acts::Vector3 position(sp.x(),
                    sp.y(),
                    sp.z());
     Acts::Vector2 covariance(sp.varianceR(), sp.varianceZ());
     return std::make_tuple(position, covariance, std::nullopt);
       };
     
     
     Acts::Extent rRangeSPExtent;
         
     Acts::CylindricalSpacePointGrid< value_type > grid =
       Acts::CylindricalSpacePointGridCreator::createGrid< value_type >(m_gridCfg, gridOpts);
  
     Acts::CylindricalSpacePointGridCreator::fillGrid(m_finderCfg, finderOpts, grid,
                              spBegin, spEnd, extractCovariance, rRangeSPExtent);
  
     Acts::CylindricalBinnedGroup< value_type > spacePointsGrouping(std::move(grid), *m_bottomBinFinder,
                                    *m_topBinFinder, m_navigation);
     
     // variable middle SP radial region of interest
     const Acts::Range1D<float> rMiddleSPRange(std::floor(rRangeSPExtent.min(Acts::binR) / 2) * 2 +
                           m_finderCfg.deltaRMiddleMinSPRange,
                           std::floor(rRangeSPExtent.max(Acts::binR) / 2) * 2 -
                           m_finderCfg.deltaRMiddleMaxSPRange);
     
     //TODO POSSIBLE OPTIMISATION come back here: see MR !52399 ( i.e. use static thread_local)
     typename decltype(m_finder)::SeedingState state;
     state.spacePointData.resize(std::distance(spBegin, spEnd),
                 m_useDetailedDoubleMeasurementInfo);
  
     if (m_useDetailedDoubleMeasurementInfo) {
       for (std::size_t idx(0); idx < spacePointsGrouping.grid().size(); ++idx) {
         const std::vector<std::unique_ptr<Acts::InternalSpacePoint<xAOD::SpacePoint>>>& collection = spacePointsGrouping.grid().at(idx);
         for (const std::unique_ptr<Acts::InternalSpacePoint<xAOD::SpacePoint>>& sp : collection) {
           std::size_t index = sp->index();
  
           const float topHalfStripLength =
               m_finderCfg.getTopHalfStripLength(sp->sp());
           const float bottomHalfStripLength =
               m_finderCfg.getBottomHalfStripLength(sp->sp());
           const Acts::Vector3 topStripDirection =
               m_finderCfg.getTopStripDirection(sp->sp());
           const Acts::Vector3 bottomStripDirection =
               m_finderCfg.getBottomStripDirection(sp->sp());
  
           state.spacePointData.setTopStripVector(
               index, topHalfStripLength * topStripDirection);
           state.spacePointData.setBottomStripVector(
               index, bottomHalfStripLength * bottomStripDirection);
           state.spacePointData.setStripCenterDistance(
               index, m_finderCfg.getStripCenterDistance(sp->sp()));
           state.spacePointData.setTopStripCenterPosition(
               index, m_finderCfg.getTopStripCenterPosition(sp->sp()));
  
         }
       }
     }
  
     for (const auto [bottom, middle, top] : spacePointsGrouping) {
       m_finder.createSeedsForGroup(finderOpts, state, spacePointsGrouping.grid(), 
           std::back_inserter(seeds), bottom, middle, top, rMiddleSPRange);
     }
  
     if (m_seedQualitySelection) {
       // Selection function - temporary implementation
       // need change from ACTS for final implementation
       // To be used only on PPP
       auto selectionFunction = [&state] (const Acts::Seed<xAOD::SpacePoint>& seed) -> bool 
     {
       const xAOD::SpacePoint* bottom_sp =  seed.sp()[0];
       const xAOD::SpacePoint* middle_sp =  seed.sp()[1];
       const xAOD::SpacePoint* top_sp =  seed.sp()[2];
       
       float seed_quality = seed.seedQuality();
       float bottom_quality = state.spacePointData.quality(bottom_sp->index());
       float middle_quality = state.spacePointData.quality(middle_sp->index());
       float top_quality = state.spacePointData.quality(top_sp->index());
       
       if (bottom_quality > seed_quality and
           middle_quality > seed_quality and
           top_quality > seed_quality) {
             return false;
           }
  
       return true;
     };
  
       // Select the seeds
       std::size_t acceptedSeeds = 0;
       for (std::size_t i(0); i<seeds.size(); ++i) {
     const auto& seed = seeds[i];
     if (not selectionFunction(seed)) {
       continue;
     }
     // move passing seeds at the beginning of the vector/collection
     // no need to swap them both. The seed currently at acceptedSeeds 
     // didn't make it (if i != acceptedSeeds)
     if (acceptedSeeds != i)
       seeds[acceptedSeeds] = std::move(seeds[i]);
     ++acceptedSeeds;
       }
       // remove seeds that didn't make it
       // they are all at the end of the collection
       seeds.erase(seeds.begin() + acceptedSeeds, seeds.end());     
     }
  
     return StatusCode::SUCCESS;
   }

◆ initialize()

StatusCode ActsTrk::SeedingTool::initialize ( )

overridevirtual

Definition at line 23 of file SeedingTool.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_numPhiNeighbors);
  
     ATH_MSG_DEBUG(" *  Used by SpacePointGridConfig");
     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_deltaRMax);
     ATH_MSG_DEBUG("   " << m_gridRMax);
     ATH_MSG_DEBUG("   " << m_phiBinDeflectionCoverage);
  
     ATH_MSG_DEBUG(" * Used by SeedFinderConfig:");
     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_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 SeedFilterConfig:");
     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);
  
  
     if (m_zBinEdges.size() - 1 !=
       m_zBinNeighborsTop.size() and
       not m_zBinNeighborsTop.empty()) {
       ATH_MSG_ERROR("Inconsistent config zBinNeighborsTop");
       return StatusCode::FAILURE;
     }
  
     if (m_zBinEdges.size() - 1 !=
       m_zBinNeighborsBottom.size() and
       not m_zBinNeighborsBottom.empty()) {
       ATH_MSG_ERROR("Inconsistent config zBinNeighborsBottom");
       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;
         }
       }
     }
  
     ATH_CHECK( prepareConfiguration() );
  
     m_bottomBinFinder = std::make_unique< Acts::GridBinFinder< 2ul > >(m_numPhiNeighbors.value(), m_zBinNeighborsBottom.value());
     m_topBinFinder = std::make_unique< Acts::GridBinFinder< 2ul > >(m_numPhiNeighbors.value(), m_zBinNeighborsTop.value());
  
     m_navigation[0ul] = {};
     m_navigation[1ul] = m_finderCfg.zBinsCustomLooping;
     
     return StatusCode::SUCCESS;
   }

◆ prepareConfiguration()

StatusCode ActsTrk::SeedingTool::prepareConfiguration ( )

protected

Definition at line 340 of file SeedingTool.cxx.

                                     {
     // Prepare the Acts::SeedFinderConfig object
     // This is done only once, during initialization using the
     // parameters set in the JO
  
     // Configuration for Acts::SeedFinder
     m_finderCfg.minPt = m_minPt;
     m_finderCfg.cotThetaMax = m_cotThetaMax;
     m_finderCfg.impactMax = m_impactMax;
     m_finderCfg.zMin = m_zMin;
     m_finderCfg.zMax = m_zMax;
     m_finderCfg.zBinEdges = m_zBinEdges;
     m_finderCfg.rMax = m_rMax;
     m_finderCfg.binSizeR = m_binSizeR;
     m_finderCfg.deltaRMin = m_deltaRMin;
     m_finderCfg.deltaRMax = m_deltaRMax;
     m_finderCfg.deltaRMinTopSP = m_deltaRMinTopSP;
     m_finderCfg.deltaRMaxTopSP = m_deltaRMaxTopSP;
     m_finderCfg.deltaRMinBottomSP = m_deltaRMinBottomSP;
     m_finderCfg.deltaRMaxBottomSP = m_deltaRMaxBottomSP;
     m_finderCfg.deltaZMax = m_deltaZMax;
     m_finderCfg.collisionRegionMin = m_collisionRegionMin;
     m_finderCfg.collisionRegionMax = m_collisionRegionMax;
     m_finderCfg.sigmaScattering = m_sigmaScattering;
     m_finderCfg.maxPtScattering = m_maxPtScattering;
     m_finderCfg.radLengthPerSeed = m_radLengthPerSeed;
     m_finderCfg.maxSeedsPerSpM = m_maxSeedsPerSpM;
     m_finderCfg.interactionPointCut = m_interactionPointCut;
     m_finderCfg.zBinsCustomLooping = m_zBinsCustomLooping;
     m_finderCfg.useVariableMiddleSPRange = m_useVariableMiddleSPRange;
     m_finderCfg.deltaRMiddleMinSPRange = m_deltaRMiddleMinSPRange;
     m_finderCfg.deltaRMiddleMaxSPRange = m_deltaRMiddleMaxSPRange;
     m_finderCfg.seedConfirmation = m_seedConfirmation;
     m_finderCfg.centralSeedConfirmationRange.zMinSeedConf = m_seedConfCentralZMin;
     m_finderCfg.centralSeedConfirmationRange.zMaxSeedConf = m_seedConfCentralZMax;
     m_finderCfg.centralSeedConfirmationRange.rMaxSeedConf = m_seedConfCentralRMax;
     m_finderCfg.centralSeedConfirmationRange.nTopForLargeR = m_seedConfCentralNTopLargeR;
     m_finderCfg.centralSeedConfirmationRange.nTopForSmallR = m_seedConfCentralNTopSmallR;
     m_finderCfg.centralSeedConfirmationRange.seedConfMinBottomRadius = m_seedConfCentralMinBottomRadius;
     m_finderCfg.centralSeedConfirmationRange.seedConfMaxZOrigin = m_seedConfCentralMaxZOrigin;
     m_finderCfg.centralSeedConfirmationRange.minImpactSeedConf = m_seedConfCentralMinImpact;
     m_finderCfg.forwardSeedConfirmationRange.zMinSeedConf = m_seedConfForwardZMin;
     m_finderCfg.forwardSeedConfirmationRange.zMaxSeedConf = m_seedConfForwardZMax;
     m_finderCfg.forwardSeedConfirmationRange.rMaxSeedConf = m_seedConfForwardRMax;
     m_finderCfg.forwardSeedConfirmationRange.nTopForLargeR = m_seedConfForwardNTopLargeR;
     m_finderCfg.forwardSeedConfirmationRange.nTopForSmallR = m_seedConfForwardNTopSmallR;
     m_finderCfg.forwardSeedConfirmationRange.seedConfMinBottomRadius = m_seedConfForwardMinBottomRadius;
     m_finderCfg.forwardSeedConfirmationRange.seedConfMaxZOrigin = m_seedConfForwardMaxZOrigin;
     m_finderCfg.forwardSeedConfirmationRange.minImpactSeedConf = m_seedConfForwardMinImpact;
     m_finderCfg.useDetailedDoubleMeasurementInfo = m_useDetailedDoubleMeasurementInfo;
     m_finderCfg.toleranceParam = m_toleranceParam;
     m_finderCfg.phiMin = m_phiMin;
     m_finderCfg.phiMax = m_phiMax;
     m_finderCfg.rMin = m_rMin;
     m_finderCfg.zAlign = m_zAlign;
     m_finderCfg.rAlign = m_rAlign;
     m_finderCfg.sigmaError = m_sigmaError;
  
     if (m_useDetailedDoubleMeasurementInfo) {
       m_finderCfg.getTopHalfStripLength.connect(
         [](const void*, const value_type& sp) -> float {
           return sp.topHalfStripLength();
         });
       m_finderCfg.getBottomHalfStripLength.connect(
         [](const void*, const value_type& sp) -> float {
           return sp.bottomHalfStripLength();
         });
       m_finderCfg.getTopStripDirection.connect(
         [](const void*, const value_type& sp) -> Acts::Vector3 {
           return sp.topStripDirection().cast<double>();
         });
       m_finderCfg.getBottomStripDirection.connect(
         [](const void*, const value_type& sp) -> Acts::Vector3 {
           return sp.bottomStripDirection().cast<double>();
         });
       m_finderCfg.getStripCenterDistance.connect(
           [](const void*, const value_type& sp) -> Acts::Vector3 {
             return sp.stripCenterDistance().cast<double>();
           });
       m_finderCfg.getTopStripCenterPosition.connect(
           [](const void*, const value_type& sp) -> Acts::Vector3 {
             return sp.topStripCenter().cast<double>();
           });
     }
  
     // Fast tracking
     // manually convert the two types
     for (const auto& vec : m_rRangeMiddleSP) {
     std::vector<float> convertedVec;
     
     for (const auto& val : vec) {
         convertedVec.push_back(static_cast<float>(val));
     }
     
     m_finderCfg.rRangeMiddleSP.push_back(convertedVec);
     }
     
     // define cuts used for fast tracking configuration
     if (m_useExperimentCuts) {
       m_finderCfg.experimentCuts.connect(
                      [](const void*, float bottomRadius, float cotTheta) -> bool {
                        
                        float fastTrackingRMin = 50.;
                        float fastTrackingCotThetaMax = 1.5;
                        
                        if (bottomRadius < fastTrackingRMin and
                            (cotTheta > fastTrackingCotThetaMax or
                         cotTheta < -fastTrackingCotThetaMax)) {
                          return false;
                        }
                        return true;
                      });
     }
     
     // Configuration for Acts::SeedFilter (used by FinderCfg)
     Acts::SeedFilterConfig filterCfg;
     filterCfg.deltaRMin = m_deltaRMin;
     filterCfg.maxSeedsPerSpM = m_maxSeedsPerSpM;
     filterCfg.useDeltaRorTopRadius = m_useDeltaRorTopRadius;
     filterCfg.seedConfirmation = m_seedConfirmationInFilter;
     filterCfg.maxSeedsPerSpMConf = m_maxSeedsPerSpMConf;
     filterCfg.maxQualitySeedsPerSpMConf = m_maxQualitySeedsPerSpMConf;
     filterCfg.centralSeedConfirmationRange = m_finderCfg.centralSeedConfirmationRange;
     filterCfg.forwardSeedConfirmationRange = m_finderCfg.forwardSeedConfirmationRange;
     filterCfg.impactWeightFactor = m_impactWeightFactor;
     filterCfg.zOriginWeightFactor = m_zOriginWeightFactor;
     filterCfg.compatSeedWeight = m_compatSeedWeight;
     filterCfg.compatSeedLimit = m_compatSeedLimit;
     filterCfg.seedWeightIncrement = m_seedWeightIncrement;
     filterCfg.numSeedIncrement = m_numSeedIncrement;
     filterCfg.deltaInvHelixDiameter = m_deltaInvHelixDiameter;
     m_finderCfg.seedFilter = std::make_unique<Acts::SeedFilter< value_type > >(filterCfg.toInternalUnits());    
  
     m_finderCfg = m_finderCfg.toInternalUnits().calculateDerivedQuantities();
  
     // Grid Configuration
     m_gridCfg.minPt = m_minPt;
     m_gridCfg.cotThetaMax = m_cotThetaMax;
     m_gridCfg.impactMax = m_impactMax;
     m_gridCfg.zMin = m_zMin;
     m_gridCfg.zMax = m_zMax;
     m_gridCfg.phiMin = m_gridPhiMin;
     m_gridCfg.phiMax = m_gridPhiMax;
     m_gridCfg.zBinEdges = m_zBinEdges;
     m_gridCfg.deltaRMax = m_deltaRMax;
     m_gridCfg.rMax = m_gridRMax;
     m_gridCfg.phiBinDeflectionCoverage = m_phiBinDeflectionCoverage;
     m_gridCfg.maxPhiBins = m_maxPhiBins;
     m_gridCfg = m_gridCfg.toInternalUnits();
  
     // Seed Finder
     m_finder = {m_finderCfg};
  
     return StatusCode::SUCCESS;
   }

Member Data Documentation

◆ m_binSizeR

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

protected

Initial value:

{this, "binSizeR", 1. * Acts::UnitConstants::mm,

"defining radial bin for space point sorting"}

Definition at line 119 of file SeedingTool.h.

◆ m_bottomBinFinder

std::unique_ptr< Acts::GridBinFinder< 2ul > > ActsTrk::SeedingTool::m_bottomBinFinder {nullptr}

private

Definition at line 258 of file SeedingTool.h.

◆ m_collisionRegionMax

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

protected

Initial value:

{this, "collisionRegionMax", 200. * Acts::UnitConstants::mm,

"limiting location of collision region in z"}

Definition at line 135 of file SeedingTool.h.

◆ m_collisionRegionMin

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

protected

Initial value:

{this, "collisionRegionMin", -200. * Acts::UnitConstants::mm,

"limiting location of collision region in z"}

Definition at line 133 of file SeedingTool.h.

◆ m_compatSeedLimit

Gaudi::Property< std::size_t > ActsTrk::SeedingTool::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 226 of file SeedingTool.h.

◆ m_compatSeedWeight

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

protected

Initial value:

{this, "compatSeedWeight", 100.,

"seed weight increased by this value if a compatible seed has been found"}

Definition at line 224 of file SeedingTool.h.

◆ m_cotThetaMax

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

protected

Initial value:

{this, "cotThetaMax", 27.2899,

"cot of maximum theta angle"}

Definition at line 93 of file SeedingTool.h.

◆ m_deltaInvHelixDiameter

Gaudi::Property<float> ActsTrk::SeedingTool::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 240 of file SeedingTool.h.

◆ m_deltaRMax

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

protected

Initial value:

{this, "deltaRMax", 280. * Acts::UnitConstants::mm,

"maximum distance in r between two measurements within one seed"}

Definition at line 99 of file SeedingTool.h.

◆ m_deltaRMaxBottomSP

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

protected

Initial value:

{this, "deltaRMaxBottomSP", 150. * Acts::UnitConstants::mm,

"maximum distance in r between middle and top SP"}

Definition at line 129 of file SeedingTool.h.

◆ m_deltaRMaxTopSP

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

protected

Initial value:

{this, "deltaRMaxTopSP", 280. * Acts::UnitConstants::mm,

"maximum distance in r between middle and top SP"}

Definition at line 125 of file SeedingTool.h.

◆ m_deltaRMiddleMaxSPRange

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

protected

Initial value:

{this, "deltaRMiddleMaxSPRange", 10.,

"delta R for middle SP range (max)"}

Definition at line 156 of file SeedingTool.h.

◆ m_deltaRMiddleMinSPRange

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

protected

Initial value:

{this, "deltaRMiddleMinSPRange", 10.,

"delta R for middle SP range (min)"}

Definition at line 154 of file SeedingTool.h.

◆ m_deltaRMin

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

protected

Initial value:

{this, "deltaRMin", 20. * Acts::UnitConstants::mm,

"minimum distance in r between two measurements within one seed"}

Definition at line 121 of file SeedingTool.h.

◆ m_deltaRMinBottomSP

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

protected

Initial value:

{this, "deltaRMinBottomSP", 6. * Acts::UnitConstants::mm,

"minimum distance in r between middle and top SP"}

Definition at line 127 of file SeedingTool.h.

◆ m_deltaRMinTopSP

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

protected

Initial value:

{this, "deltaRMinTopSP", 6. * Acts::UnitConstants::mm,

"minimum distance in r between middle and top SP"}

Definition at line 123 of file SeedingTool.h.

◆ m_deltaZMax

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

protected

Initial value:

{this, "deltaZMax", 600,

"maximum distance in z between two measurements within one seed"}

Definition at line 131 of file SeedingTool.h.

◆ m_finder

Acts::SeedFinder< value_type, Acts::CylindricalSpacePointGrid<value_type> > ActsTrk::SeedingTool::m_finder

protected

Definition at line 82 of file SeedingTool.h.

◆ m_finderCfg

Acts::SeedFinderConfig< value_type > ActsTrk::SeedingTool::m_finderCfg

protected

Definition at line 83 of file SeedingTool.h.

◆ m_gridCfg

Acts::CylindricalSpacePointGridConfig ActsTrk::SeedingTool::m_gridCfg

protected

Definition at line 84 of file SeedingTool.h.

◆ m_gridPhiMax

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

protected

Initial value:

{this, "gridPhiMax", M_PI,

"phi max for space point grid formation"}

Definition at line 110 of file SeedingTool.h.

◆ m_gridPhiMin

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

protected

Initial value:

{this, "gridPhiMin", -M_PI,

"phi min for space point grid formation"}

Definition at line 108 of file SeedingTool.h.

◆ m_gridRMax

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

protected

Initial value:

{this, "gridRMax", 320. * Acts::UnitConstants::mm,

"radial extension of subdetector to be used in grid building"}

Definition at line 106 of file SeedingTool.h.

◆ m_impactMax

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

protected

Initial value:

{this, "impactMax", 2. * Acts::UnitConstants::mm,

"maximum impact parameter"}

Definition at line 101 of file SeedingTool.h.

◆ m_impactWeightFactor

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

protected

Initial value:

{this, "impactWeightFactor", 100.,

"the impact parameters (d0) is multiplied by this factor and subtracted from weight"}

Definition at line 221 of file SeedingTool.h.

◆ m_interactionPointCut

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

protected

Initial value:

{this, "interactionPointCut", true,

"Enable cut on the compatibility between interaction point and SPs"}

Definition at line 145 of file SeedingTool.h.

◆ m_maxPhiBins

Gaudi::Property< int > ActsTrk::SeedingTool::m_maxPhiBins {this, "maxPhiBins", 200, "max number of bins"}

protected

Definition at line 114 of file SeedingTool.h.

◆ m_maxPtScattering

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

protected

Initial value:

{this, "maxPtScattering", 10e6,

"Upper pt limit for scattering calculation"}

Definition at line 139 of file SeedingTool.h.

◆ m_maxQualitySeedsPerSpMConf

Gaudi::Property< std::size_t > ActsTrk::SeedingTool::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 236 of file SeedingTool.h.

◆ m_maxSeedsPerSpM

Gaudi::Property< int > ActsTrk::SeedingTool::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 143 of file SeedingTool.h.

◆ m_maxSeedsPerSpMConf

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

protected

Initial value:

{this, "maxSeedsPerSpMConf", 5,

"Maximum number of lower quality seeds in seed confirmation."}

Definition at line 234 of file SeedingTool.h.

◆ m_minPt

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

protected

Initial value:

{this, "minPt", 900. * Acts::UnitConstants::MeV,

"lower pT cutoff for seeds"}

Definition at line 91 of file SeedingTool.h.

◆ m_navigation

std::array<std::vector<std::size_t>, 2ul> ActsTrk::SeedingTool::m_navigation {}

private

Definition at line 261 of file SeedingTool.h.

◆ m_numPhiNeighbors

Gaudi::Property< int > ActsTrk::SeedingTool::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 252 of file SeedingTool.h.

◆ m_numSeedIncrement

Gaudi::Property< float > ActsTrk::SeedingTool::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 230 of file SeedingTool.h.

◆ m_phiBinDeflectionCoverage

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

protected

Initial value:

{this, "phiBinDeflectionCoverage", 3,

"sets of consecutive phi bins to cover full deflection of minimum pT particle"}

Definition at line 112 of file SeedingTool.h.

◆ m_phiMax

Gaudi::Property<float> ActsTrk::SeedingTool::m_phiMax {this, "phiMax", M_PI, ""}

protected

Definition at line 214 of file SeedingTool.h.

◆ m_phiMin

Gaudi::Property<float> ActsTrk::SeedingTool::m_phiMin {this, "phiMin", -M_PI, ""}

protected

Definition at line 213 of file SeedingTool.h.

◆ m_radLengthPerSeed

Gaudi::Property< float > ActsTrk::SeedingTool::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 141 of file SeedingTool.h.

◆ m_rAlign

Gaudi::Property<float> ActsTrk::SeedingTool::m_rAlign {this, "rAlign", 0 * Acts::UnitConstants::mm, ""}

protected

Definition at line 217 of file SeedingTool.h.

◆ m_rMax

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

protected

Initial value:

{this, "rMax", 320. * Acts::UnitConstants::mm,

"limiting location of measurements"}

Definition at line 117 of file SeedingTool.h.

◆ m_rMin

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

protected

Definition at line 215 of file SeedingTool.h.

◆ m_rRangeMiddleSP

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

protected

Initial value:

{this, "rRangeMiddleSP", 
      {{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}}, 
      "radial range for middle SP"}

Definition at line 151 of file SeedingTool.h.

◆ m_seedConfCentralMaxZOrigin

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

protected

Initial value:

{this, "seedConfCentralMaxZOrigin", 150 * Acts::UnitConstants::mm,

"Maximum zOrigin in seed confirmation"}

Definition at line 178 of file SeedingTool.h.

◆ m_seedConfCentralMinBottomRadius

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

protected

Initial value:

{this, "seedConfCentralMinBottomRadius", 60 * Acts::UnitConstants::mm,

"Minimum radius for bottom SP in seed confirmation"}

Definition at line 175 of file SeedingTool.h.

◆ m_seedConfCentralMinImpact

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

protected

Initial value:

{this, "seedConfCentralMinImpact", 1. * Acts::UnitConstants::mm,

"Minimum impact parameter for seed confirmation"}

Definition at line 181 of file SeedingTool.h.

◆ m_seedConfCentralNTopLargeR

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

protected

Initial value:

{this, "seedConfCentralNTopLargeR", 1,

"nTop for large R central seed confirmation"}

Definition at line 169 of file SeedingTool.h.

◆ m_seedConfCentralNTopSmallR

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

protected

Initial value:

{this, "seedConfCentralNTopSmallR", 2,

"nTop for small R central seed confirmation"}

Definition at line 172 of file SeedingTool.h.

◆ m_seedConfCentralRMax

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

protected

Initial value:

{this, "seedConfCentralRMax", 140. * Acts::UnitConstants::mm,

"maximum r for central seed confirmation "}

Definition at line 166 of file SeedingTool.h.

◆ m_seedConfCentralZMax

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

protected

Initial value:

{this, "seedConfCentralZMax", 250. * Acts::UnitConstants::mm,

"maximum z for central seed confirmation "}

Definition at line 163 of file SeedingTool.h.

◆ m_seedConfCentralZMin

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

protected

Initial value:

{this, "seedConfCentralZMin", -250. * Acts::UnitConstants::mm,

"minimum z for central seed confirmation "}

Definition at line 160 of file SeedingTool.h.

◆ m_seedConfForwardMaxZOrigin

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

protected

Initial value:

{this, "seedConfForwardMaxZOrigin", 150 * Acts::UnitConstants::mm,

"Maximum zOrigin in seed confirmation"}

Definition at line 202 of file SeedingTool.h.

◆ m_seedConfForwardMinBottomRadius

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

protected

Initial value:

{this, "seedConfForwardMinBottomRadius", 60 * Acts::UnitConstants::mm,

"Minimum radius for bottom SP in seed confirmation"}

Definition at line 199 of file SeedingTool.h.

◆ m_seedConfForwardMinImpact

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

protected

Initial value:

{this, "seedConfForwardMinImpact", 1. * Acts::UnitConstants::mm,

"Minimum impact parameter for seed confirmation"}

Definition at line 205 of file SeedingTool.h.

◆ m_seedConfForwardNTopLargeR

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

protected

Initial value:

{this, "seedConfForwardNTopLargeR", 1,

"nTop for large R forward seed confirmation"}

Definition at line 193 of file SeedingTool.h.

◆ m_seedConfForwardNTopSmallR

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

protected

Initial value:

{this, "seedConfForwardNTopSmallR", 2,

"nTop for small R forward seed confirmation"}

Definition at line 196 of file SeedingTool.h.

◆ m_seedConfForwardRMax

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

protected

Initial value:

{this, "seedConfForwardRMax", 140. * Acts::UnitConstants::mm,

"maximum r for forward seed confirmation "}

Definition at line 190 of file SeedingTool.h.

◆ m_seedConfForwardZMax

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

protected

Initial value:

{this, "seedConfForwardZMax", 3000. * Acts::UnitConstants::mm,

"maximum z for forward seed confirmation "}

Definition at line 187 of file SeedingTool.h.

◆ m_seedConfForwardZMin

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

protected

Initial value:

{this, "seedConfForwardZMin", -3000. * Acts::UnitConstants::mm,

"minimum z for forward seed confirmation "}

Definition at line 184 of file SeedingTool.h.

◆ m_seedConfirmation

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

protected

Initial value:

{this, "seedConfirmation", true,

"run seed confirmation"}

Definition at line 158 of file SeedingTool.h.

◆ m_seedConfirmationInFilter

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

protected

Initial value:

{this, "seedConfirmationInFilter", true,

"run seed confirmation"}

Definition at line 232 of file SeedingTool.h.

◆ m_seedQualitySelection

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

protected

Initial value:

{this, "doSeedQualitySelection", true,

"Select seed according to quality criteria"}

Definition at line 87 of file SeedingTool.h.

◆ m_seedWeightIncrement

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

protected

Initial value:

{this, "seedWeightIncrement", 0.,

"increment in seed weight if needed"}

Definition at line 228 of file SeedingTool.h.

◆ m_sigmaError

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

protected

Definition at line 218 of file SeedingTool.h.

◆ m_sigmaScattering

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

protected

Initial value:

{this, "sigmaScattering", 2.,

"how many sigmas of scattering angle should be considered"}

Definition at line 137 of file SeedingTool.h.

◆ m_toleranceParam

Gaudi::Property<float> ActsTrk::SeedingTool::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 211 of file SeedingTool.h.

◆ m_topBinFinder

std::unique_ptr< Acts::GridBinFinder< 2ul > > ActsTrk::SeedingTool::m_topBinFinder {nullptr}

private

Definition at line 259 of file SeedingTool.h.

◆ m_useDeltaRorTopRadius

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

protected

Initial value:

{this, "useDeltaRorTopRadius", true,

"use deltaR (top radius - middle radius) instead of top radius"}

Definition at line 238 of file SeedingTool.h.

◆ m_useDetailedDoubleMeasurementInfo

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

protected

Initial value:

{this, "useDetailedDoubleMeasurementInfo", false,

"enable use of double measurement details"}

Definition at line 208 of file SeedingTool.h.

◆ m_useExperimentCuts

Gaudi::Property< bool > ActsTrk::SeedingTool::m_useExperimentCuts {this, "useExperimentCuts", false, ""}

protected

Definition at line 255 of file SeedingTool.h.

◆ m_useVariableMiddleSPRange

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

protected

Initial value:

{this, "useVariableMiddleSPRange", true,

"Enable variable range to search for middle SPs"}

Definition at line 149 of file SeedingTool.h.

◆ m_zAlign

Gaudi::Property<float> ActsTrk::SeedingTool::m_zAlign {this, "zAlign", 0 * Acts::UnitConstants::mm, ""}

protected

Definition at line 216 of file SeedingTool.h.

◆ m_zBinEdges

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

protected

Initial value:

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

Definition at line 103 of file SeedingTool.h.

◆ m_zBinNeighborsBottom

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

protected

Initial value:

{this, "zBinNeighborsBottom",
      {{0, 1},  {0, 1},  {0, 1},  {0, 1}, {0, 1},  {0, 0},  {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}},
      "vector containing the map of z bins in the top layers"}

Definition at line 249 of file SeedingTool.h.

◆ m_zBinNeighborsTop

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

protected

Initial value:

{this,
      "zBinNeighborsTop",
      {{0, 0},  {-1, 0}, {-1, 0}, {-1, 0}, {-1, 0}, {-1, 1}, {0, 1},  {0, 1}, {0, 1},  {0, 1},  {0, 0}},
      "vector containing the map of z bins in the top layers"}

Definition at line 245 of file SeedingTool.h.

◆ m_zBinsCustomLooping

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

protected

Initial value:

{this, "zBinsCustomLooping",

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

Definition at line 147 of file SeedingTool.h.

◆ m_zMax

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

protected

Initial value:

{this, "zMax", 3000. * Acts::UnitConstants::mm,

"limiting location of measurements"}

Definition at line 97 of file SeedingTool.h.

◆ m_zMin

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

protected

Initial value:

{this, "zMin", -3000. * Acts::UnitConstants::mm,

"limiting location of measurements"}

Definition at line 95 of file SeedingTool.h.

◆ m_zOriginWeightFactor

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

protected

Definition at line 223 of file SeedingTool.h.

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ seed_type

◆ value_type

Constructor & Destructor Documentation

◆ SeedingTool()

◆ ~SeedingTool()

Member Function Documentation

◆ createSeeds() [1/2]

◆ createSeeds() [2/2]

◆ initialize()

◆ prepareConfiguration()

Member Data Documentation

◆ m_binSizeR

◆ m_bottomBinFinder

◆ m_collisionRegionMax

◆ m_collisionRegionMin

◆ m_compatSeedLimit

◆ m_compatSeedWeight

◆ m_cotThetaMax

◆ m_deltaInvHelixDiameter

◆ m_deltaRMax

◆ m_deltaRMaxBottomSP

◆ m_deltaRMaxTopSP

◆ m_deltaRMiddleMaxSPRange

◆ m_deltaRMiddleMinSPRange

◆ m_deltaRMin

◆ m_deltaRMinBottomSP

◆ m_deltaRMinTopSP

◆ m_deltaZMax

◆ m_finder

◆ m_finderCfg

◆ m_gridCfg

◆ m_gridPhiMax

◆ m_gridPhiMin

◆ m_gridRMax

◆ m_impactMax

◆ m_impactWeightFactor

◆ m_interactionPointCut

◆ m_maxPhiBins

◆ m_maxPtScattering

◆ m_maxQualitySeedsPerSpMConf

◆ m_maxSeedsPerSpM

◆ m_maxSeedsPerSpMConf

◆ m_minPt

◆ m_navigation

◆ m_numPhiNeighbors

◆ m_numSeedIncrement

◆ m_phiBinDeflectionCoverage

◆ m_phiMax

◆ m_phiMin

◆ m_radLengthPerSeed

◆ m_rAlign

◆ m_rMax

◆ m_rMin

◆ m_rRangeMiddleSP

◆ m_seedConfCentralMaxZOrigin

◆ m_seedConfCentralMinBottomRadius

◆ m_seedConfCentralMinImpact

◆ m_seedConfCentralNTopLargeR

◆ m_seedConfCentralNTopSmallR

◆ m_seedConfCentralRMax

◆ m_seedConfCentralZMax

◆ m_seedConfCentralZMin

◆ m_seedConfForwardMaxZOrigin

◆ m_seedConfForwardMinBottomRadius

◆ m_seedConfForwardMinImpact

◆ m_seedConfForwardNTopLargeR

◆ m_seedConfForwardNTopSmallR

◆ m_seedConfForwardRMax

◆ m_seedConfForwardZMax

◆ m_seedConfForwardZMin

◆ m_seedConfirmation

◆ m_seedConfirmationInFilter