ActsTrk::GridTripletSeedingTool Class Reference

#include <GridTripletSeedingTool.h>

Inheritance diagram for ActsTrk::GridTripletSeedingTool:

Collaboration diagram for ActsTrk::GridTripletSeedingTool:

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

Protected Attributes
Gaudi::Property< bool >	m_seedQualitySelection
Gaudi::Property< float >	m_minPt
Gaudi::Property< float >	m_cotThetaMax
Gaudi::Property< float >	m_zMin
Gaudi::Property< float >	m_zMax
Gaudi::Property< float >	m_deltaRMax
Gaudi::Property< float >	m_impactMax
Gaudi::Property< std::vector< float > >	m_zBinEdges
Gaudi::Property< std::vector< float > >	m_rBinEdges
Gaudi::Property< float >	m_gridRMax
Gaudi::Property< float >	m_gridPhiMin
Gaudi::Property< float >	m_gridPhiMax
Gaudi::Property< int >	m_phiBinDeflectionCoverage
Gaudi::Property< int >	m_maxPhiBins
Gaudi::Property< float >	m_rMax
Gaudi::Property< float >	m_binSizeR
Gaudi::Property< float >	m_deltaRMin
Gaudi::Property< float >	m_deltaRMinTopSP
Gaudi::Property< float >	m_deltaRMaxTopSP
Gaudi::Property< float >	m_deltaRMinBottomSP
Gaudi::Property< float >	m_deltaRMaxBottomSP
Gaudi::Property< float >	m_deltaZMax
Gaudi::Property< float >	m_collisionRegionMin
Gaudi::Property< float >	m_collisionRegionMax
Gaudi::Property< bool >	m_useHVCollisionRegion
Gaudi::Property< float >	m_hvCollisionRegionTolerance
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_maxStripDeltaCotTheta
Gaudi::Property< float >	m_phiMin
Gaudi::Property< float >	m_phiMax
Gaudi::Property< float >	m_rMin {this, "rMin", 0 * Acts::UnitConstants::mm, ""}
Gaudi::Property< float >	m_zAlign
Gaudi::Property< float >	m_rAlign
Gaudi::Property< float >	m_sigmaError {this, "sigmaError", 5, ""}
Gaudi::Property< float >	m_impactWeightFactor
Gaudi::Property< float >	m_zOriginWeightFactor {this, "zOriginWeightFactor", 1.}
Gaudi::Property< float >	m_compatSeedWeight
Gaudi::Property< std::size_t >	m_compatSeedLimit
Gaudi::Property< float >	m_seedWeightIncrement
Gaudi::Property< float >	m_numSeedIncrement
Gaudi::Property< bool >	m_seedConfirmationInFilter
Gaudi::Property< std::size_t >	m_maxSeedsPerSpMConf
Gaudi::Property< std::size_t >	m_maxQualitySeedsPerSpMConf
Gaudi::Property< bool >	m_useDeltaRorTopRadius
Gaudi::Property< float >	m_deltaInvHelixDiameter
Gaudi::Property< float >	m_absDeltaEtaWeightFactor
Gaudi::Property< float >	m_absDeltaEtaMinImpact
Gaudi::Property< std::vector< std::pair< int, int > > >	m_zBinNeighborsTop
Gaudi::Property< std::vector< std::pair< int, int > > >	m_zBinNeighborsBottom
Gaudi::Property< std::vector< std::pair< int, int > > >	m_rBinNeighborsTop
Gaudi::Property< std::vector< std::pair< int, int > > >	m_rBinNeighborsBottom
Gaudi::Property< int >	m_numPhiNeighbors
Gaudi::Property< bool >	m_useExperimentCuts
Gaudi::Property< bool >	m_doubletDPhiCut
Gaudi::Property< float >	m_doubletDPhiD0Max
Gaudi::Property< float >	m_doubletDPhiCap
Gaudi::Property< float >	m_doubletDPhiConst
Gaudi::Property< float >	m_doubletDPhiSlope
Gaudi::Property< int >	m_stateVectorReserveSize
Gaudi::Property< float >	m_expCutrMin

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

