ATLAS Offline Software
Classes | Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes | List of all members
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 = 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
 

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
 
template<typename external_iterator_t >
StatusCode createSeeds (external_iterator_t spBegin, external_iterator_t spEnd, const Acts::Vector3 &beamSpotPos, const Acts::Vector3 &bField, DataVector< Acts::Seed< typename SeedingTool::external_type, 3ul > > &seedContainer) const
 

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, DataVector< Acts::Seed< external_type, 3ul > > &seeds) const
 
StatusCode prepareConfiguration ()
 

Protected Attributes

Acts::SeedFinder< value_type, Acts::CylindricalSpacePointGrid< value_type > > m_finder
 
Acts::SeedFinderConfig< value_typem_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, ""}
 

Private Member Functions

const Acts::Logger & logger () const
 Private access to the logger. More...
 

Static Private Member Functions

static bool itkFastTrackingSPselect (const value_type &sp)
 
static bool itkFastDoubletCut (float bottomRadius, float cotTheta)
 

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 More...
 

Static Private Attributes

static constexpr float m_ExpCutrMin = 45.
 

Detailed Description

Definition at line 39 of file SeedingTool.h.

Member Typedef Documentation

◆ external_type

using ActsTrk::SeedingTool::external_type = 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 44 of file SeedingTool.h.

◆ seed_type

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

Definition at line 43 of file SeedingTool.h.

◆ value_type

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

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

21  : base_class(type, name, parent)
22  {}

◆ ~SeedingTool()

virtual ActsTrk::SeedingTool::~SeedingTool ( )
virtualdefault

Member Function Documentation

◆ createSeeds() [1/3]

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

211  {
212  // Create Seeds
213  //TODO POSSIBLE OPTIMISATION come back here: see MR !52399 ( i.e. use static thread_local)
214  ATH_CHECK(createSeeds(spContainer.begin(),
215  spContainer.end(),
216  beamSpotPos,
217  bField,
218  seedContainer));
219 
220  return StatusCode::SUCCESS;
221  }

◆ createSeeds() [2/3]

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,
DataVector< Acts::Seed< external_type, 3ul > > &  seeds 
) const
protected

◆ createSeeds() [3/3]

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,
DataVector< Acts::Seed< typename SeedingTool::external_type, 3ul > > &  seedContainer 
) const

Definition at line 225 of file SeedingTool.cxx.

230  {
231  static_assert(std::is_same<typename external_spacepoint< external_iterator_t >::type, const value_type&>::value,
232  "Inconsistent type");
233 
234  if (spBegin == spEnd)
235  return StatusCode::SUCCESS;
236 
237  std::vector< seed_type > seeds;
238 
239  // Space Point Grid Options
240  Acts::CylindricalSpacePointGridOptions gridOpts;
241  gridOpts.bFieldInZ = bField[2];
242  gridOpts = gridOpts.toInternalUnits();
243 
244  // Seed Finder Options
245  Acts::SeedFinderOptions finderOpts;
246  finderOpts.beamPos = Acts::Vector2(beamSpotPos[Amg::x],
247  beamSpotPos[Amg::y]);
248  finderOpts.bFieldInZ = bField[2];
249  finderOpts = finderOpts.toInternalUnits().calculateDerivedQuantities(m_finderCfg);
250 
251 
252 
253 
254  Acts::CylindricalSpacePointGrid< value_type > grid =
255  Acts::CylindricalSpacePointGridCreator::createGrid< value_type >(m_gridCfg, gridOpts, logger());
256 
257  Acts::CylindricalSpacePointGridCreator::fillGrid(m_finderCfg, finderOpts, grid,
258  spBegin, spEnd, logger());
259 
260  // Compute radius Range
261  // we rely on the fact the grid is storing the proxies
262  // with a sorting in the radius
263  float minRange = std::numeric_limits<float>::max();
264  float maxRange = std::numeric_limits<float>::lowest();
265  for (const auto& coll : grid) {
266  if (coll.empty()) {
267  continue;
268  }
269  const auto* firstEl = coll.front();
270  const auto* lastEl = coll.back();
271  minRange = std::min(firstEl->radius(), minRange);
272  maxRange = std::max(lastEl->radius(), maxRange);
273  }
274 
275  Acts::CylindricalBinnedGroup< value_type > spacePointsGrouping(std::move(grid), *m_bottomBinFinder,
277 
278  // variable middle SP radial region of interest
279  const Acts::Range1D<float> rMiddleSPRange(std::floor(minRange/2)*2 + m_finderCfg.deltaRMiddleMinSPRange,
280  std::floor(maxRange/2)*2 - m_finderCfg.deltaRMiddleMaxSPRange);
281 
282  //TODO POSSIBLE OPTIMISATION come back here: see MR !52399 ( i.e. use static thread_local)
283  typename decltype(m_finder)::SeedingState state;
284  state.spacePointMutableData.resize(std::distance(spBegin, spEnd));
285 
286  for (const auto [bottom, middle, top] : spacePointsGrouping) {
287  m_finder.createSeedsForGroup(finderOpts, state, spacePointsGrouping.grid(),
288  seeds, bottom, middle, top, rMiddleSPRange);
289  }
290 
292  // Selection function - temporary implementation
293  // need change from ACTS for final implementation
294  // To be used only on PPP
295  auto selectionFunction = [&state] (const seed_type& seed) -> bool
296  {
297  float seed_quality = seed.seedQuality();
298  float bottom_quality = state.spacePointMutableData.quality(seed.sp()[0]->index());
299  float middle_quality = state.spacePointMutableData.quality(seed.sp()[1]->index());
300  float top_quality = state.spacePointMutableData.quality(seed.sp()[2]->index());
301 
302  if (bottom_quality > seed_quality and
303  middle_quality > seed_quality and
304  top_quality > seed_quality) {
305  return false;
306  }
307 
308  return true;
309  };
310 
311  // Select the seeds
312  std::size_t acceptedSeeds = 0;
313  for (std::size_t i(0); i<seeds.size(); ++i) {
314  const auto& seed = seeds[i];
315  if (not selectionFunction(seed)) {
316  continue;
317  }
318  // move passing seeds at the beginning of the vector/collection
319  // no need to swap them both. The seed currently at acceptedSeeds
320  // didn't make it (if i != acceptedSeeds)
321  if (acceptedSeeds != i)
322  seeds[acceptedSeeds] = std::move(seeds[i]);
323  ++acceptedSeeds;
324  }
325  // remove seeds that didn't make it
326  // they are all at the end of the collection
327  seeds.erase(seeds.begin() + acceptedSeeds, seeds.end());
328  }
329 
330 
331  // Store seeds
332  seedContainer.reserve(seeds.size());
333  for(const auto& seed: seeds) {
334  const auto [bottom, middle, top] = seed.sp();
335 
336  std::unique_ptr< ActsTrk::Seed > toAdd =
337  std::make_unique< ActsTrk::Seed >(bottom->externalSpacePoint(),
338  middle->externalSpacePoint(),
339  top->externalSpacePoint());
340  toAdd->setVertexZ(seed.z());
341  toAdd->setQuality(seed.seedQuality());
342  seedContainer.push_back(std::move(toAdd));
343  }
344 
345  return StatusCode::SUCCESS;
346  }

