ActsTrk::GbtsSeedingTool Class Reference

#include <GbtsSeedingTool.h>

Inheritance diagram for ActsTrk::GbtsSeedingTool:

Collaboration diagram for ActsTrk::GbtsSeedingTool:

Public Member Functions
	GbtsSeedingTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~GbtsSeedingTool ()=default
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

Private Member Functions
void	printGbtsConfig () const
	prints all current config settings used either with default settings or properties changed by the gaudi options tells what the defaults in the config are
StatusCode	prepareConfiguration ()
	sets configs based on gaudi properties defined below
StatusCode	readConnections (const std::vector< Acts::Experimental::GbtsLayerDescription > &layers, std::vector< Acts::Experimental::GbtsLayerConnection > &connections, float &etaBinWidth) const
	Reads the connection table and keeps the connections this pass is for: both layers have to be layers this detector has, of one technology, and that technology has to be one the pass asked for.
StatusCode	readTauLookupTable (Acts::Experimental::detail::GbtsTauLookupTable &tauLookupTable) const
	Reads the tau lookup table the cluster width cuts need: per line a cluster width, the bulk tau bounds and the near-edge ones.
const Acts::Logger &	logger () const
	Private access to the logger.

Private Attributes
std::unique_ptr< const Acts::Logger >	m_logger
	logging instance
Acts::Experimental::GraphBasedTrackSeeder::Config	m_finderCfg
	steering for seeding algorithm
Acts::Experimental::GbtsTrackingFilter::Config	m_filterCfg
	steering for track filter
std::optional< Acts::Experimental::GraphBasedTrackSeeder >	m_finder
	the actual seed fining algorithm
std::optional< Acts::Experimental::GbtsTrackingFilter >	m_filter
	the seed filter
std::optional< Acts::Experimental::GbtsRoiDescriptor >	m_internalRoi
	region of interest for pixel seeding
const std::vector< short > *	m_stripHashToLayer = nullptr
	Wafer hash to dense GBTS layer index, one map per technology.
const std::vector< short > *	m_pixelHashToLayer = nullptr
ToolHandle< IGbtsLayerTool >	m_layerTool {this, "layerTool", "ActsTrk::GbtsLayerTool/ActsGbtsLayerTool"}
	Builds the GBTS layers out of the ITk readout geometry.
Gaudi::Property< std::string >	m_connectorInputFile {this, "connectorInputFile","binTables_ITK_RUN4.txt", "input file for making connector object"}
Gaudi::Property< bool >	m_pixelConnections {this, "usePixelConnections", true, "keep the pixel to pixel connections of the table"}
Gaudi::Property< bool >	m_stripConnections {this, "useStripConnections", false, "keep the strip to strip connections of the table"}
Gaudi::Property< std::string >	m_lutFile {this, "lutInputFile", "gbts_ml_pixel_barrel_loose.lut", "file to LUT"}
Gaudi::Property< bool >	m_usePixelLayers {this, "usePixelLayers", true, "seed on the pixel layers"}
	Which technologies this instance seeds on.
Gaudi::Property< bool >	m_useStripLayers {this, "useStripLayers", false, "seed on the strip layers"}
Gaudi::Property< bool >	m_LRTmode {this, "LRTmode", false, "whether strip or pixel hits are used"}
Gaudi::Property< bool >	m_useML {this, "useML", true, "use the cluster width of the spacepoint"}
Gaudi::Property< bool >	m_matchBeforeCreate {this, "matchBeforeCreate", true, "need to check what this does"}
Gaudi::Property< bool >	m_useOldTunings {this, "useOldTunings", false, "use the tunings for 900MeV cut"}
Gaudi::Property< bool >	m_beamSpotCorrection {this, "beamSpotCorrection", true, "apply primary vertex corrections to spacepoints"}
Gaudi::Property< bool >	m_validateTriplets {this, "ValidateTriplets", true, "extra validation on pT and d0 performed to connected barrel edges"}
Gaudi::Property< bool >	m_useAdaptiveCuts {this, "UseAdaptiveCuts", true, "allows for larger accpetance of candidate edges that skip layers"}
Gaudi::Property< bool >	m_addTriplets {this, "addTriplets", false, "add seeds with three spacepoints in a defined eta region"}
Gaudi::Property< bool >	m_useEtaBinning {this, "useEtaBinning",true, "bool to use eta binning from geometry structure"}
Gaudi::Property< bool >	m_doubletFilterRZ {this, "doubletFilterRZ",true, "bool applies new Z cuts on doublets"}
Gaudi::Property< float >	m_etaBinWidthOverride {this, "etaBinOverride", 0.0f, "apply custom binning for connections"}
Gaudi::Property< float >	m_nMaxPhiSlice {this, "nMaxPhiSlice",53, "used to calculate phi slices"}
Gaudi::Property< float >	m_tauRatioCut {this, "tauRatioCut",0.007, "tau cut for doublets and triplets"}
Gaudi::Property< float >	m_tauRatioPrecut {this, "precutTauRatioMax",0.009f, "used to reject edges early if matchBeforCreate is on"}
Gaudi::Property< float >	m_tauRatioCorr {this, "tauRatioCorrection", 0.006, "correction added to tau accpetance if candidate edge skips a layer"}
Gaudi::Property< float >	m_minPt {this, "minPt", 1000.0, "Lower cutoff for seeds"}
Gaudi::Property< float >	m_maxEtaAddTriplets {this, "maxEtaAddTriplets", 1.5, "eta region in which three sapcepoint seeds are allowed"}
Gaudi::Property< float >	m_minDeltaRadius {this, "minDeltaRadius",2.0, " min dr for doublet"}
Gaudi::Property< int >	m_nMaxEdges {this, "MaxEdges",3000000, " max number of Gbts edges/doublets"}
Gaudi::Property< float >	m_cutDPhiMax {this, "cutDPhiMax", 0.012f, "not sure"}
Gaudi::Property< float >	m_cutDCurvMax {this, "cutDCurvMax", 0.001f, "not sure"}
Gaudi::Property< float >	m_minDeltaPhi {this, "minDeltaPhi", 0.001f, "not sure"}
Gaudi::Property< float >	m_maxOuterRadius {this, "maxOuterRadius", 550.0f, "not sure"}
Gaudi::Property< float >	m_minZ0 {this, "minZ0", -99999, "not sure"}
Gaudi::Property< float >	m_maxZ0 {this, "maxZ0", -99999, "not sure"}
Gaudi::Property< float >	m_d0Max {this, "d0Max", 3.0, "maximum d0 value allowed when using validateTiplets"}
Gaudi::Property< float >	m_sigmaMS {this, "sigmaMS", 0.016, "process noise from multiple scattering"}
Gaudi::Property< float >	m_radLen {this, "radLen", 0.025, "defines how much material scattering the kalman filter should take into account"}
Gaudi::Property< float >	m_sigmaX {this, "sigmaX", 0.08, "measurement resolution for residual on y direction"}
Gaudi::Property< float >	m_sigmaY {this, "sigmaY", 0.25, "measurement resolution on r-z plane"}
Gaudi::Property< float >	m_weightX {this, "weightX", 0.5, "penalty weight for track"}
Gaudi::Property< float >	m_weightY {this, "weightY", 0.5, "penalty weight for track"}
Gaudi::Property< float >	m_maxDChi2X {this, "maxDChi2X", 5.0, "gate threshold for chi2 test"}
Gaudi::Property< float >	m_maxDChi2Y {this, "maxDChi2Y", 6.0, "gate threshold for chi2 test"}
Gaudi::Property< float >	m_addHit {this, "addHit", 14.0, "reward added to tracks for each accepted hit before chi2"}
Gaudi::Property< float >	m_maxCurvature {this, "maxCurvature", 1e-3f, "maximum curvature allowed for candiadte tracklet"}
Gaudi::Property< float >	m_filterMaxZ0 {this, "filterMaxZ0", 170.0, "maximum z0 allowed for candidate tracklet"}
Gaudi::Property< float >	m_edgeMaskMinEta {this, "edgeMaskMinEta", 1.5, "minimum eta allowed for masking edges in graph so they are not used again"}
Gaudi::Property< float >	m_hitShareThreshold {this, "hitShareThreshold", 0.49, "threshold of hits that are shared between seeds before one seed is labelled a clone"}
Gaudi::Property< float >	m_maxEndcapClusterwidth {this, "maxEndcapClusterwidth", 0.35, "discards any spacepoints which dr/dz cant be accurately modelled"}