Private Attributes
Acts::CylindricalSpacePointGrid2::Config	m_gridCfg
Acts::DoubletSeedFinder::Config	m_bottomDoubletFinderCfg
Acts::DoubletSeedFinder::Config	m_topDoubletFinderCfg
Acts::TripletSeedFinder::Config	m_tripletFinderCfg
Acts::BroadTripletSeedFilter::Config	m_filterCfg
std::optional< Acts::TripletSeeder >	m_finder
std::unique_ptr< const Acts::Logger >	m_logger
	logging instance
std::unique_ptr< const Acts::Logger >	m_loggerFilter
const PixelID *	m_pixelId {nullptr}
SG::ReadHandleKey< xAOD::VertexContainer >	m_inputHoughVtxKey {this, "inputHoughVtx", "", "input vertex container"}

Detailed Description

Definition at line 29 of file GridTripletSeedingTool.h.

Constructor & Destructor Documentation

GridTripletSeedingTool()

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

Definition at line 12 of file GridTripletSeedingTool.cxx.

    : base_class(type, name, parent) {}

Member Function Documentation

createSeeds()

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

override

Definition at line 438 of file GridTripletSeedingTool.cxx.

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

doubletSelectionFunction()

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

private

Definition at line 347 of file GridTripletSeedingTool.cxx.

                                  {
  if (m_doubletDPhiCut) {
    // per-pair azimuthal-swing bound: the hit azimuth of a track with impact
    // parameter d0 swings between two radii by asin(d0/rInner) -
    // asin(d0/rOuter) on top of the curvature rotation. The grid phi-bin
    // widening only knows the full radial span; this applies the exact
    // per-pair bound before the doublet enters the triplet stage.
    // NB: this container only fills the packed coordinate columns, so the
    // packed accessors xy()/zr() must be used here.
    const float rM = middle.zr()[1];
    const float rO = other.zr()[1];
    const float rInner = std::min(rM, rO);
    const float rOuter = std::max(rM, rO);
    const float d0 =
        m_doubletDPhiD0Max < 0.f ? m_impactMax.value() : m_doubletDPhiD0Max.value();
 
    const std::array<float, 2>& xyM = middle.xy();
    const std::array<float, 2>& xyO = other.xy();
    float dPhi = std::atan2(xyO[1], xyO[0]) - std::atan2(xyM[1], xyM[0]);
    if (dPhi > std::numbers::pi_v<float>) {
      dPhi -= 2.f * std::numbers::pi_v<float>;
    } else if (dPhi < -std::numbers::pi_v<float>) {
      dPhi += 2.f * std::numbers::pi_v<float>;
    }
 
    const float swing =
        std::asin(std::min(1.f, d0 / std::max(rInner, 1.f))) -
        std::asin(std::min(1.f, d0 / std::max(rOuter, 1.f)));
    const float bound = m_doubletDPhiConst +
                        m_doubletDPhiSlope * (rOuter - rInner) +
                        std::min(m_doubletDPhiCap.value(), swing);
 
    if (std::abs(dPhi) > bound) {
      return false;
    }
  }
 
  if (!m_useExperimentCuts) {
    return true;
  }
 
  // We remove some doublets that have the middle space point in some specific
  // areas This should eventually be moved inside ACTS and allow a veto
  // mechanism according to the user desire. As of now we cannot really do this
  // since we define a range of validity of the middle candidate, and if we want
  // to veto some sub-regions inside it, we need to do it here.
  if (std::abs(middle.zr()[0]) > 1500 and middle.zr()[1] > 100 and
      middle.zr()[1] < 150) {
    return false;
  }
 
  // We remove here some seeds, in case the bottom space point radius is
  // too small (i.e. < fastTrackingRMin)
 
  // This operation is done only within a specific eta window
  // Instead of eta we use the doublet cottheta
  static constexpr float cotThetaEta120 = 1.5095;
  static constexpr float cotThetaEta360 = 18.2855;
 
  float absCotTheta = std::abs(cotTheta);
  if (isBottomCandidate && other.zr()[1] < m_expCutrMin &&
      absCotTheta > cotThetaEta120 && absCotTheta < cotThetaEta360) {
    return false;
  }
 
  return true;
}

