ActsTrk::SeedingTool Class Reference

#include <SeedingTool.h>

Inheritance diagram for ActsTrk::SeedingTool:

Collaboration diagram for ActsTrk::SeedingTool:

Classes
struct	external_spacepoint

Public Types
using	value_type = typename Acts::SpacePointContainer<ActsTrk::SpacePointCollector, Acts::detail::RefHolder>::SpacePointProxyType
using	seed_type = Acts::Seed< value_type, 3ul >
using	external_type

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 Acts::SpacePointContainer< ActsTrk::SpacePointCollector, Acts::detail::RefHolder > &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, ActsTrk::SeedContainer &seeds) const
StatusCode	prepareConfiguration ()

Protected Attributes
const PixelID *	m_pixelId { nullptr }
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< 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 {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< 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 {this, "phiMin", -std::numbers::pi_v<float>, ""}
Gaudi::Property< float >	m_phiMax {this, "phiMax", std::numbers::pi_v<float>, ""}
Gaudi::Property< float >	m_rMin {this, "rMin", 0 * Acts::UnitConstants::mm, ""}
Gaudi::Property< float >	m_zAlign {this, "zAlign", 0 * Acts::UnitConstants::mm, ""}
Gaudi::Property< float >	m_rAlign {this, "rAlign", 0 * Acts::UnitConstants::mm, ""}
Gaudi::Property< float >	m_sigmaError {this, "sigmaError", 5, ""}
Gaudi::Property< float >	m_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 {this, "useExperimentCuts", false, ""}
Gaudi::Property< int >	m_stateVectorReserveSize {this, "stateVectorReserveSize", 500, "Size of the initial Seeding State internal vectors"}

Private Member Functions
const Acts::Logger &	logger () const
	Private access to the logger.
bool	spacePointSelectionFunction (const value_type &sp) const
bool	doubletSelectionFunction (const value_type &middle, const value_type &other, float cotTheta, bool isBottomCandidate) const

Private Attributes
std::unique_ptr< Acts::GridBinFinder< 3ul > >	m_bottomBinFinder {nullptr}
std::unique_ptr< Acts::GridBinFinder< 3ul > >	m_topBinFinder {nullptr}
std::array< std::vector< std::size_t >, 3ul >	m_navigation {}
std::unique_ptr< const Acts::Logger >	m_logger {nullptr}
	logging instance
Gaudi::Property< float >	m_ExpCutrMin {this, "SpSelectionExpCutrMin", 45. * Acts::UnitConstants::mm}

Detailed Description

Definition at line 40 of file SeedingTool.h.

Member Typedef Documentation

external_type

using ActsTrk::SeedingTool::external_type

Initial value:

 typename std::conditional< 
      std::is_const< typename value_type::ValueType >::value,
      typename std::remove_const< typename value_type::ValueType >::type,
      typename value_type::ValueType
      >::type

Definition at line 45 of file SeedingTool.h.

seed_type

using ActsTrk::SeedingTool::seed_type = Acts::Seed< value_type, 3ul >

Definition at line 44 of file SeedingTool.h.

value_type

using ActsTrk::SeedingTool::value_type = typename Acts::SpacePointContainer<ActsTrk::SpacePointCollector, Acts::detail::RefHolder>::SpacePointProxyType

Definition at line 43 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 24 of file SeedingTool.cxx.

    : base_class(type, name, parent)
  {}

~SeedingTool()

virtual ActsTrk::SeedingTool::~SeedingTool ( )

virtualdefault

Member Function Documentation

createSeeds() [1/2]

ATH_FLATTEN StatusCode ActsTrk::SeedingTool::createSeeds ( const EventContext & ctx, const Acts::SpacePointContainer< ActsTrk::SpacePointCollector, Acts::detail::RefHolder > & spContainer, const Acts::Vector3 & beamSpotPos, const Acts::Vector3 & bField, ActsTrk::SeedContainer & seedContainer ) const

overridevirtual

Definition at line 218 of file SeedingTool.cxx.

  {
    // Create Seeds
    //TODO POSSIBLE OPTIMISATION come back here: see MR !52399 ( i.e. use static thread_local)
    ATH_CHECK(createSeeds(spContainer.begin(),
              spContainer.end(),
              beamSpotPos,
              bField,
              seedContainer));
 
    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, ActsTrk::SeedContainer & seeds ) const

protected

Definition at line 237 of file SeedingTool.cxx.

  {
    static_assert(std::is_same<typename external_spacepoint< external_iterator_t >::type, const value_type&>::value,
          "Inconsistent type");
 
    if (spBegin == spEnd)
      return StatusCode::SUCCESS;
 
    seedContainer.spacePoints().reserve(std::distance(spBegin, spEnd));
    for (auto sp = spBegin; sp != spEnd; ++sp) {
      seedContainer.spacePoints().push_back(&(*sp).externalSpacePoint());
    }
    std::vector< seed_type > seeds;
 
    // 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);
 
 
 
    
    Acts::CylindricalSpacePointGrid< value_type > grid =
      Acts::CylindricalSpacePointGridCreator::createGrid< value_type >(m_gridCfg, gridOpts, logger());
 
    Acts::CylindricalSpacePointGridCreator::fillGrid(m_finderCfg, finderOpts, grid,
                             spBegin, spEnd, logger());
 
    // Compute radius Range
    // we rely on the fact the grid is storing the proxies
    // with a sorting in the radius
    float minRange = std::numeric_limits<float>::max();
    float maxRange = std::numeric_limits<float>::lowest();
    for (const auto& coll : grid) {
      if (coll.empty()) {
        continue;
      }
      const auto* firstEl = coll.front();
      const auto* lastEl = coll.back();
      minRange = std::min(firstEl->radius(), minRange);
      maxRange = std::max(lastEl->radius(), maxRange);
    }
    
    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(minRange/2)*2 + m_finderCfg.deltaRMiddleMinSPRange,
                          std::floor(maxRange/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;
 
    // Already reserve the state vectors here.
    
    state.topSpVec.reserve(m_stateVectorReserveSize);
    state.curvatures.reserve(m_stateVectorReserveSize);
    state.impactParameters.reserve(m_stateVectorReserveSize);
    state.linCircleTop.reserve(m_stateVectorReserveSize);
    state.compatBottomSP.reserve(m_stateVectorReserveSize);
    state.compatTopSP.reserve(m_stateVectorReserveSize);
        
    state.spacePointMutableData.resize(std::distance(spBegin, spEnd));
 
    for (const auto& [bottom, middle, top] : spacePointsGrouping) {
      m_finder.createSeedsForGroup(finderOpts, state, spacePointsGrouping.grid(), 
          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 seed_type& seed) -> bool 
    {
      float seed_quality = seed.seedQuality();
      float bottom_quality = state.spacePointMutableData.quality(seed.sp()[0]->index());
      float middle_quality = state.spacePointMutableData.quality(seed.sp()[1]->index());
      float top_quality = state.spacePointMutableData.quality(seed.sp()[2]->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());     
    }
 
 
    // Store seeds
    seedContainer.reserve(seeds.size());
    for(const auto& seed: seeds) {
      seedContainer.push_back(&seed);
    }
 
    return StatusCode::SUCCESS;
  }

doubletSelectionFunction()

bool ActsTrk::SeedingTool::doubletSelectionFunction ( const value_type & middle, const value_type & other, float cotTheta, bool isBottomCandidate ) const

inlineprivate

Definition at line 350 of file SeedingTool.h.

                                                    {
      // 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.z()) > 1500 and
          middle.radius() > 100 and middle.radius() < 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 and other.radius() < m_ExpCutrMin and
          absCotTheta > cotThetaEta120 and
          absCotTheta < cotThetaEta360) {
        return false;
      }
      
      return true;
    }

initialize()

StatusCode ActsTrk::SeedingTool::initialize ( )

overridevirtual

Definition at line 30 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_rBinNeighborsTop);
    ATH_MSG_DEBUG("   " << m_rBinNeighborsBottom);
    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_rBinEdges);
    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_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 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);
 
    // Make the logger And Propagate to ACTS routines
    m_logger = makeActsAthenaLogger(this, "Acts");
 
    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_rBinEdges.size() - 1 !=
    m_rBinNeighborsTop.size() and
    not m_rBinNeighborsTop.empty()) {
      ATH_MSG_ERROR("Inconsistent config rBinNeighborsTop");
      return StatusCode::FAILURE;
    }
    
    if (m_rBinEdges.size() - 1 !=
    m_rBinNeighborsBottom.size() and
    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;
        }
      }
    }
 
    ATH_CHECK( prepareConfiguration() );
 
    m_bottomBinFinder = std::make_unique< Acts::GridBinFinder< 3ul > >(m_numPhiNeighbors.value(),
                                       m_zBinNeighborsBottom.value(),
                                       m_rBinNeighborsBottom.value());
    m_topBinFinder = std::make_unique< Acts::GridBinFinder< 3ul > >(m_numPhiNeighbors.value(),
                                    m_zBinNeighborsTop.value(),
                                    m_rBinNeighborsTop.value());
 
    m_navigation[0ul] = {};
    m_navigation[1ul] = m_finderCfg.zBinsCustomLooping;
    m_navigation[2ul] = m_rBinsCustomLooping.value();
 
    if (detStore()->retrieve(m_pixelId, "PixelID").isFailure()) {
        ATH_MSG_ERROR("Could not get PixelID helper !");
        return StatusCode::FAILURE;
    }
 
    return StatusCode::SUCCESS;
  }