Detailed Description

Definition at line 45 of file GbtsSeedingTool.h.

Constructor & Destructor Documentation

GbtsSeedingTool()

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

Definition at line 24 of file GbtsSeedingTool.cxx.

    : base_class(type, name, parent)
  {}

~GbtsSeedingTool()

virtual ActsTrk::GbtsSeedingTool::~GbtsSeedingTool ( )

virtualdefault

Member Function Documentation

createSeeds()

ATH_FLATTEN StatusCode ActsTrk::GbtsSeedingTool::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 86 of file GbtsSeedingTool.cxx.

  {
    // to avoid compile issues with unused veriables 
    (void) ctx;
 
    const Acts::Experimental::GraphBasedTrackSeeder::Options options(bFieldInZ);
 
 
    std::vector<const xAOD::SpacePoint*> tmpSpacePoints;
 
    // add spacepoint pointers to singel container, this makes indexing them easier 
    for (const xAOD::SpacePointContainer* spacePoints : spacePointCollections) {
      for (const xAOD::SpacePoint* sp : *spacePoints) {
        tmpSpacePoints.emplace_back(sp);
      }
    }
 
 
    // create the node storage and fill it from the xAOD space points
    Acts::Experimental::GbtsNodeStorage nodeStorage = m_finder->makeNodeStorage();
 
    // node positions are relative to the beam spot in x and y if the correction is on
    const float offsetX = m_finderCfg.beamSpotCorrection ? beamSpotPos[0] : 0.0f;
    const float offsetY = m_finderCfg.beamSpotCorrection ? beamSpotPos[1] : 0.0f;
 
    std::size_t nPixelNodes = 0;
    std::size_t nStripNodes = 0;
 
    // space points GBTS has no layer for, counted rather than reported per
    // space point: the loop runs over the whole event
    std::size_t nUnmappedHashes = 0;
    std::size_t nUngroupedModules = 0;
 
    // add spacepoints to node storage
    for(std::size_t idx = 0; idx < tmpSpacePoints.size(); ++idx){
      // obtain module hash for spacepoint
      const xAOD::SpacePoint* sp = tmpSpacePoints[idx];
      const std::vector<xAOD::DetectorIDHashType>& elementlist = sp->elementIdList();
 
      // a strip space point is made of one cluster on each side of a stereo pair
      const bool isPixel(elementlist.size() == 1);
 
      if (isPixel ? !m_usePixelLayers : !m_useStripLayers) {
        continue;
      }
 
      const std::vector<short>& hashToLayer =
        isPixel ? *m_pixelHashToLayer : *m_stripHashToLayer;
      const auto hash = static_cast<std::size_t>(elementlist[0]);
      if (hash >= hashToLayer.size()) [[unlikely]] {
        ++nUnmappedHashes;
        continue;
      }
 
      const short layer = hashToLayer[hash];
      if (layer == IGbtsLayerTool::kNoLayer) {
        // a wafer GBTS does not group into any of its layers
        ++nUngroupedModules;
        continue;
      }
 
      float clusterWidth = 0.0f;
      float localPositionY = 0.0f;
      if (m_finderCfg.useClusterWidthCuts && isPixel) {
        assert(dynamic_cast<const xAOD::PixelCluster*>(sp->measurements().front())!=nullptr);
        const xAOD::PixelCluster* pCL = static_cast<const xAOD::PixelCluster*>(sp->measurements().front());
        clusterWidth = pCL->widthInEta();
        localPositionY = pCL->localPosition<2>().y();
      }
 
      // the stereo pair of a strip space point, for the strip calibration in GBTS
      Acts::OuterStripSpacePointCalibrationDetails stripDetails{};
      const Acts::OuterStripSpacePointCalibrationDetails* strip = nullptr;
      if (!isPixel) {
        // topStripCenter is global, the node frame shifts only x and y
        Eigen::Map<Eigen::Vector3f>(stripDetails.outerCenter.data()) =
          sp->topStripCenter() - Eigen::Vector3f(offsetX, offsetY, 0.0f);
        Eigen::Map<Eigen::Vector3f>(stripDetails.innerToOuterSeparation.data()) =
          sp->stripCenterDistance();
        Eigen::Map<Eigen::Vector3f>(stripDetails.outerHalfVector.data()) =
          sp->topHalfStripLength() * sp->topStripDirection();
        Eigen::Map<Eigen::Vector3f>(stripDetails.innerHalfVector.data()) =
          sp->bottomHalfStripLength() * sp->bottomStripDirection();
        strip = &stripDetails;
      }
 
      const float x = static_cast<float>(sp->x()) - offsetX;
      const float y = static_cast<float>(sp->y()) - offsetY;
      const std::optional<std::uint32_t> bin = nodeStorage.insert(
        static_cast<Acts::SpacePointIndex>(idx), x, y,
        static_cast<float>(sp->z()), std::hypot(x, y), std::atan2(y, x),
        static_cast<std::uint32_t>(layer), clusterWidth, localPositionY, strip);
 
      if (bin.has_value()) {
        ++(isPixel ? nPixelNodes : nStripNodes);
      }
    }
 
    ATH_MSG_DEBUG("Inserted " << nPixelNodes << " pixel and " << nStripNodes
                  << " strip nodes; the graph "
                  << (nodeStorage.hasStrips() ? "carries" : "does not carry")
                  << " stereo pairs");
 
    if (nUnmappedHashes != 0) [[unlikely]] {
      ATH_MSG_WARNING(nUnmappedHashes << " space points sit on a wafer hash "
                      "outside the GBTS layer map and were dropped");
    }
    if (nUngroupedModules != 0) {
      ATH_MSG_DEBUG(nUngroupedModules << " space points sit on a wafer GBTS "
                    "does not group into a layer");
    }
 
    // order the nodes and build the derived per-node data
    nodeStorage.finalize();
 
    ATH_MSG_VERBOSE("Spacepoints successfully added to node storage");
 
    Acts::SeedContainer seeds;
    m_finder->createSeeds(nodeStorage, m_internalRoi.value(), *m_filter, options, seeds);
 
    // add seeds to the output container
    seedContainer.reserve(seedContainer.size() + seeds.size(), 7.0f);
    for (auto seed : seeds) {
      seedContainer.push_back(
        seed.asConst(),
        [&](const Acts::SpacePointIndex spIndex) {
          return tmpSpacePoints[spIndex];
        });
    }
 
    ATH_MSG_VERBOSE("Number of seeds created is " << seedContainer.size());
    return StatusCode::SUCCESS;
  }