initialize()

StatusCode ActsTrk::GridTripletSeedingTool::initialize ( )

overridevirtual

Definition at line 17 of file GridTripletSeedingTool.cxx.

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

logger()

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

inlineprivate

Private access to the logger.

Definition at line 387 of file GridTripletSeedingTool.h.

{ return *m_logger; }

retrieveRadiusRangeForMiddle()

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

private

Definition at line 418 of file GridTripletSeedingTool.cxx.

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

spacePointSelectionFunction()

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

private

Definition at line 298 of file GridTripletSeedingTool.cxx.

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

Member Data Documentation

m_absDeltaEtaMinImpact

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

protected

Initial value:

{
      this, "absDeltaEtaMinImpact", 2. * Acts::UnitConstants::mm,
      "minimum impact parameter to apply abs(delta-eta) weight"}

Definition at line 292 of file GridTripletSeedingTool.h.

                                             {
      this, "absDeltaEtaMinImpact", 2. * Acts::UnitConstants::mm,
      "minimum impact parameter to apply abs(delta-eta) weight"};

m_absDeltaEtaWeightFactor

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

protected

Initial value:

{
      this, "absDeltaEtaWeightFactor", 0.,
      "weight factor for abs(delta-eta) penalty between seed direction and "
      "beamspot-to-PCA direction (0 = disabled, typical LRT value: 10)"}

Definition at line 288 of file GridTripletSeedingTool.h.

                                                {
      this, "absDeltaEtaWeightFactor", 0.,
      "weight factor for abs(delta-eta) penalty between seed direction and "
      "beamspot-to-PCA direction (0 = disabled, typical LRT value: 10)"};

m_binSizeR

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

protected

Initial value:

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

Definition at line 95 of file GridTripletSeedingTool.h.

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

m_bottomDoubletFinderCfg

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

private

Definition at line 373 of file GridTripletSeedingTool.h.

m_collisionRegionMax

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

protected

Initial value:

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

Definition at line 120 of file GridTripletSeedingTool.h.

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

m_collisionRegionMin

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

protected

Initial value:

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

Definition at line 117 of file GridTripletSeedingTool.h.

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

m_compatSeedLimit

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

protected

Initial value:

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

Definition at line 262 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_compatSeedWeight

protected

Initial value:

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

Definition at line 258 of file GridTripletSeedingTool.h.

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

m_cotThetaMax

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

protected

Initial value:

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

Definition at line 52 of file GridTripletSeedingTool.h.

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

m_deltaInvHelixDiameter

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

protected

Initial value:

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

Definition at line 284 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_deltaRMax

protected

Initial value:

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

Definition at line 58 of file GridTripletSeedingTool.h.

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

m_deltaRMaxBottomSP

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

protected

Initial value:

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

Definition at line 111 of file GridTripletSeedingTool.h.

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

m_deltaRMaxTopSP

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

protected

Initial value:

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

Definition at line 105 of file GridTripletSeedingTool.h.

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

m_deltaRMiddleMaxSPRange

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

protected

Initial value:

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

Definition at line 176 of file GridTripletSeedingTool.h.

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

m_deltaRMiddleMinSPRange

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

protected

Initial value:

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

Definition at line 174 of file GridTripletSeedingTool.h.

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

m_deltaRMin

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

protected

Initial value:

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

Definition at line 98 of file GridTripletSeedingTool.h.

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

m_deltaRMinBottomSP

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

protected

Initial value:

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

Definition at line 108 of file GridTripletSeedingTool.h.

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

m_deltaRMinTopSP

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

protected

Initial value:

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

Definition at line 102 of file GridTripletSeedingTool.h.

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

m_deltaZMax

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

protected

Initial value:

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

Definition at line 114 of file GridTripletSeedingTool.h.

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

m_doubletDPhiCap

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

protected

Initial value:

{this, "doubletDPhiCap", 10.,
      "cap on the displaced phi-swing term [rad]"}

Definition at line 357 of file GridTripletSeedingTool.h.

                                       {this, "doubletDPhiCap", 10.,
      "cap on the displaced phi-swing term [rad]"};

m_doubletDPhiConst

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