logger()

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

inlineprivate

Private access to the logger.

Definition at line 286 of file SeedingTool.h.

{ return *m_logger; }

prepareConfiguration()

StatusCode ActsTrk::SeedingTool::prepareConfiguration ( )

protected

Definition at line 367 of file SeedingTool.cxx.

                                    {
    assert(m_logger != nullptr);
    
    // 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;
 
    // Fast tracking
    // manually convert the two types
    for (const auto& vec : m_rRangeMiddleSP) {
    std::vector<float> convertedVec;
    convertedVec.reserve(vec.size());
    for (const auto& val : vec) {
        convertedVec.push_back(static_cast<float>(val));
    }
    
    m_finderCfg.rRangeMiddleSP.push_back(std::move(convertedVec));
    }
 
 
    // define cuts used for fast tracking configuration
    if (m_useExperimentCuts) {      
      
      // This function will be applied to select space points during grid filling
      m_finderCfg.spacePointSelector
        .connect<&ActsTrk::SeedingTool::spacePointSelectionFunction>(this);
 
      m_finderCfg.experimentCuts
        .connect<&ActsTrk::SeedingTool::doubletSelectionFunction>(this);
      
    }
    
    // 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(), logger().cloneWithSuffix("Filter"));    
 
    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.rBinEdges = m_rBinEdges;
    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 = decltype(m_finder){m_finderCfg, logger().cloneWithSuffix("Finder")};
 
    return StatusCode::SUCCESS;
  }