initialize()

StatusCode ActsTrk::GbtsSeedingTool::initialize ( )

overridevirtual

Definition at line 30 of file GbtsSeedingTool.cxx.

                                         {
    ATH_CHECK(m_layerTool.retrieve());
    ATH_MSG_DEBUG("Initializing " << name() << "...");
 
    // Make the logger And Propagate to ACTS routines
    m_logger = makeActsAthenaLogger(this, "Acts");
 
    // etaMin,etaMax,zMin,zMax
    m_internalRoi.emplace(-4.5, 4.5, -150.0, 150.0);
 
    ATH_CHECK( prepareConfiguration());
    printGbtsConfig();
 
    // The layer tool builds the GBTS layers, in dense layer index order, and
    // knows which layer each module hash belongs to and what it is made of.
    const std::vector<Acts::Experimental::GbtsLayerDescription>& layers =
      m_layerTool->layerDescriptions();
 
    m_pixelHashToLayer = &m_layerTool->pixelLayers();
    m_stripHashToLayer = &m_layerTool->stripLayers();
 
    if (!m_usePixelLayers && !m_useStripLayers) {
      ATH_MSG_ERROR("Neither pixel nor strip layers are enabled, there is "
                    "nothing to seed on.");
      return StatusCode::FAILURE;
    }
 
    std::vector<Acts::Experimental::GbtsLayerConnection> connections;
    float etaBinWidth = 0.0f;
    ATH_CHECK(readConnections(layers, connections, etaBinWidth));
 
    // option that allows for adding custom eta binning (default is at 0.2)
    if (m_etaBinWidthOverride.value() != 0.0f) {
      etaBinWidth = m_etaBinWidthOverride.value();
    }
 
    // the cluster width cuts are the only user of the tau lookup table
    if (m_finderCfg.useClusterWidthCuts) {
      ATH_CHECK(readTauLookupTable(m_finderCfg.tauLookupTable));
    }
 
    // create geoemtry object that holds allowed pairing of allowed eta regions in each layer
    // holds all geometry information (m_layergeomtry and connection table)
    auto gbtsGeo = std::make_shared<Acts::Experimental::GbtsGeometry>(
      layers, connections, etaBinWidth, Acts::Experimental::GbtsZ0Range{}, logger());
 
    m_finder = Acts::Experimental::GraphBasedTrackSeeder(
      Acts::Experimental::GraphBasedTrackSeeder::DerivedConfig(m_finderCfg),
      gbtsGeo, logger().cloneWithSuffix("gbtsFinder"));
 
    m_filter = Acts::Experimental::GbtsTrackingFilter(m_filterCfg, gbtsGeo);
 
    return StatusCode::SUCCESS;
  }

logger()

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

inlineprivate

Private access to the logger.

Definition at line 88 of file GbtsSeedingTool.h.

{ return *m_logger; }

prepareConfiguration()

StatusCode ActsTrk::GbtsSeedingTool::prepareConfiguration ( )

private