◆ initialize()

StatusCode ActsTrk::SeedingTool::initialize ( )
overridevirtual

Definition at line 24 of file SeedingTool.cxx.

24  {
25  ATH_MSG_DEBUG("Initializing " << name() << "...");
26 
27  ATH_MSG_DEBUG("Properties Summary:");
33 
34  ATH_MSG_DEBUG(" * Used by SpacePointGridConfig");
35  ATH_MSG_DEBUG(" " << m_minPt);
37  ATH_MSG_DEBUG(" " << m_impactMax);
38  ATH_MSG_DEBUG(" " << m_zMin);
39  ATH_MSG_DEBUG(" " << m_zMax);
42  ATH_MSG_DEBUG(" " << m_zBinEdges);
43  ATH_MSG_DEBUG(" " << m_rBinEdges);
44  ATH_MSG_DEBUG(" " << m_deltaRMax);
45  ATH_MSG_DEBUG(" " << m_gridRMax);
47 
48  ATH_MSG_DEBUG(" * Used by SeedFinderConfig:");
49  ATH_MSG_DEBUG(" " << m_minPt);
51  ATH_MSG_DEBUG(" " << m_impactMax);
52  ATH_MSG_DEBUG(" " << m_zMin);
53  ATH_MSG_DEBUG(" " << m_zMax);
54  ATH_MSG_DEBUG(" " << m_zBinEdges);
55  ATH_MSG_DEBUG(" " << m_rMax);
56  ATH_MSG_DEBUG(" " << m_deltaRMin);
57  ATH_MSG_DEBUG(" " << m_deltaRMax);
62  ATH_MSG_DEBUG(" " << m_deltaZMax);
76  } else if ( not m_rRangeMiddleSP.empty() )
79  if ( m_seedConfirmation ) {
96  }
99  ATH_MSG_DEBUG(" " << m_phiMin);
100  ATH_MSG_DEBUG(" " << m_phiMax);
101  ATH_MSG_DEBUG(" " << m_rMin);
102  ATH_MSG_DEBUG(" " << m_zAlign);
103  ATH_MSG_DEBUG(" " << m_rAlign);
104  ATH_MSG_DEBUG(" " << m_sigmaError);
105 
106  ATH_MSG_DEBUG(" * Used by SeedFilterConfig:");
107  ATH_MSG_DEBUG(" " << m_deltaRMin);
130  }
137 
138  // Make the logger And Propagate to ACTS routines
139  m_logger = makeActsAthenaLogger(this, "Acts");
140 
141  if (m_zBinEdges.size() - 1 !=
142  m_zBinNeighborsTop.size() and
143  not m_zBinNeighborsTop.empty()) {
144  ATH_MSG_ERROR("Inconsistent config zBinNeighborsTop");
145  return StatusCode::FAILURE;
146  }
147 
148  if (m_zBinEdges.size() - 1 !=
149  m_zBinNeighborsBottom.size() and
150  not m_zBinNeighborsBottom.empty()) {
151  ATH_MSG_ERROR("Inconsistent config zBinNeighborsBottom");
152  return StatusCode::FAILURE;
153  }
154 
155  if (m_rBinEdges.size() - 1 !=
156  m_rBinNeighborsTop.size() and
157  not m_rBinNeighborsTop.empty()) {
158  ATH_MSG_ERROR("Inconsistent config rBinNeighborsTop");
159  return StatusCode::FAILURE;
160  }
161 
162  if (m_rBinEdges.size() - 1 !=
163  m_rBinNeighborsBottom.size() and
164  not m_rBinNeighborsBottom.empty()) {
165  ATH_MSG_ERROR("Inconsistent config rBinNeighborsBottom");
166  return StatusCode::FAILURE;
167  }
168 
169  if (m_zBinsCustomLooping.size() != 0) {
170  // zBinsCustomLooping can contain a number of elements <= to the total number
171  // of bin in zBinEdges
172  for (std::size_t i : m_zBinsCustomLooping) {
173  if (i >= m_zBinEdges.size()) {
174  ATH_MSG_ERROR("Inconsistent config zBinsCustomLooping contains bins that are not in zBinEdges");
175  return StatusCode::FAILURE;
176  }
177  }
178  }
179 
180  if (m_rBinsCustomLooping.size() != 0) {
181  for (std::size_t i : m_rBinsCustomLooping) {
182  if (i >= m_rBinEdges.size()) {
183  ATH_MSG_ERROR("Inconsistent config rBinsCustomLooping contains bins that are not in rBinEdges");
184  return StatusCode::FAILURE;
185  }
186  }
187  }
188 
190 
191  m_bottomBinFinder = std::make_unique< Acts::GridBinFinder< 3ul > >(m_numPhiNeighbors.value(),
192  m_zBinNeighborsBottom.value(),
193  m_rBinNeighborsBottom.value());
194  m_topBinFinder = std::make_unique< Acts::GridBinFinder< 3ul > >(m_numPhiNeighbors.value(),
195  m_zBinNeighborsTop.value(),
196  m_rBinNeighborsTop.value());
197 
198  m_navigation[0ul] = {};
199  m_navigation[1ul] = m_finderCfg.zBinsCustomLooping;
201 
202  return StatusCode::SUCCESS;
203  }