protected

Initial value:

{this, "doubletDPhiConst", 0.015,
      "constant term of the prompt doublet phi window [rad]"}

Definition at line 359 of file GridTripletSeedingTool.h.

                                         {this, "doubletDPhiConst", 0.015,
      "constant term of the prompt doublet phi window [rad]"};

m_doubletDPhiCut

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

protected

Initial value:

{this, "doubletDPhiCut", false,
      "apply the per-pair azimuthal-swing doublet cut"}

Definition at line 353 of file GridTripletSeedingTool.h.

                                      {this, "doubletDPhiCut", false,
      "apply the per-pair azimuthal-swing doublet cut"};

m_doubletDPhiD0Max

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

protected

Initial value:

{this, "doubletDPhiD0Max", -1.,
      "impact parameter bounding the doublet phi swing; negative uses impactMax"}

Definition at line 355 of file GridTripletSeedingTool.h.

                                         {this, "doubletDPhiD0Max", -1.,
      "impact parameter bounding the doublet phi swing; negative uses impactMax"};

m_doubletDPhiSlope

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

protected

Initial value:

{this, "doubletDPhiSlope", 2.0e-4,
      "curvature term of the prompt doublet phi window [rad/mm]"}

Definition at line 361 of file GridTripletSeedingTool.h.

                                         {this, "doubletDPhiSlope", 2.0e-4,
      "curvature term of the prompt doublet phi window [rad/mm]"};

m_expCutrMin

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

protected

Initial value:

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

Definition at line 368 of file GridTripletSeedingTool.h.

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

m_filterCfg

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

private

Definition at line 376 of file GridTripletSeedingTool.h.

m_finder

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

private

Definition at line 378 of file GridTripletSeedingTool.h.

m_gridCfg

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

private

Definition at line 372 of file GridTripletSeedingTool.h.

m_gridPhiMax

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

protected

Initial value:

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

Definition at line 82 of file GridTripletSeedingTool.h.

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

m_gridPhiMin

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

protected

Initial value:

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

Definition at line 79 of file GridTripletSeedingTool.h.

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

m_gridRMax

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

protected

Initial value:

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

Definition at line 76 of file GridTripletSeedingTool.h.

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

m_hvCollisionRegionTolerance

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

protected

Initial value:

{
      this, "hvCollisionRegionTolerance", 10. * Acts::UnitConstants::mm,
      "size of collision region when using Hough vertex"}

Definition at line 126 of file GridTripletSeedingTool.h.

                                                   {
      this, "hvCollisionRegionTolerance", 10. * Acts::UnitConstants::mm,
      "size of collision region when using Hough vertex"};  

m_impactMax

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

protected

Initial value:

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

Definition at line 62 of file GridTripletSeedingTool.h.

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

m_impactWeightFactor

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

protected

Initial value:

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

Definition at line 253 of file GridTripletSeedingTool.h.

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

m_inputHoughVtxKey

SG::ReadHandleKey<xAOD::VertexContainer> ActsTrk::GridTripletSeedingTool::m_inputHoughVtxKey {this, "inputHoughVtx", "", "input vertex container"}

private

Definition at line 399 of file GridTripletSeedingTool.h.

{this, "inputHoughVtx", "", "input vertex container"};

m_interactionPointCut

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

protected

Initial value:

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

Definition at line 144 of file GridTripletSeedingTool.h.

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

m_logger

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

private

logging instance

Definition at line 381 of file GridTripletSeedingTool.h.

m_loggerFilter

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

private

Definition at line 382 of file GridTripletSeedingTool.h.

m_maxPhiBins

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

protected

Initial value:

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

Definition at line 89 of file GridTripletSeedingTool.h.

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

m_maxPtScattering

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

protected

Initial value:

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

Definition at line 132 of file GridTripletSeedingTool.h.

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

m_maxQualitySeedsPerSpMConf

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

protected

Initial value:

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

Definition at line 277 of file GridTripletSeedingTool.h.

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

m_maxSeedsPerSpM

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

protected

Initial value:

{
      this, "maxSeedsPerSpM", 4,
      "In dense environments many seeds may be found per middle space point. "
      "Only seeds with the highest weight will be kept if this limit is "
      "reached."}