sets configs based on gaudi properties defined below

Definition at line 354 of file GbtsSeedingTool.cxx.

                                                   {
    m_finderCfg.useStripConnections = m_stripConnections;
    m_finderCfg.useClusterWidthCuts = m_useML;
    m_finderCfg.matchBeforeCreate = m_matchBeforeCreate;
    // useOldTunings gated the curvature bounds and the phi window together,
    // while LRT mode only wanted the first, so the seeder now has them apart
    m_finderCfg.useOldTuningsCurvature = m_useOldTunings || m_LRTmode;
    m_finderCfg.useOldTuningsPhiWindow = m_useOldTunings;
    m_finderCfg.beamSpotCorrection = m_beamSpotCorrection;
    m_finderCfg.minPt = m_minPt;
    m_finderCfg.nMaxPhiSlice = m_nMaxPhiSlice;
    m_finderCfg.useEtaBinning = m_useEtaBinning;
    m_finderCfg.doubletFilterRZ = m_doubletFilterRZ;
    m_finderCfg.minDeltaRadius = m_minDeltaRadius;
    m_finderCfg.nMaxEdges = m_nMaxEdges;
    m_finderCfg.tauRatioCut = m_tauRatioCut; 
    m_finderCfg.tauRatioPrecut = m_tauRatioPrecut;
    m_finderCfg.edgeMaskMinEta = m_edgeMaskMinEta;
    m_finderCfg.hitShareThreshold = m_hitShareThreshold;
    m_finderCfg.maxEndcapClusterWidth = m_maxEndcapClusterwidth;
    m_finderCfg.d0Max = m_d0Max;
 
    //use roi for pixel and given value for strip
    m_finderCfg.maxZ0 = m_LRTmode ? m_maxZ0.value() : m_internalRoi->zMax();
    m_finderCfg.minZ0 = m_LRTmode ? m_minZ0.value() : m_internalRoi->zMin();
 
    m_finderCfg.validateTriplets = m_validateTriplets;
    m_finderCfg.useAdaptiveCuts = m_useAdaptiveCuts;
    m_finderCfg.tauRatioCorr = m_tauRatioCorr;
    m_finderCfg.addTriplets = m_addTriplets;
    m_finderCfg.maxAbsEtaAddTriplets = m_maxEtaAddTriplets;
    m_finderCfg.cutDPhiMax = m_cutDPhiMax;
    m_finderCfg.cutDCurvMax = m_cutDCurvMax;
    m_finderCfg.minDeltaPhi = m_minDeltaPhi;
    m_finderCfg.maxOuterRadius = m_maxOuterRadius;
 
    // The seeder no longer recognises an LRT mode, so spell out the rest of
    // what it used to imply: the whole of maxCurv for the curvature bounds and
    // the phi window, and a triplet with no confirmation.
    if (m_LRTmode) {
      m_finderCfg.oldTuningsCurvatureHighEtaFraction = 1.f;
      m_finderCfg.oldTuningsCurvatureLowEtaFraction = 1.f;
      m_finderCfg.oldTuningsPhiWindowFraction = 1.f;
      m_finderCfg.minSeedLevel = 2;
    }
 
    m_filterCfg.sigmaMS = m_sigmaMS;
    m_filterCfg.radLen = m_radLen;
    m_filterCfg.sigmaX = m_sigmaX;
    m_filterCfg.sigmaY = m_sigmaY;
    m_filterCfg.weightX = m_weightX;
    m_filterCfg.weightY = m_weightY;
    m_filterCfg.maxDChi2X = m_maxDChi2X;
    m_filterCfg.maxDChi2Y = m_maxDChi2Y;
    m_filterCfg.addHit = m_addHit;
    m_filterCfg.maxCurvature = m_maxCurvature;
    m_filterCfg.maxZ0 = m_filterMaxZ0;
 
    return StatusCode::SUCCESS;
  }

printGbtsConfig()

void ActsTrk::GbtsSeedingTool::printGbtsConfig ( ) const

private

prints all current config settings used either with default settings or properties changed by the gaudi options tells what the defaults in the config are