◆ itkFastDoubletCut()

static bool ActsTrk::SeedingTool::itkFastDoubletCut ( float  bottomRadius,
float  cotTheta 
)
inlinestaticprivate

Definition at line 304 of file SeedingTool.h.

304  {
305  //float fastTrackingRMin = m_ExpCutrMin;
306  float fastTrackingCotThetaMax = 1.5;
307 
308  //if (bottomRadius < fastTrackingRMin and
309  if (bottomRadius < m_ExpCutrMin and
310  (cotTheta > fastTrackingCotThetaMax or
311  cotTheta < -fastTrackingCotThetaMax)) {
312  return false;
313  }
314  return true;
315  }

◆ itkFastTrackingSPselect()

static bool ActsTrk::SeedingTool::itkFastTrackingSPselect ( const value_type sp)
inlinestaticprivate

Remove space points beyond eta=4 if their z is larger than the max seed z0 (150.)

Definition at line 286 of file SeedingTool.h.

286  {
287  // At small r we remove points beyond |z| > 200.
288  float r = sp.radius();
289  float zabs = std::abs(sp.z());
290 
291  if (zabs > 200. && r < m_ExpCutrMin) {
292  return false;
293  }
294 
297  float cotTheta = 27.2899; // corresponds to eta=4
298  if ((zabs - 150.) > cotTheta * r) {
299  return false;
300  }
301  return true;
302  }

◆ logger()

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

Private access to the logger.

Definition at line 280 of file SeedingTool.h.

280 { return *m_logger; }

◆ prepareConfiguration()

StatusCode ActsTrk::SeedingTool::prepareConfiguration ( )
protected

Definition at line 349 of file SeedingTool.cxx.