spacePointSelectionFunction()

bool ActsTrk::SeedingTool::spacePointSelectionFunction ( const value_type & sp ) const

inlineprivate

Definition at line 294 of file SeedingTool.h.

                                                                        {
 
      float r = sp.radius();
      float zabs = std::abs(sp.z());
      float absCotTheta = zabs / r;
      
      // checking configuration to remove pixel space points
      Identifier identifier = m_pixelId->wafer_id(sp.externalSpacePoint().elementIdList().at(0));
      if (m_pixelId->is_barrel(identifier)) {
    if (zabs > 200 and
        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 and
      r < m_ExpCutrMin)
    return false;   
 
      
      // Outer layers
      // Above 2.20
      static constexpr float cotThetaEta220 = 4.4571;
      if (absCotTheta > cotThetaEta220 and
      r > 260.)
    return false;
      
      // Above 2.60
      static constexpr float cotThetaEta260 = 6.6947;
      if (absCotTheta > cotThetaEta260 and
          r > 200.)
    return false;
 
      // Above 3.20
      static constexpr float cotThetaEta320 = 12.2459;
      if (absCotTheta > cotThetaEta320 and
          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::SeedingTool::m_binSizeR

protected

Initial value:

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

Definition at line 133 of file SeedingTool.h.

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

m_bottomBinFinder

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

private

Definition at line 280 of file SeedingTool.h.

{nullptr};

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 149 of file SeedingTool.h.

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

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 147 of file SeedingTool.h.

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

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 242 of file SeedingTool.h.

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

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 240 of file SeedingTool.h.

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

m_cotThetaMax

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

protected

Initial value:

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

Definition at line 105 of file SeedingTool.h.

                                         {this, "cotThetaMax", 27.2899,
      "cot of maximum theta angle"}; // Used in SeedfinderConfig as well

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 256 of file SeedingTool.h.

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

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 111 of file SeedingTool.h.

                                       {this, "deltaRMax",  280. * Acts::UnitConstants::mm,
      "maximum distance in r between two measurements within one seed"}; // Used in SeedfinderConfig as well

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 143 of file SeedingTool.h.

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

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 139 of file SeedingTool.h.

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

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 172 of file SeedingTool.h.

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

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 170 of file SeedingTool.h.

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

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 135 of file SeedingTool.h.

                                       {this, "deltaRMin", 20. * Acts::UnitConstants::mm,
      "minimum distance in r between two measurements within one seed"}; // Used in SeedFilterConfig as well

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 141 of file SeedingTool.h.

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

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 137 of file SeedingTool.h.

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

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 145 of file SeedingTool.h.

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

m_ExpCutrMin

Gaudi::Property<float> ActsTrk::SeedingTool::m_ExpCutrMin {this, "SpSelectionExpCutrMin", 45. * Acts::UnitConstants::mm}

private

Definition at line 292 of file SeedingTool.h.

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

m_finder

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

protected

Definition at line 94 of file SeedingTool.h.

m_finderCfg

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

protected

Definition at line 95 of file SeedingTool.h.

m_gridCfg

Acts::CylindricalSpacePointGridConfig ActsTrk::SeedingTool::m_gridCfg

protected

Definition at line 96 of file SeedingTool.h.

m_gridPhiMax

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

protected

Initial value:

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

Definition at line 124 of file SeedingTool.h.

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

m_gridPhiMin

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

protected

Initial value:

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

Definition at line 122 of file SeedingTool.h.

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

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 120 of file SeedingTool.h.

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

m_impactMax

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

protected

Initial value:

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

Definition at line 113 of file SeedingTool.h.

                                       {this, "impactMax", 2. * Acts::UnitConstants::mm,
      "maximum impact parameter"}; // Used in SeedfinderConfig as well

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 237 of file SeedingTool.h.

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

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 159 of file SeedingTool.h.

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

m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::SeedingTool::m_logger {nullptr}

private

logging instance

Definition at line 288 of file SeedingTool.h.

{nullptr};

m_maxPhiBins

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

protected

Definition at line 128 of file SeedingTool.h.

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

m_maxPtScattering

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

protected

Initial value:

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

Definition at line 153 of file SeedingTool.h.

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

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 252 of file SeedingTool.h.

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

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 157 of file SeedingTool.h.

                                          {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."}; // Used in SeedFilterConfig as well

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 250 of file SeedingTool.h.

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

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 103 of file SeedingTool.h.

                                   {this, "minPt", 900. * Acts::UnitConstants::MeV,
      "lower pT cutoff for seeds"}; // Used in SeedfinderConfig as well

m_navigation

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

private

Definition at line 283 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 272 of file SeedingTool.h.

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

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 246 of file SeedingTool.h.

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

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 126 of file SeedingTool.h.

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

m_phiMax

Gaudi::Property<float> ActsTrk::SeedingTool::m_phiMax {this, "phiMax", std::numbers::pi_v<float>, ""}

protected

Definition at line 230 of file SeedingTool.h.

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

m_phiMin

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

protected

Definition at line 229 of file SeedingTool.h.

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

m_pixelId

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

protected

Definition at line 92 of file SeedingTool.h.

{ nullptr };

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 155 of file SeedingTool.h.

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

m_rAlign

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

protected

Definition at line 233 of file SeedingTool.h.

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

m_rBinEdges

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

protected

Initial value:

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

Definition at line 118 of file SeedingTool.h.

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

m_rBinNeighborsBottom

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

protected

Initial value:

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

Definition at line 270 of file SeedingTool.h.

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

m_rBinNeighborsTop

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

protected

Initial value:

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

Definition at line 268 of file SeedingTool.h.

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

m_rBinsCustomLooping

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

protected

Initial value:

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

Definition at line 163 of file SeedingTool.h.

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

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 131 of file SeedingTool.h.

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

m_rMin

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

protected

Definition at line 231 of file SeedingTool.h.

{this, "rMin", 0 * Acts::UnitConstants::mm, ""};    

m_rRangeMiddleSP

Gaudi::Property< std::vector<std::vector<double> > > ActsTrk::SeedingTool::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 167 of file SeedingTool.h.

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

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 194 of file SeedingTool.h.

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

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 191 of file SeedingTool.h.

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

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 197 of file SeedingTool.h.

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

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 185 of file SeedingTool.h.

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

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 188 of file SeedingTool.h.

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

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 182 of file SeedingTool.h.

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

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 179 of file SeedingTool.h.

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

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 176 of file SeedingTool.h.

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

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 218 of file SeedingTool.h.

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

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 215 of file SeedingTool.h.

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

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 221 of file SeedingTool.h.

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

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 209 of file SeedingTool.h.

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

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 212 of file SeedingTool.h.

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

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 206 of file SeedingTool.h.

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

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 203 of file SeedingTool.h.

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

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 200 of file SeedingTool.h.

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

m_seedConfirmation

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

protected

Initial value:

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

Definition at line 174 of file SeedingTool.h.

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

m_seedConfirmationInFilter

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

protected

Initial value:

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

Definition at line 248 of file SeedingTool.h.

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

m_seedQualitySelection

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

protected

Initial value:

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

Definition at line 99 of file SeedingTool.h.

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

m_seedWeightIncrement

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

protected

Initial value:

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

Definition at line 244 of file SeedingTool.h.

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

m_sigmaError

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

protected

Definition at line 234 of file SeedingTool.h.

{this, "sigmaError", 5, ""};

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 151 of file SeedingTool.h.

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

m_stateVectorReserveSize

Gaudi::Property< int > ActsTrk::SeedingTool::m_stateVectorReserveSize {this, "stateVectorReserveSize", 500, "Size of the initial Seeding State internal vectors"}

protected

Definition at line 277 of file SeedingTool.h.

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

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 227 of file SeedingTool.h.

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

m_topBinFinder

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

private

Definition at line 281 of file SeedingTool.h.

{nullptr};

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 254 of file SeedingTool.h.

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

m_useDetailedDoubleMeasurementInfo

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

protected

Initial value:

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

Definition at line 224 of file SeedingTool.h.

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

m_useExperimentCuts

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

protected

Definition at line 275 of file SeedingTool.h.

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

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 165 of file SeedingTool.h.

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

m_zAlign

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

protected

Definition at line 232 of file SeedingTool.h.

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

m_zBinEdges

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

                                                    {this, "zBinEdges",
      {-3000., -2700., -2500., -1400., -925., -500., -250.,  250., 500., 925.,   1400.,  2500., 2700, 3000.},
      "enable non equidistant binning in z"}; // Used in SeedfinderConfig as well

m_zBinNeighborsBottom

Gaudi::Property< std::vector<std::pair<int, int> > > ActsTrk::SeedingTool::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 265 of file SeedingTool.h.

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

m_zBinNeighborsTop

Gaudi::Property< std::vector<std::pair<int, int> > > ActsTrk::SeedingTool::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 261 of file SeedingTool.h.

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

m_zBinsCustomLooping

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

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

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 109 of file SeedingTool.h.

                                  {this, "zMax", 3000. * Acts::UnitConstants::mm,
      "limiting location of measurements"}; // Used in SeedfinderConfig as well

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 107 of file SeedingTool.h.

                                  {this, "zMin", -3000. * Acts::UnitConstants::mm,
      "limiting location of measurements"}; // Used in SeedfinderConfig as well

m_zOriginWeightFactor

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

protected

Definition at line 239 of file SeedingTool.h.

{this, "zOriginWeightFactor", 1.};

---

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

• SeedingTool.h
• SeedingTool.cxx