Definition at line 416 of file GbtsSeedingTool.cxx.

                                            {
  ATH_MSG_DEBUG("===== GBTS finder config =====");
  ATH_MSG_DEBUG( "beamSpotCorrection: " << m_finderCfg.beamSpotCorrection);
  ATH_MSG_DEBUG( "connectorInputFile: " << m_connectorInputFile.value());
  ATH_MSG_DEBUG( "lutInputFile: " << m_lutFile.value());
  ATH_MSG_DEBUG( "LRTmode: " << m_LRTmode.value());
  ATH_MSG_DEBUG( "useStripConnections: " << m_finderCfg.useStripConnections);
  ATH_MSG_DEBUG( "useClusterWidthCuts: " << m_finderCfg.useClusterWidthCuts);
  ATH_MSG_DEBUG( "matchBeforeCreate: " << m_finderCfg.matchBeforeCreate);
  ATH_MSG_DEBUG( "useOldTuningsCurvature: " << m_finderCfg.useOldTuningsCurvature);
  ATH_MSG_DEBUG( "useOldTuningsPhiWindow: " << m_finderCfg.useOldTuningsPhiWindow);
  ATH_MSG_DEBUG( "minSeedLevel: " << m_finderCfg.minSeedLevel);
  ATH_MSG_DEBUG( "tauRatioPrecut: " << m_finderCfg.tauRatioPrecut);
  ATH_MSG_DEBUG( "tauRatioCut: " << m_finderCfg.tauRatioCut);
  ATH_MSG_DEBUG( "tauRatioCorr: " << m_finderCfg.tauRatioCorr);
  ATH_MSG_DEBUG( "etaBinWidthOverride: " << m_etaBinWidthOverride.value());
  ATH_MSG_DEBUG( "nMaxPhiSlice: " << m_finderCfg.nMaxPhiSlice);
  ATH_MSG_DEBUG( "minPt: " << m_finderCfg.minPt);
  ATH_MSG_DEBUG( "useEtaBinning: " << m_finderCfg.useEtaBinning);
  ATH_MSG_DEBUG( "doubletFilterRZ: " << m_finderCfg.doubletFilterRZ);
  ATH_MSG_DEBUG( "nMaxEdges: " << m_finderCfg.nMaxEdges);
  ATH_MSG_DEBUG( "minDeltaRadius: " << m_finderCfg.minDeltaRadius);
  ATH_MSG_DEBUG( "edgeMaskMinEta: " << m_finderCfg.edgeMaskMinEta);
  ATH_MSG_DEBUG( "hitShareThreshold: " << m_finderCfg.hitShareThreshold);
  ATH_MSG_DEBUG( "maxEndcapClusterWidth: " << m_finderCfg.maxEndcapClusterWidth);
  ATH_MSG_DEBUG( "d0Max: " << m_finderCfg.d0Max);
  ATH_MSG_DEBUG("maxZ0: " << m_finderCfg.maxZ0);
  ATH_MSG_DEBUG("minZ0: " << m_finderCfg.minZ0);
  ATH_MSG_DEBUG( "validateTriplets: " << m_finderCfg.validateTriplets);
  ATH_MSG_DEBUG( "useAdaptiveCuts: " << m_finderCfg.useAdaptiveCuts);
  ATH_MSG_DEBUG( "addTriplets: " << m_finderCfg.addTriplets);
  ATH_MSG_DEBUG( "maxEtaAddTriplets: " << m_finderCfg.maxAbsEtaAddTriplets);
  ATH_MSG_DEBUG("cutDphiMax: " << m_finderCfg.cutDPhiMax);
  ATH_MSG_DEBUG("cutDCurvMax: " << m_finderCfg.cutDCurvMax);
  ATH_MSG_DEBUG("minDeltaPhi: " << m_finderCfg.minDeltaPhi);
  ATH_MSG_DEBUG("maxOuterRadius: " << m_finderCfg.maxOuterRadius);
 
  ATH_MSG_DEBUG("===== GBTS filter config =====");
  ATH_MSG_DEBUG( "sigmaMS: " << m_filterCfg.sigmaMS);
  ATH_MSG_DEBUG( "radLen: " << m_filterCfg.radLen);
  ATH_MSG_DEBUG( "sigmaX: " << m_filterCfg.sigmaX);
  ATH_MSG_DEBUG( "sigmaY: " << m_filterCfg.sigmaY);
  ATH_MSG_DEBUG( "weightX: " << m_filterCfg.weightX);
  ATH_MSG_DEBUG( "weightY: " << m_filterCfg.weightY);
  ATH_MSG_DEBUG( "maxDChi2X: " << m_filterCfg.maxDChi2X);
  ATH_MSG_DEBUG( "maxDChi2Y: " << m_filterCfg.maxDChi2Y);
  ATH_MSG_DEBUG( "addHit: " << m_filterCfg.addHit);
  ATH_MSG_DEBUG( "maxCurvature: " << m_filterCfg.maxCurvature);
  ATH_MSG_DEBUG( "filterMaxZ0: " << m_filterCfg.maxZ0);
}

readConnections()

StatusCode ActsTrk::GbtsSeedingTool::readConnections ( const std::vector< Acts::Experimental::GbtsLayerDescription > & layers, std::vector< Acts::Experimental::GbtsLayerConnection > & connections, float & etaBinWidth ) const

private

Reads the connection table and keeps the connections this pass is for: both layers have to be layers this detector has, of one technology, and that technology has to be one the pass asked for.

Parameters

connections	filled with the layer pairs, in stage order
etaBinWidth	filled with the eta bin width the table was made for

Definition at line 227 of file GbtsSeedingTool.cxx.

  {
    std::ifstream connectionStream(m_connectorInputFile.value());
    if (!connectionStream.is_open()) {
      ATH_MSG_ERROR("Cannot open the GBTS connection table "
                    << m_connectorInputFile.value());
      return StatusCode::FAILURE;
    }
 
    GbtsConnectionTable::ReadResult table;
    try {
      table = GbtsConnectionTable::read(connectionStream);
    } catch (const std::exception& e) {
      ATH_MSG_ERROR("Cannot read " << m_connectorInputFile.value() << ": "
                    << e.what());
      return StatusCode::FAILURE;
    }
 
    // the table names a layer by its id, the layer tool by its dense index
    std::unordered_map<std::uint32_t, Acts::Experimental::GbtsLayerTechnology>
      layerTechnologies;
    layerTechnologies.reserve(layers.size());
    for (const Acts::Experimental::GbtsLayerDescription& layer : layers) {
      layerTechnologies.emplace(static_cast<std::uint32_t>(layer.id),
                                layer.technology);
    }
 
    etaBinWidth = table.etaBinWidth;
 
    // the stage column only fixes the order the connections are handed over in
    std::vector<std::pair<std::uint32_t, Acts::Experimental::GbtsLayerConnection>> staged;
    staged.reserve(table.connections.size());
 
    std::size_t nOtherTechnology = 0;
    std::size_t nUnknownLayer = 0;
 
    for (const GbtsConnectionTable::Connection& connection :
         table.connections) {
      const auto src = layerTechnologies.find(connection.src);
      const auto dst = layerTechnologies.find(connection.dst);
      if (src == layerTechnologies.end() || dst == layerTechnologies.end()) {
        ++nUnknownLayer;
        continue;
      }
 
      // GBTS pairs a layer only with one of its own technology
      const bool wanted = src->second == dst->second &&
                          (src->second ==
                             Acts::Experimental::GbtsLayerTechnology::Pixel
                             ? m_pixelConnections.value()
                             : m_stripConnections.value());
      if (!wanted) {
        ++nOtherTechnology;
        continue;
      }
 
      staged.emplace_back(connection.stage,
                          Acts::Experimental::GbtsLayerConnection{connection.src,
                                                                  connection.dst});
    }
 
    std::ranges::stable_sort(staged, {}, [](const auto& entry) { return entry.first; });
 
    connections.clear();
    connections.reserve(staged.size());
    for (const auto& entry : staged) {
      connections.push_back(entry.second);
    }
    const std::size_t nKept = connections.size();
 
    if (nUnknownLayer != 0) {
      ATH_MSG_WARNING(nUnknownLayer << " connections of "
                      << m_connectorInputFile.value() << " name no GBTS layer "
                      "and were dropped");
    }
    if (nKept == 0) {
      ATH_MSG_ERROR("None of the connections of "
                    << m_connectorInputFile.value() << " are usable: the table "
                    "does not match the detector this job is reconstructing");
      return StatusCode::FAILURE;
    }
    ATH_MSG_DEBUG("Kept " << nKept << " GBTS layer connections, dropping "
                  << nOtherTechnology << " of a technology not asked for, eta bin width "
                  << etaBinWidth);
 
    return StatusCode::SUCCESS;
  }