349  {
350  assert(m_logger != nullptr);
351 
352  // Prepare the Acts::SeedFinderConfig object
353  // This is done only once, during initialization using the
354  // parameters set in the JO
355 
356  // Configuration for Acts::SeedFinder
357  m_finderCfg.minPt = m_minPt;
358  m_finderCfg.cotThetaMax = m_cotThetaMax;
359  m_finderCfg.impactMax = m_impactMax;
360  m_finderCfg.zMin = m_zMin;
361  m_finderCfg.zMax = m_zMax;
362  m_finderCfg.zBinEdges = m_zBinEdges;
363  m_finderCfg.rMax = m_rMax;
364  m_finderCfg.binSizeR = m_binSizeR;
365  m_finderCfg.deltaRMin = m_deltaRMin;
366  m_finderCfg.deltaRMax = m_deltaRMax;
367  m_finderCfg.deltaRMinTopSP = m_deltaRMinTopSP;
368  m_finderCfg.deltaRMaxTopSP = m_deltaRMaxTopSP;
369  m_finderCfg.deltaRMinBottomSP = m_deltaRMinBottomSP;
370  m_finderCfg.deltaRMaxBottomSP = m_deltaRMaxBottomSP;
371  m_finderCfg.deltaZMax = m_deltaZMax;
372  m_finderCfg.collisionRegionMin = m_collisionRegionMin;
373  m_finderCfg.collisionRegionMax = m_collisionRegionMax;
374  m_finderCfg.sigmaScattering = m_sigmaScattering;
375  m_finderCfg.maxPtScattering = m_maxPtScattering;
376  m_finderCfg.radLengthPerSeed = m_radLengthPerSeed;
377  m_finderCfg.maxSeedsPerSpM = m_maxSeedsPerSpM;
378  m_finderCfg.interactionPointCut = m_interactionPointCut;
379  m_finderCfg.zBinsCustomLooping = m_zBinsCustomLooping;
380  m_finderCfg.useVariableMiddleSPRange = m_useVariableMiddleSPRange;
381  m_finderCfg.deltaRMiddleMinSPRange = m_deltaRMiddleMinSPRange;
382  m_finderCfg.deltaRMiddleMaxSPRange = m_deltaRMiddleMaxSPRange;
383  m_finderCfg.seedConfirmation = m_seedConfirmation;
384  m_finderCfg.centralSeedConfirmationRange.zMinSeedConf = m_seedConfCentralZMin;
385  m_finderCfg.centralSeedConfirmationRange.zMaxSeedConf = m_seedConfCentralZMax;
386  m_finderCfg.centralSeedConfirmationRange.rMaxSeedConf = m_seedConfCentralRMax;
387  m_finderCfg.centralSeedConfirmationRange.nTopForLargeR = m_seedConfCentralNTopLargeR;
388  m_finderCfg.centralSeedConfirmationRange.nTopForSmallR = m_seedConfCentralNTopSmallR;
389  m_finderCfg.centralSeedConfirmationRange.seedConfMinBottomRadius = m_seedConfCentralMinBottomRadius;
390  m_finderCfg.centralSeedConfirmationRange.seedConfMaxZOrigin = m_seedConfCentralMaxZOrigin;
391  m_finderCfg.centralSeedConfirmationRange.minImpactSeedConf = m_seedConfCentralMinImpact;
392  m_finderCfg.forwardSeedConfirmationRange.zMinSeedConf = m_seedConfForwardZMin;
393  m_finderCfg.forwardSeedConfirmationRange.zMaxSeedConf = m_seedConfForwardZMax;
394  m_finderCfg.forwardSeedConfirmationRange.rMaxSeedConf = m_seedConfForwardRMax;
395  m_finderCfg.forwardSeedConfirmationRange.nTopForLargeR = m_seedConfForwardNTopLargeR;
396  m_finderCfg.forwardSeedConfirmationRange.nTopForSmallR = m_seedConfForwardNTopSmallR;
397  m_finderCfg.forwardSeedConfirmationRange.seedConfMinBottomRadius = m_seedConfForwardMinBottomRadius;
398  m_finderCfg.forwardSeedConfirmationRange.seedConfMaxZOrigin = m_seedConfForwardMaxZOrigin;
399  m_finderCfg.forwardSeedConfirmationRange.minImpactSeedConf = m_seedConfForwardMinImpact;
400  m_finderCfg.useDetailedDoubleMeasurementInfo = m_useDetailedDoubleMeasurementInfo;
401  m_finderCfg.toleranceParam = m_toleranceParam;
402  m_finderCfg.phiMin = m_phiMin;
403  m_finderCfg.phiMax = m_phiMax;
404  m_finderCfg.rMin = m_rMin;
405  m_finderCfg.zAlign = m_zAlign;
406  m_finderCfg.rAlign = m_rAlign;
407  m_finderCfg.sigmaError = m_sigmaError;
408 
409  // Fast tracking
410  // manually convert the two types
411  for (const auto& vec : m_rRangeMiddleSP) {
412  std::vector<float> convertedVec;
413 
414  for (const auto& val : vec) {
415  convertedVec.push_back(static_cast<float>(val));
416  }
417 
418  m_finderCfg.rRangeMiddleSP.push_back(convertedVec);
419  }
420 
421  // define cuts used for fast tracking configuration
422  if (m_useExperimentCuts) {
423 
424  // This function will be applied to select space points during grid filling
425  m_finderCfg.spacePointSelector
426  .connect<itkFastTrackingSPselect>();
427 
428  m_finderCfg.experimentCuts
429  .connect<itkFastDoubletCut>();
430 
431  }
432 
433  // Configuration for Acts::SeedFilter (used by FinderCfg)
434  Acts::SeedFilterConfig filterCfg;
435  filterCfg.deltaRMin = m_deltaRMin;
436  filterCfg.maxSeedsPerSpM = m_maxSeedsPerSpM;
437  filterCfg.useDeltaRorTopRadius = m_useDeltaRorTopRadius;
438  filterCfg.seedConfirmation = m_seedConfirmationInFilter;
439  filterCfg.maxSeedsPerSpMConf = m_maxSeedsPerSpMConf;
440  filterCfg.maxQualitySeedsPerSpMConf = m_maxQualitySeedsPerSpMConf;
441  filterCfg.centralSeedConfirmationRange = m_finderCfg.centralSeedConfirmationRange;
442  filterCfg.forwardSeedConfirmationRange = m_finderCfg.forwardSeedConfirmationRange;
443  filterCfg.impactWeightFactor = m_impactWeightFactor;
444  filterCfg.zOriginWeightFactor = m_zOriginWeightFactor;
445  filterCfg.compatSeedWeight = m_compatSeedWeight;
446  filterCfg.compatSeedLimit = m_compatSeedLimit;
447  filterCfg.seedWeightIncrement = m_seedWeightIncrement;
448  filterCfg.numSeedIncrement = m_numSeedIncrement;
449  filterCfg.deltaInvHelixDiameter = m_deltaInvHelixDiameter;
450  m_finderCfg.seedFilter = std::make_unique<Acts::SeedFilter< value_type > >(filterCfg.toInternalUnits(), logger().cloneWithSuffix("Filter"));
451 
452  m_finderCfg = m_finderCfg.toInternalUnits().calculateDerivedQuantities();
453 
454  // Grid Configuration
455  m_gridCfg.minPt = m_minPt;
456  m_gridCfg.cotThetaMax = m_cotThetaMax;
457  m_gridCfg.impactMax = m_impactMax;
458  m_gridCfg.zMin = m_zMin;
459  m_gridCfg.zMax = m_zMax;
460  m_gridCfg.phiMin = m_gridPhiMin;
461  m_gridCfg.phiMax = m_gridPhiMax;
462  m_gridCfg.zBinEdges = m_zBinEdges;
463  m_gridCfg.rBinEdges = m_rBinEdges;
464  m_gridCfg.deltaRMax = m_deltaRMax;
465  m_gridCfg.rMax = m_gridRMax;
466  m_gridCfg.phiBinDeflectionCoverage = m_phiBinDeflectionCoverage;
467  m_gridCfg.maxPhiBins = m_maxPhiBins;
468  m_gridCfg = m_gridCfg.toInternalUnits();
469 
470  // Seed Finder
471  m_finder = {m_finderCfg, logger().cloneWithSuffix("Finder")};
472 
473  return StatusCode::SUCCESS;
474  }

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