Definition at line 139 of file GridTripletSeedingTool.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."};

m_maxSeedsPerSpMConf

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

protected

Initial value:

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

Definition at line 274 of file GridTripletSeedingTool.h.

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

m_maxStripDeltaCotTheta

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

protected

Initial value:

{
      this, "maxStripDeltaCotTheta", 1e10f,
      "maximum allowed |cotTheta_bottom - cotTheta_top| pre-filter for strip "
      "triplets before expensive coordinate checks"}

Definition at line 236 of file GridTripletSeedingTool.h.

                                              {
      this, "maxStripDeltaCotTheta", 1e10f,
      "maximum allowed |cotTheta_bottom - cotTheta_top| pre-filter for strip "
      "triplets before expensive coordinate checks"};

m_minPt

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

protected

Initial value:

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

Definition at line 50 of file GridTripletSeedingTool.h.

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

m_numPhiNeighbors

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

protected

Initial value:

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

Definition at line 342 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_numSeedIncrement

protected

Initial value:

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

Definition at line 268 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_phiBinDeflectionCoverage

protected

Initial value:

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

Definition at line 85 of file GridTripletSeedingTool.h.

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

m_phiMax

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

protected

Initial value:

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

Definition at line 243 of file GridTripletSeedingTool.h.

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

m_phiMin

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

protected

Initial value:

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

Definition at line 241 of file GridTripletSeedingTool.h.

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

m_pixelId

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

private

Definition at line 384 of file GridTripletSeedingTool.h.

{nullptr};

m_radLengthPerSeed

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

protected

Initial value:

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

Definition at line 135 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_rAlign

protected

Initial value:

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

Definition at line 248 of file GridTripletSeedingTool.h.

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

m_rBinEdges

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

protected

Initial value:

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

Definition at line 71 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_rBinNeighborsBottom

protected

Initial value:

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

Definition at line 337 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_rBinNeighborsTop

protected

Initial value:

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

Definition at line 332 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_rBinsCustomLooping

protected

Initial value:

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

Definition at line 152 of file GridTripletSeedingTool.h.

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

m_rMax

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

protected

Initial value:

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

Definition at line 93 of file GridTripletSeedingTool.h.

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

m_rMin

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

protected

Definition at line 245 of file GridTripletSeedingTool.h.

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

m_rRangeMiddleSP

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

protected

Initial value:

{
      this,
      "rRangeMiddleSP",
      {{40.0, 90.0},
       {40.0, 90.0},
       {40.0, 200.0},
       {46.0, 200.0},
       {46.0, 200.0},
       {46.0, 250.0},
       {46.0, 250.0},
       {46.0, 250.0},
       {46.0, 200.0},
       {46.0, 200.0},
       {40.0, 200.0},
       {40.0, 90.0},
       {40.0, 90.0}},
      "radial range for middle SP"}

Definition at line 157 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_seedConfCentralMaxZOrigin

protected

Initial value:

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

Definition at line 198 of file GridTripletSeedingTool.h.

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

m_seedConfCentralMinBottomRadius

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

protected

Initial value:

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

Definition at line 195 of file GridTripletSeedingTool.h.

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

m_seedConfCentralMinImpact

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

protected

Initial value:

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

Definition at line 201 of file GridTripletSeedingTool.h.

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

m_seedConfCentralNTopLargeR

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

protected

Initial value:

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

Definition at line 189 of file GridTripletSeedingTool.h.

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

m_seedConfCentralNTopSmallR

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

protected

Initial value:

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

Definition at line 192 of file GridTripletSeedingTool.h.

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

m_seedConfCentralRMax

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

protected

Initial value:

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

Definition at line 186 of file GridTripletSeedingTool.h.

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

m_seedConfCentralZMax

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

protected

Initial value:

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

Definition at line 183 of file GridTripletSeedingTool.h.

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

m_seedConfCentralZMin

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

protected

Initial value:

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

Definition at line 180 of file GridTripletSeedingTool.h.

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

m_seedConfForwardMaxZOrigin

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

protected

Initial value:

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

Definition at line 222 of file GridTripletSeedingTool.h.

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