readTauLookupTable()

StatusCode ActsTrk::GbtsSeedingTool::readTauLookupTable ( Acts::Experimental::detail::GbtsTauLookupTable & tauLookupTable ) const

private

Reads the tau lookup table the cluster width cuts need: per line a cluster width, the bulk tau bounds and the near-edge ones.

Definition at line 318 of file GbtsSeedingTool.cxx.

  {
    std::ifstream lutStream(m_lutFile.value());
    if (!lutStream.is_open()) {
      ATH_MSG_ERROR("Cannot open the GBTS tau lookup table " << m_lutFile.value());
      return StatusCode::FAILURE;
    }
 
    tauLookupTable.clear();
 
    // the width is dropped: a row is located by index, one row per
    // tauLutBinWidth of cluster width, never searched
    float clusterWidth = 0.0f;
    Acts::Experimental::detail::GbtsTauBounds bounds;
    while (lutStream >> clusterWidth >> bounds.minTau >> bounds.maxTau >>
           bounds.minTauNearEdge >> bounds.maxTauNearEdge) {
      tauLookupTable.push_back(bounds);
    }
 
    if (!lutStream.eof()) {
      // ended on a parse error, not on a clean end of file
      ATH_MSG_ERROR("Malformed GBTS tau lookup table " << m_lutFile.value());
      return StatusCode::FAILURE;
    }
    if (tauLookupTable.empty()) {
      ATH_MSG_ERROR("The GBTS tau lookup table " << m_lutFile.value() << " is empty");
      return StatusCode::FAILURE;
    }
 
    ATH_MSG_DEBUG("Read " << tauLookupTable.size() << " rows of the GBTS tau lookup table "
                  << m_lutFile.value());
 
    return StatusCode::SUCCESS;
  }

Member Data Documentation

m_addHit

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_addHit {this, "addHit", 14.0, "reward added to tracks for each accepted hit before chi2"}

private

Definition at line 172 of file GbtsSeedingTool.h.

{this, "addHit", 14.0, "reward added to tracks for each accepted hit before chi2"};

m_addTriplets

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_addTriplets {this, "addTriplets", false, "add seeds with three spacepoints in a defined eta region"}

private

Definition at line 135 of file GbtsSeedingTool.h.

{this, "addTriplets", false, "add seeds with three spacepoints in a defined eta region"};

m_beamSpotCorrection

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_beamSpotCorrection {this, "beamSpotCorrection", true, "apply primary vertex corrections to spacepoints"}

private

Definition at line 132 of file GbtsSeedingTool.h.

{this, "beamSpotCorrection", true, "apply primary vertex corrections to spacepoints"};

m_connectorInputFile

Gaudi::Property<std::string> ActsTrk::GbtsSeedingTool::m_connectorInputFile {this, "connectorInputFile","binTables_ITK_RUN4.txt", "input file for making connector object"}

private

Definition at line 117 of file GbtsSeedingTool.h.

{this, "connectorInputFile","binTables_ITK_RUN4.txt", "input file for making connector object"};

m_cutDCurvMax

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_cutDCurvMax {this, "cutDCurvMax", 0.001f, "not sure"}

private

Definition at line 151 of file GbtsSeedingTool.h.

{this, "cutDCurvMax", 0.001f, "not sure"};

m_cutDPhiMax

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_cutDPhiMax {this, "cutDPhiMax", 0.012f, "not sure"}

private

Definition at line 150 of file GbtsSeedingTool.h.

{this, "cutDPhiMax", 0.012f, "not sure"};

m_d0Max

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_d0Max {this, "d0Max", 3.0, "maximum d0 value allowed when using validateTiplets"}

private

Definition at line 161 of file GbtsSeedingTool.h.

{this, "d0Max", 3.0, "maximum d0 value allowed when using validateTiplets"};

m_doubletFilterRZ

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_doubletFilterRZ {this, "doubletFilterRZ",true, "bool applies new Z cuts on doublets"}

private

Definition at line 137 of file GbtsSeedingTool.h.

{this, "doubletFilterRZ",true, "bool applies new Z cuts on doublets"};

m_edgeMaskMinEta

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_edgeMaskMinEta {this, "edgeMaskMinEta", 1.5, "minimum eta allowed for masking edges in graph so they are not used again"}

private

Definition at line 175 of file GbtsSeedingTool.h.

{this, "edgeMaskMinEta", 1.5, "minimum eta allowed for masking edges in graph so they are not used again"};

m_etaBinWidthOverride

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_etaBinWidthOverride {this, "etaBinOverride", 0.0f, "apply custom binning for connections"}

private

Definition at line 139 of file GbtsSeedingTool.h.

{this, "etaBinOverride", 0.0f, "apply custom binning for connections"};

m_filter

std::optional<Acts::Experimental::GbtsTrackingFilter> ActsTrk::GbtsSeedingTool::m_filter

private

the seed filter

Definition at line 103 of file GbtsSeedingTool.h.

m_filterCfg

Acts::Experimental::GbtsTrackingFilter::Config ActsTrk::GbtsSeedingTool::m_filterCfg

private

steering for track filter

Definition at line 97 of file GbtsSeedingTool.h.