◆ m_bottomBinFinder

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

Definition at line 274 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 145 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 143 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 238 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 236 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 101 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 252 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 107 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 139 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 135 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 168 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 166 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 131 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 137 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 133 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 141 of file SeedingTool.h.

◆ m_ExpCutrMin

constexpr float ActsTrk::SeedingTool::m_ExpCutrMin = 45.
staticconstexprprivate

Definition at line 284 of file SeedingTool.h.

◆ m_finder

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

Definition at line 90 of file SeedingTool.h.

◆ m_finderCfg

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

Definition at line 91 of file SeedingTool.h.

◆ m_gridCfg

Acts::CylindricalSpacePointGridConfig ActsTrk::SeedingTool::m_gridCfg
protected

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

◆ 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 118 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 116 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 109 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 233 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 155 of file SeedingTool.h.

◆ m_logger

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

logging instance

Definition at line 282 of file SeedingTool.h.

◆ m_maxPhiBins

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

Definition at line 124 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 149 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 248 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 153 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 246 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 99 of file SeedingTool.h.

◆ m_navigation

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

Definition at line 277 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 268 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 242 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 122 of file SeedingTool.h.

◆ m_phiMax

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

Definition at line 226 of file SeedingTool.h.

◆ m_phiMin

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

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

◆ m_rAlign

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

Definition at line 229 of file SeedingTool.h.

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

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

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

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

◆ m_rMin

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

Definition at line 227 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, 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 163 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 190 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 187 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 193 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 181 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 184 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 178 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 175 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 172 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 214 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 211 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 217 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 205 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 208 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 202 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 199 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 196 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 170 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 244 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 95 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 240 of file SeedingTool.h.

◆ m_sigmaError

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

Definition at line 230 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 147 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 223 of file SeedingTool.h.

◆ m_topBinFinder

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

Definition at line 275 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 250 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 220 of file SeedingTool.h.

◆ m_useExperimentCuts

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

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

◆ m_zAlign

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

Definition at line 228 of file SeedingTool.h.

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