m_seedConfForwardMinBottomRadius

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

protected

Initial value:

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

Definition at line 219 of file GridTripletSeedingTool.h.

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

m_seedConfForwardMinImpact

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

protected

Initial value:

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

Definition at line 225 of file GridTripletSeedingTool.h.

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

m_seedConfForwardNTopLargeR

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

protected

Initial value:

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

Definition at line 213 of file GridTripletSeedingTool.h.

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

m_seedConfForwardNTopSmallR

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

protected

Initial value:

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

Definition at line 216 of file GridTripletSeedingTool.h.

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

m_seedConfForwardRMax

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

protected

Initial value:

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

Definition at line 210 of file GridTripletSeedingTool.h.

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

m_seedConfForwardZMax

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

protected

Initial value:

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

Definition at line 207 of file GridTripletSeedingTool.h.

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

m_seedConfForwardZMin

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

protected

Initial value:

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

Definition at line 204 of file GridTripletSeedingTool.h.

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

m_seedConfirmation

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

protected

Initial value:

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

Definition at line 178 of file GridTripletSeedingTool.h.

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

m_seedConfirmationInFilter

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

protected

Initial value:

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

Definition at line 272 of file GridTripletSeedingTool.h.

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

m_seedQualitySelection

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

protected

Initial value:

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

Definition at line 44 of file GridTripletSeedingTool.h.

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

m_seedWeightIncrement

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

protected

Initial value:

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

Definition at line 266 of file GridTripletSeedingTool.h.

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

m_sigmaError

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

protected

Definition at line 250 of file GridTripletSeedingTool.h.

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

m_sigmaScattering

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

protected

Initial value:

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

Definition at line 129 of file GridTripletSeedingTool.h.

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

m_stateVectorReserveSize

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

protected

Initial value:

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

Definition at line 364 of file GridTripletSeedingTool.h.

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

m_toleranceParam

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

protected

Initial value:

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

Definition at line 232 of file GridTripletSeedingTool.h.

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

m_topDoubletFinderCfg

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

private

Definition at line 374 of file GridTripletSeedingTool.h.

m_tripletFinderCfg

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

private

Definition at line 375 of file GridTripletSeedingTool.h.

m_useDeltaRorTopRadius

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

protected

Initial value:

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

Definition at line 281 of file GridTripletSeedingTool.h.

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

m_useDetailedDoubleMeasurementInfo

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

protected

Initial value:

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

Definition at line 228 of file GridTripletSeedingTool.h.

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

m_useExperimentCuts

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

protected

Initial value:

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

Definition at line 347 of file GridTripletSeedingTool.h.

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

m_useHVCollisionRegion

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

protected

Initial value:

{
      this, "useHVCollisionRegion", false, 
      "restrict collision region by Hough vertex position"}

Definition at line 123 of file GridTripletSeedingTool.h.

                                            {
      this, "useHVCollisionRegion", false, 
      "restrict collision region by Hough vertex position"};

m_useVariableMiddleSPRange

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

protected

Initial value:

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

Definition at line 154 of file GridTripletSeedingTool.h.

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

m_zAlign

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

protected

Initial value:

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

Definition at line 246 of file GridTripletSeedingTool.h.

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

m_zBinEdges

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

protected

Initial value:

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

Definition at line 65 of file GridTripletSeedingTool.h.

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

m_zBinNeighborsBottom

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

protected

Initial value:

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

Definition at line 315 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_zBinNeighborsTop

protected

Initial value:

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

Definition at line 298 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_zBinsCustomLooping

protected

Initial value:

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

Definition at line 147 of file GridTripletSeedingTool.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::GridTripletSeedingTool::m_zMax

protected

Initial value:

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

Definition at line 56 of file GridTripletSeedingTool.h.

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

m_zMin

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

protected

Initial value:

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

Definition at line 54 of file GridTripletSeedingTool.h.

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

m_zOriginWeightFactor

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

protected

Definition at line 257 of file GridTripletSeedingTool.h.

{this, "zOriginWeightFactor", 1.};

---

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

• GridTripletSeedingTool.h
• GridTripletSeedingTool.cxx