m_filterMaxZ0

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_filterMaxZ0 {this, "filterMaxZ0", 170.0, "maximum z0 allowed for candidate tracklet"}

private

Definition at line 174 of file GbtsSeedingTool.h.

{this, "filterMaxZ0", 170.0, "maximum z0 allowed for candidate tracklet"};

m_finder

std::optional<Acts::Experimental::GraphBasedTrackSeeder> ActsTrk::GbtsSeedingTool::m_finder

private

the actual seed fining algorithm

Definition at line 100 of file GbtsSeedingTool.h.

m_finderCfg

Acts::Experimental::GraphBasedTrackSeeder::Config ActsTrk::GbtsSeedingTool::m_finderCfg

private

steering for seeding algorithm

Definition at line 94 of file GbtsSeedingTool.h.

m_hitShareThreshold

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_hitShareThreshold {this, "hitShareThreshold", 0.49, "threshold of hits that are shared between seeds before one seed is labelled a clone"}

private

Definition at line 176 of file GbtsSeedingTool.h.

{this, "hitShareThreshold", 0.49, "threshold of hits that are shared between seeds before one seed is labelled a clone"};

m_internalRoi

std::optional<Acts::Experimental::GbtsRoiDescriptor> ActsTrk::GbtsSeedingTool::m_internalRoi

private

region of interest for pixel seeding

Definition at line 106 of file GbtsSeedingTool.h.

m_layerTool

ToolHandle<IGbtsLayerTool> ActsTrk::GbtsSeedingTool::m_layerTool {this, "layerTool", "ActsTrk::GbtsLayerTool/ActsGbtsLayerTool"}

private

Builds the GBTS layers out of the ITk readout geometry.

Definition at line 114 of file GbtsSeedingTool.h.

{this, "layerTool", "ActsTrk::GbtsLayerTool/ActsGbtsLayerTool"}; 

m_logger

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

private

logging instance

Definition at line 91 of file GbtsSeedingTool.h.

m_LRTmode

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_LRTmode {this, "LRTmode", false, "whether strip or pixel hits are used"}

private

Definition at line 128 of file GbtsSeedingTool.h.

{this, "LRTmode", false, "whether strip or pixel hits are used"};

m_lutFile

Gaudi::Property<std::string> ActsTrk::GbtsSeedingTool::m_lutFile {this, "lutInputFile", "gbts_ml_pixel_barrel_loose.lut", "file to LUT"}

private

Definition at line 120 of file GbtsSeedingTool.h.

{this, "lutInputFile", "gbts_ml_pixel_barrel_loose.lut", "file to LUT"}; 

m_matchBeforeCreate

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_matchBeforeCreate {this, "matchBeforeCreate", true, "need to check what this does"}

private

Definition at line 130 of file GbtsSeedingTool.h.

{this, "matchBeforeCreate", true, "need to check what this does"};

m_maxCurvature

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxCurvature {this, "maxCurvature", 1e-3f, "maximum curvature allowed for candiadte tracklet"}

private

Definition at line 173 of file GbtsSeedingTool.h.

{this, "maxCurvature", 1e-3f, "maximum curvature allowed for candiadte tracklet"};

m_maxDChi2X

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxDChi2X {this, "maxDChi2X", 5.0, "gate threshold for chi2 test"}

private

Definition at line 170 of file GbtsSeedingTool.h.

{this, "maxDChi2X", 5.0, "gate threshold for chi2 test"}; 

m_maxDChi2Y

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxDChi2Y {this, "maxDChi2Y", 6.0, "gate threshold for chi2 test"}

private

Definition at line 171 of file GbtsSeedingTool.h.

{this, "maxDChi2Y", 6.0, "gate threshold for chi2 test"};

m_maxEndcapClusterwidth

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxEndcapClusterwidth {this, "maxEndcapClusterwidth", 0.35, "discards any spacepoints which dr/dz cant be accurately modelled"}

private

Definition at line 179 of file GbtsSeedingTool.h.

{this, "maxEndcapClusterwidth", 0.35, "discards any spacepoints which dr/dz cant be accurately modelled"};

m_maxEtaAddTriplets

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxEtaAddTriplets {this, "maxEtaAddTriplets", 1.5, "eta region in which three sapcepoint seeds are allowed"}

private

Definition at line 147 of file GbtsSeedingTool.h.

{this, "maxEtaAddTriplets", 1.5, "eta region in which three sapcepoint seeds are allowed"}; 

m_maxOuterRadius

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxOuterRadius {this, "maxOuterRadius", 550.0f, "not sure"}

private

Definition at line 153 of file GbtsSeedingTool.h.

{this, "maxOuterRadius", 550.0f, "not sure"};

m_maxZ0

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxZ0 {this, "maxZ0", -99999, "not sure"}

private

Definition at line 158 of file GbtsSeedingTool.h.

{this, "maxZ0", -99999, "not sure"};

m_minDeltaPhi

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_minDeltaPhi {this, "minDeltaPhi", 0.001f, "not sure"}

private

Definition at line 152 of file GbtsSeedingTool.h.

{this, "minDeltaPhi", 0.001f, "not sure"};

m_minDeltaRadius

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_minDeltaRadius {this, "minDeltaRadius",2.0, " min dr for doublet"}

private

Definition at line 148 of file GbtsSeedingTool.h.

{this, "minDeltaRadius",2.0, " min dr for doublet"}; 

m_minPt

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_minPt {this, "minPt", 1000.0, "Lower cutoff for seeds"}

private

Definition at line 146 of file GbtsSeedingTool.h.

{this, "minPt", 1000.0, "Lower cutoff for seeds"};

m_minZ0

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_minZ0 {this, "minZ0", -99999, "not sure"}

private

Definition at line 157 of file GbtsSeedingTool.h.

{this, "minZ0", -99999, "not sure"};

m_nMaxEdges

Gaudi::Property<int> ActsTrk::GbtsSeedingTool::m_nMaxEdges {this, "MaxEdges",3000000, " max number of Gbts edges/doublets"}