◆ 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 261 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}, {-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 257 of file SeedingTool.h.

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

◆ m_zOriginWeightFactor

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

Definition at line 235 of file SeedingTool.h.


The documentation for this class was generated from the following files:
DataVector::reserve
void reserve(size_type n)
Attempt to preallocate enough memory for a specified number of elements.
ActsTrk::SeedingTool::m_deltaRMaxTopSP
Gaudi::Property< float > m_deltaRMaxTopSP
Definition: SeedingTool.h:135
ActsTrk::SeedingTool::m_gridPhiMax
Gaudi::Property< float > m_gridPhiMax
Definition: SeedingTool.h:120
beamspotman.r
def r
Definition: beamspotman.py:676
ActsTrk::SeedingTool::m_compatSeedLimit
Gaudi::Property< std::size_t > m_compatSeedLimit
Definition: SeedingTool.h:238
ActsTrk::SeedingTool::m_seedConfCentralMaxZOrigin
Gaudi::Property< float > m_seedConfCentralMaxZOrigin
Definition: SeedingTool.h:190
ActsTrk::SeedingTool::m_finderCfg
Acts::SeedFinderConfig< value_type > m_finderCfg
Definition: SeedingTool.h:91
ActsTrk::SeedingTool::m_seedConfCentralMinBottomRadius
Gaudi::Property< float > m_seedConfCentralMinBottomRadius
Definition: SeedingTool.h:187
ActsTrk::SeedingTool::m_compatSeedWeight
Gaudi::Property< float > m_compatSeedWeight
Definition: SeedingTool.h:236
ActsTrk::SeedingTool::m_sigmaScattering
Gaudi::Property< float > m_sigmaScattering
Definition: SeedingTool.h:147
ActsTrk::SeedingTool::m_maxSeedsPerSpM
Gaudi::Property< int > m_maxSeedsPerSpM
Definition: SeedingTool.h:153
ActsTrk::SeedingTool::m_seedConfForwardMaxZOrigin
Gaudi::Property< float > m_seedConfForwardMaxZOrigin
Definition: SeedingTool.h:214
ActsTrk::SeedingTool::m_bottomBinFinder
std::unique_ptr< Acts::GridBinFinder< 3ul > > m_bottomBinFinder
Definition: SeedingTool.h:274
ActsTrk::SeedingTool::m_maxQualitySeedsPerSpMConf
Gaudi::Property< std::size_t > m_maxQualitySeedsPerSpMConf
Definition: SeedingTool.h:248
ActsTrk::SeedingTool::m_seedConfirmation
Gaudi::Property< bool > m_seedConfirmation
Definition: SeedingTool.h:170
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
ActsTrk::SeedingTool::m_phiBinDeflectionCoverage
Gaudi::Property< int > m_phiBinDeflectionCoverage
Definition: SeedingTool.h:122
ActsTrk::SeedingTool::m_phiMin
Gaudi::Property< float > m_phiMin
Definition: SeedingTool.h:225
ActsTrk::SeedingTool::m_deltaRMinTopSP
Gaudi::Property< float > m_deltaRMinTopSP
Definition: SeedingTool.h:133
ActsTrk::SeedingTool::m_deltaRMaxBottomSP
Gaudi::Property< float > m_deltaRMaxBottomSP
Definition: SeedingTool.h:139
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
ActsTrk::SeedingTool::itkFastTrackingSPselect
static bool itkFastTrackingSPselect(const value_type &sp)
Definition: SeedingTool.h:286
ActsTrk::SeedingTool::m_useVariableMiddleSPRange
Gaudi::Property< bool > m_useVariableMiddleSPRange
Definition: SeedingTool.h:161
python.SystemOfUnits.MeV
int MeV
Definition: SystemOfUnits.py:154
Amg::y
@ y
Definition: GeoPrimitives.h:35
ActsTrk::SeedingTool::external_spacepoint::type
typename std::conditional< std::is_pointer< typename spacepoint_iterator_t::value_type >::value, typename std::remove_const< typename std::remove_pointer< typename spacepoint_iterator_t::value_type >::type >::type, typename std::remove_const< typename spacepoint_iterator_t::value_type >::type >::type type
Definition: SeedingTool.h:73
ActsTrk::SeedingTool::m_rMin
Gaudi::Property< float > m_rMin
Definition: SeedingTool.h:227
ActsTrk::SeedingTool::m_rAlign
Gaudi::Property< float > m_rAlign
Definition: SeedingTool.h:229
ActsTrk::SeedingTool::m_seedConfCentralNTopLargeR
Gaudi::Property< size_t > m_seedConfCentralNTopLargeR
Definition: SeedingTool.h:181
athena.value
value
Definition: athena.py:124
ActsTrk::SeedingTool::m_deltaRMax
Gaudi::Property< float > m_deltaRMax
Definition: SeedingTool.h:107
ActsTrk::SeedingTool::m_deltaRMinBottomSP
Gaudi::Property< float > m_deltaRMinBottomSP
Definition: SeedingTool.h:137
vec
std::vector< size_t > vec
Definition: CombinationsGeneratorTest.cxx:12
ActsTrk::SeedingTool::createSeeds
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
Definition: SeedingTool.cxx:206
ActsTrk::SeedingTool::m_finder
Acts::SeedFinder< value_type, Acts::CylindricalSpacePointGrid< value_type > > m_finder
Definition: SeedingTool.h:90
ActsTrk::SeedingTool::m_useExperimentCuts
Gaudi::Property< bool > m_useExperimentCuts
Definition: SeedingTool.h:271
ActsTrk::SeedingTool::m_rMax
Gaudi::Property< float > m_rMax
Definition: SeedingTool.h:127
ActsTrk::SeedingTool::m_zAlign
Gaudi::Property< float > m_zAlign
Definition: SeedingTool.h:228
ActsTrk::SeedingTool::m_seedConfCentralZMax
Gaudi::Property< float > m_seedConfCentralZMax
Definition: SeedingTool.h:175
ActsTrk::SeedingTool::m_zBinNeighborsTop
Gaudi::Property< std::vector< std::pair< int, int > > > m_zBinNeighborsTop
Definition: SeedingTool.h:257
makeActsAthenaLogger
std::unique_ptr< const Acts::Logger > makeActsAthenaLogger(IMessageSvc *svc, const std::string &name, int level, std::optional< std::string > parent_name)
Definition: Tracking/Acts/ActsInterop/src/Logger.cxx:64
ActsTrk::SeedingTool::m_impactMax
Gaudi::Property< float > m_impactMax
Definition: SeedingTool.h:109
ActsTrk::SeedingTool::m_impactWeightFactor
Gaudi::Property< float > m_impactWeightFactor
Definition: SeedingTool.h:233
ActsTrk::SeedingTool::m_seedQualitySelection
Gaudi::Property< bool > m_seedQualitySelection
Definition: SeedingTool.h:95
ActsTrk::SeedingTool::m_zBinEdges
Gaudi::Property< std::vector< float > > m_zBinEdges
Definition: SeedingTool.h:111
ActsTrk::SeedingTool::m_zMax
Gaudi::Property< float > m_zMax
Definition: SeedingTool.h:105
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ActsTrk::SeedingTool::m_seedConfForwardZMax
Gaudi::Property< float > m_seedConfForwardZMax
Definition: SeedingTool.h:199
lumiFormat.i
int i
Definition: lumiFormat.py:85
ActsTrk::SeedingTool::m_minPt
Gaudi::Property< float > m_minPt
Definition: SeedingTool.h:99
ActsTrk::SeedingTool::m_deltaZMax
Gaudi::Property< float > m_deltaZMax
Definition: SeedingTool.h:141
ActsTrk::SeedingTool::m_maxSeedsPerSpMConf
Gaudi::Property< std::size_t > m_maxSeedsPerSpMConf
Definition: SeedingTool.h:246
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Amg::x
@ x
Definition: GeoPrimitives.h:34
ActsTrk::SeedingTool::m_binSizeR
Gaudi::Property< float > m_binSizeR
Definition: SeedingTool.h:129
ActsTrk::SeedingTool::m_topBinFinder
std::unique_ptr< Acts::GridBinFinder< 3ul > > m_topBinFinder
Definition: SeedingTool.h:275
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsTrk::SeedingTool::m_seedConfForwardRMax
Gaudi::Property< float > m_seedConfForwardRMax
Definition: SeedingTool.h:202
detail::ul
unsigned long ul
Definition: PrimitiveHelpers.h:46
ActsTrk::SeedingTool::m_seedConfCentralMinImpact
Gaudi::Property< float > m_seedConfCentralMinImpact
Definition: SeedingTool.h:193
ActsTrk::SeedingTool::m_seedConfForwardMinImpact
Gaudi::Property< float > m_seedConfForwardMinImpact
Definition: SeedingTool.h:217
ActsTrk::SeedingTool::m_rBinNeighborsTop
Gaudi::Property< std::vector< std::pair< int, int > > > m_rBinNeighborsTop
Definition: SeedingTool.h:264
ActsTrk::SeedingTool::m_gridRMax
Gaudi::Property< float > m_gridRMax
Definition: SeedingTool.h:116
ActsTrk::SeedingTool::m_radLengthPerSeed
Gaudi::Property< float > m_radLengthPerSeed
Definition: SeedingTool.h:151
DeMoUpdate.toAdd
bool toAdd
Definition: DeMoUpdate.py:1304
ActsTrk::SeedingTool::m_deltaInvHelixDiameter
Gaudi::Property< float > m_deltaInvHelixDiameter
Definition: SeedingTool.h:252
ActsTrk::SeedingTool::logger
const Acts::Logger & logger() const
Private access to the logger.
Definition: SeedingTool.h:280
ActsTrk::SeedingTool::m_seedConfCentralRMax
Gaudi::Property< float > m_seedConfCentralRMax
Definition: SeedingTool.h:178
ActsTrk::SeedingTool::m_collisionRegionMax
Gaudi::Property< float > m_collisionRegionMax
Definition: SeedingTool.h:145
ActsTrk::SeedingTool::m_rBinNeighborsBottom
Gaudi::Property< std::vector< std::pair< int, int > > > m_rBinNeighborsBottom
Definition: SeedingTool.h:266
ActsTrk::SeedingTool::m_rBinsCustomLooping
Gaudi::Property< std::vector< std::size_t > > m_rBinsCustomLooping
Definition: SeedingTool.h:159
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
ActsTrk::SeedingTool::m_deltaRMiddleMaxSPRange
Gaudi::Property< float > m_deltaRMiddleMaxSPRange
Definition: SeedingTool.h:168
ActsTrk::SeedingTool::m_deltaRMiddleMinSPRange
Gaudi::Property< float > m_deltaRMiddleMinSPRange
Definition: SeedingTool.h:166
ActsTrk::SeedingTool::m_navigation
std::array< std::vector< std::size_t >, 3ul > m_navigation
Definition: SeedingTool.h:277
ActsTrk::SeedingTool::m_seedConfCentralZMin
Gaudi::Property< float > m_seedConfCentralZMin
Definition: SeedingTool.h:172
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
ActsTrk::SeedingTool::itkFastDoubletCut
static bool itkFastDoubletCut(float bottomRadius, float cotTheta)
Definition: SeedingTool.h:304
ActsTrk::SeedingTool::m_zBinsCustomLooping
Gaudi::Property< std::vector< size_t > > m_zBinsCustomLooping
Definition: SeedingTool.h:157
ActsTrk::SeedingTool::prepareConfiguration
StatusCode prepareConfiguration()
Definition: SeedingTool.cxx:349
ActsTrk::SeedingTool::m_phiMax
Gaudi::Property< float > m_phiMax
Definition: SeedingTool.h:226
ActsTrk::SeedingTool::m_collisionRegionMin
Gaudi::Property< float > m_collisionRegionMin
Definition: SeedingTool.h:143
ActsTrk::SeedingTool::m_seedConfCentralNTopSmallR
Gaudi::Property< size_t > m_seedConfCentralNTopSmallR
Definition: SeedingTool.h:184
ActsTrk::SeedingTool::m_cotThetaMax
Gaudi::Property< float > m_cotThetaMax
Definition: SeedingTool.h:101
ActsTrk::SeedingTool::m_maxPhiBins
Gaudi::Property< int > m_maxPhiBins
Definition: SeedingTool.h:124
python.SystemOfUnits.mm
int mm
Definition: SystemOfUnits.py:83
ActsTrk::SeedingTool::m_toleranceParam
Gaudi::Property< float > m_toleranceParam
Definition: SeedingTool.h:223
ActsTrk::SeedingTool::seed_type
Acts::Seed< value_type, 3ul > seed_type
Definition: SeedingTool.h:43
ActsTrk::SeedingTool::m_deltaRMin
Gaudi::Property< float > m_deltaRMin
Definition: SeedingTool.h:131
ActsTrk::SeedingTool::m_seedWeightIncrement
Gaudi::Property< float > m_seedWeightIncrement
Definition: SeedingTool.h:240
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
ActsTrk::SeedingTool::m_numPhiNeighbors
Gaudi::Property< int > m_numPhiNeighbors
Definition: SeedingTool.h:268
ActsTrk::SeedingTool::m_seedConfForwardNTopLargeR
Gaudi::Property< size_t > m_seedConfForwardNTopLargeR
Definition: SeedingTool.h:205
ActsTrk::SeedingTool::m_ExpCutrMin
static constexpr float m_ExpCutrMin
Definition: SeedingTool.h:284
ActsTrk::SeedingTool::m_seedConfForwardZMin
Gaudi::Property< float > m_seedConfForwardZMin
Definition: SeedingTool.h:196
TRT::Track::cotTheta
@ cotTheta
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:65
ActsTrk::SeedingTool::m_seedConfirmationInFilter
Gaudi::Property< bool > m_seedConfirmationInFilter
Definition: SeedingTool.h:244
ActsTrk::SeedingTool::m_rBinEdges
Gaudi::Property< std::vector< float > > m_rBinEdges
Definition: SeedingTool.h:114
ActsTrk::SeedingTool::m_interactionPointCut
Gaudi::Property< bool > m_interactionPointCut
Definition: SeedingTool.h:155
ActsTrk::SeedingTool::m_rRangeMiddleSP
Gaudi::Property< std::vector< std::vector< double > > > m_rRangeMiddleSP
Definition: SeedingTool.h:163
ActsTrk::SeedingTool::m_useDeltaRorTopRadius
Gaudi::Property< bool > m_useDeltaRorTopRadius
Definition: SeedingTool.h:250
top
@ top
Definition: TruthClasses.h:64
ActsTrk::SeedingTool::m_seedConfForwardNTopSmallR
Gaudi::Property< size_t > m_seedConfForwardNTopSmallR
Definition: SeedingTool.h:208
ActsTrk::SeedingTool::m_gridCfg
Acts::CylindricalSpacePointGridConfig m_gridCfg
Definition: SeedingTool.h:92
ActsTrk::SeedingTool::m_zOriginWeightFactor
Gaudi::Property< float > m_zOriginWeightFactor
Definition: SeedingTool.h:235
ActsTrk::SeedingTool::m_useDetailedDoubleMeasurementInfo
Gaudi::Property< bool > m_useDetailedDoubleMeasurementInfo
Definition: SeedingTool.h:220
ActsTrk::SeedingTool::m_zBinNeighborsBottom
Gaudi::Property< std::vector< std::pair< int, int > > > m_zBinNeighborsBottom
Definition: SeedingTool.h:261
value_type
Definition: EDM_MasterSearch.h:11
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
ActsTrk::SeedingTool::m_gridPhiMin
Gaudi::Property< float > m_gridPhiMin
Definition: SeedingTool.h:118
ActsTrk::SeedingTool::m_sigmaError
Gaudi::Property< float > m_sigmaError
Definition: SeedingTool.h:230
ActsTrk::SeedingTool::m_logger
std::unique_ptr< const Acts::Logger > m_logger
logging instance
Definition: SeedingTool.h:282
ActsTrk::SeedingTool::m_maxPtScattering
Gaudi::Property< float > m_maxPtScattering
Definition: SeedingTool.h:149
ActsTrk::SeedingTool::m_numSeedIncrement
Gaudi::Property< float > m_numSeedIncrement
Definition: SeedingTool.h:242
ActsTrk::SeedingTool::m_seedConfForwardMinBottomRadius
Gaudi::Property< float > m_seedConfForwardMinBottomRadius
Definition: SeedingTool.h:211
ActsTrk::SeedingTool::m_zMin
Gaudi::Property< float > m_zMin
Definition: SeedingTool.h:103