private

Definition at line 149 of file GbtsSeedingTool.h.

{this, "MaxEdges",3000000, " max number of Gbts edges/doublets"};

m_nMaxPhiSlice

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_nMaxPhiSlice {this, "nMaxPhiSlice",53, "used to calculate phi slices"}

private

Definition at line 140 of file GbtsSeedingTool.h.

{this, "nMaxPhiSlice",53, "used to calculate phi slices"};

m_pixelConnections

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_pixelConnections {this, "usePixelConnections", true, "keep the pixel to pixel connections of the table"}

private

Definition at line 118 of file GbtsSeedingTool.h.

{this, "usePixelConnections", true, "keep the pixel to pixel connections of the table"};

m_pixelHashToLayer

const std::vector<short>* ActsTrk::GbtsSeedingTool::m_pixelHashToLayer = nullptr

private

Definition at line 111 of file GbtsSeedingTool.h.

m_radLen

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_radLen {this, "radLen", 0.025, "defines how much material scattering the kalman filter should take into account"}

private

Definition at line 165 of file GbtsSeedingTool.h.

{this, "radLen", 0.025, "defines how much material scattering the kalman filter should take into account"};

m_sigmaMS

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_sigmaMS {this, "sigmaMS", 0.016, "process noise from multiple scattering"}

private

Definition at line 164 of file GbtsSeedingTool.h.

{this, "sigmaMS", 0.016, "process noise from multiple scattering"};

m_sigmaX

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_sigmaX {this, "sigmaX", 0.08, "measurement resolution for residual on y direction"}

private

Definition at line 166 of file GbtsSeedingTool.h.

{this, "sigmaX", 0.08, "measurement resolution for residual on y direction"}; 

m_sigmaY

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_sigmaY {this, "sigmaY", 0.25, "measurement resolution on r-z plane"}

private

Definition at line 167 of file GbtsSeedingTool.h.

{this, "sigmaY", 0.25, "measurement resolution on r-z plane"};

m_stripConnections

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_stripConnections {this, "useStripConnections", false, "keep the strip to strip connections of the table"}

private

Definition at line 119 of file GbtsSeedingTool.h.

{this, "useStripConnections", false, "keep the strip to strip connections of the table"};

m_stripHashToLayer

const std::vector<short>* ActsTrk::GbtsSeedingTool::m_stripHashToLayer = nullptr

private

Wafer hash to dense GBTS layer index, one map per technology.

Used to put a space point on the layer its module belongs to.

Definition at line 110 of file GbtsSeedingTool.h.

m_tauRatioCorr

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_tauRatioCorr {this, "tauRatioCorrection", 0.006, "correction added to tau accpetance if candidate edge skips a layer"}

private

Definition at line 145 of file GbtsSeedingTool.h.

{this, "tauRatioCorrection", 0.006, "correction added to tau accpetance if candidate edge skips a layer"}; 

m_tauRatioCut

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_tauRatioCut {this, "tauRatioCut",0.007, "tau cut for doublets and triplets"}

private

Definition at line 143 of file GbtsSeedingTool.h.

{this, "tauRatioCut",0.007, "tau cut for doublets and triplets"}; 

m_tauRatioPrecut

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_tauRatioPrecut {this, "precutTauRatioMax",0.009f, "used to reject edges early if matchBeforCreate is on"}

private

Definition at line 144 of file GbtsSeedingTool.h.

{this, "precutTauRatioMax",0.009f, "used to reject edges early if matchBeforCreate is on"};

m_useAdaptiveCuts

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_useAdaptiveCuts {this, "UseAdaptiveCuts", true, "allows for larger accpetance of candidate edges that skip layers"}

private

Definition at line 134 of file GbtsSeedingTool.h.

{this, "UseAdaptiveCuts", true, "allows for larger accpetance of candidate edges that skip layers"};

m_useEtaBinning

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_useEtaBinning {this, "useEtaBinning",true, "bool to use eta binning from geometry structure"}

private

Definition at line 136 of file GbtsSeedingTool.h.

{this, "useEtaBinning",true, "bool to use eta binning from geometry structure"}; 

m_useML

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_useML {this, "useML", true, "use the cluster width of the spacepoint"}

private

Definition at line 129 of file GbtsSeedingTool.h.

{this, "useML", true, "use the cluster width of the spacepoint"};

m_useOldTunings

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_useOldTunings {this, "useOldTunings", false, "use the tunings for 900MeV cut"}

private

Definition at line 131 of file GbtsSeedingTool.h.

{this, "useOldTunings", false, "use the tunings for 900MeV cut"};

m_usePixelLayers

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_usePixelLayers {this, "usePixelLayers", true, "seed on the pixel layers"}

private

Which technologies this instance seeds on.

A space point is used only when its layer is enabled.

Definition at line 124 of file GbtsSeedingTool.h.

{this, "usePixelLayers", true, "seed on the pixel layers"};

m_useStripLayers

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_useStripLayers {this, "useStripLayers", false, "seed on the strip layers"}

private

Definition at line 125 of file GbtsSeedingTool.h.

{this, "useStripLayers", false, "seed on the strip layers"};

m_validateTriplets

Gaudi::Property<bool> ActsTrk::GbtsSeedingTool::m_validateTriplets {this, "ValidateTriplets", true, "extra validation on pT and d0 performed to connected barrel edges"}

private

Definition at line 133 of file GbtsSeedingTool.h.

{this, "ValidateTriplets", true, "extra validation on pT and d0 performed to connected barrel edges"};

m_weightX

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_weightX {this, "weightX", 0.5, "penalty weight for track"}

private

Definition at line 168 of file GbtsSeedingTool.h.

{this, "weightX", 0.5, "penalty weight for track"};

m_weightY

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_weightY {this, "weightY", 0.5, "penalty weight for track"}

private

Definition at line 169 of file GbtsSeedingTool.h.

{this, "weightY", 0.5, "penalty weight for track"};

---

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

• GbtsSeedingTool.h
• GbtsSeedingTool.cxx