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	readTauLookupTable (Acts::Experimental::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::GbtsGraphBuilder::Config	m_graphCfg
	steering for doublet graph building
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::GbtsGraphBuilder >	m_graphBuilder
	the doublet graph builder
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_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< float >	m_maxEdgesPerSP {this, "MaxEdgesPerSP", 30.0f, " max number of Gbts edges/doublets per space point"}
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_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 46 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 22 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 87 of file GbtsSeedingTool.cxx.

  {
    // to avoid compile issues with unused veriables 
    (void) ctx;
 
    const Acts::Experimental::GraphBasedTrackSeeder::Options options{
      .bFieldInZ = 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_beamSpotCorrection ? beamSpotPos[0] : 0.0f;
    const float offsetY = m_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<Acts::Experimental::GbtsLayerIndex>(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_graphBuilder,
      *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 28 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, m_minZ0.value(), m_maxZ0.value());
 
    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(m_layerTool->readConnections(layers, connections, etaBinWidth, m_connectorInputFile.value(), m_usePixelLayers, m_useStripLayers));
 
    // 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_graphBuilder.emplace(m_graphCfg, gbtsGeo,
      logger().cloneWithSuffix("gbtsGraphBuilder"));
 
    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 79 of file GbtsSeedingTool.h.

{ return *m_logger; }

prepareConfiguration()

StatusCode ActsTrk::GbtsSeedingTool::prepareConfiguration ( )

private

sets configs based on gaudi properties defined below

Definition at line 264 of file GbtsSeedingTool.cxx.

                                                   {
    m_finderCfg.useClusterWidthCuts = m_useML;
    m_graphCfg.matchBeforeCreate = m_matchBeforeCreate;
    m_graphCfg.minPt = m_minPt;
    m_finderCfg.nMaxPhiSlice = m_nMaxPhiSlice;
    m_graphCfg.useEtaBinning = m_useEtaBinning;
    m_graphCfg.doubletFilterRZ = m_doubletFilterRZ;
    m_graphCfg.minDeltaRadius = m_minDeltaRadius;
    m_graphCfg.maxEdgesPerSP = m_maxEdgesPerSP;
    m_graphCfg.tauRatioCut = m_tauRatioCut; 
    m_graphCfg.tauRatioPrecut = m_tauRatioPrecut;
    m_finderCfg.edgeMaskMinEta = m_edgeMaskMinEta;
    m_finderCfg.hitShareThreshold = m_hitShareThreshold;
    m_finderCfg.maxEndcapClusterWidth = m_maxEndcapClusterwidth;
    m_graphCfg.d0Max = m_d0Max;
 
    //use roi for pixel and given value for strip
    m_graphCfg.maxZ0 = m_maxZ0.value();
    m_graphCfg.minZ0 = m_minZ0.value();
 
    m_graphCfg.validateTriplets = m_validateTriplets;
    m_graphCfg.useAdaptiveCuts = m_useAdaptiveCuts;
    m_graphCfg.tauRatioCorr = m_tauRatioCorr;
    m_finderCfg.addTriplets = m_addTriplets;
    m_finderCfg.maxAbsEtaAddTriplets = m_maxEtaAddTriplets;
    m_graphCfg.cutDPhiMax = m_cutDPhiMax;
    m_graphCfg.cutDCurvMax = m_cutDCurvMax;
    m_graphCfg.maxOuterRadius = m_maxOuterRadius;
 
    // The seeder no longer recognises an LRT mode, so spell out what it used
    // to imply: a triplet with no confirmation.
    if (m_LRTmode) {
      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 315 of file GbtsSeedingTool.cxx.

                                            {
  ATH_MSG_DEBUG("===== GBTS finder config =====");
  ATH_MSG_DEBUG( "beamSpotCorrection: " << m_beamSpotCorrection.value());
  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_stripConnections.value());
  ATH_MSG_DEBUG( "useClusterWidthCuts: " << m_finderCfg.useClusterWidthCuts);
  ATH_MSG_DEBUG( "matchBeforeCreate: " << m_graphCfg.matchBeforeCreate);
  ATH_MSG_DEBUG( "minSeedLevel: " << static_cast<unsigned>(m_finderCfg.minSeedLevel));
  ATH_MSG_DEBUG( "tauRatioPrecut: " << m_graphCfg.tauRatioPrecut);
  ATH_MSG_DEBUG( "tauRatioCut: " << m_graphCfg.tauRatioCut);
  ATH_MSG_DEBUG( "tauRatioCorr: " << m_graphCfg.tauRatioCorr);
  ATH_MSG_DEBUG( "etaBinWidthOverride: " << m_etaBinWidthOverride.value());
  ATH_MSG_DEBUG( "nMaxPhiSlice: " << m_finderCfg.nMaxPhiSlice);
  ATH_MSG_DEBUG( "minPt: " << m_graphCfg.minPt);
  ATH_MSG_DEBUG( "useEtaBinning: " << m_graphCfg.useEtaBinning);
  ATH_MSG_DEBUG( "doubletFilterRZ: " << m_graphCfg.doubletFilterRZ);
  ATH_MSG_DEBUG( "maxEdgesPerSP: " << m_graphCfg.maxEdgesPerSP);
  ATH_MSG_DEBUG( "minDeltaRadius: " << m_graphCfg.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_graphCfg.d0Max);
  ATH_MSG_DEBUG("maxZ0: " << m_graphCfg.maxZ0);
  ATH_MSG_DEBUG("minZ0: " << m_graphCfg.minZ0);
  ATH_MSG_DEBUG( "validateTriplets: " << m_graphCfg.validateTriplets);
  ATH_MSG_DEBUG( "useAdaptiveCuts: " << m_graphCfg.useAdaptiveCuts);
  ATH_MSG_DEBUG( "addTriplets: " << m_finderCfg.addTriplets);
  ATH_MSG_DEBUG( "maxEtaAddTriplets: " << m_finderCfg.maxAbsEtaAddTriplets);
  ATH_MSG_DEBUG("cutDphiMax: " << m_graphCfg.cutDPhiMax);
  ATH_MSG_DEBUG("cutDCurvMax: " << m_graphCfg.cutDCurvMax);
  ATH_MSG_DEBUG("maxOuterRadius: " << m_graphCfg.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);
}

readTauLookupTable()

StatusCode ActsTrk::GbtsSeedingTool::readTauLookupTable ( Acts::Experimental::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 228 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::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 167 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 131 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 128 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 114 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 147 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 146 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 156 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 133 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 170 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 135 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 100 of file GbtsSeedingTool.h.

m_filterCfg

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

private

steering for track filter

Definition at line 91 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 169 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 94 of file GbtsSeedingTool.h.

m_finderCfg

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

private

steering for seeding algorithm

Definition at line 85 of file GbtsSeedingTool.h.

m_graphBuilder

std::optional<Acts::Experimental::GbtsGraphBuilder> ActsTrk::GbtsSeedingTool::m_graphBuilder

private

the doublet graph builder

Definition at line 97 of file GbtsSeedingTool.h.

m_graphCfg

Acts::Experimental::GbtsGraphBuilder::Config ActsTrk::GbtsSeedingTool::m_graphCfg

private

steering for doublet graph building

Definition at line 88 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 171 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 103 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 111 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 82 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 125 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 117 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 127 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 168 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 165 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 166 of file GbtsSeedingTool.h.

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

m_maxEdgesPerSP

Gaudi::Property<float> ActsTrk::GbtsSeedingTool::m_maxEdgesPerSP {this, "MaxEdgesPerSP", 30.0f, " max number of Gbts edges/doublets per space point"}

private

Definition at line 145 of file GbtsSeedingTool.h.

{this, "MaxEdgesPerSP", 30.0f, " max number of Gbts edges/doublets per space point"};

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 174 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 143 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 148 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 153 of file GbtsSeedingTool.h.

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

m_minDeltaRadius

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

private

Definition at line 144 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 142 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 152 of file GbtsSeedingTool.h.

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

m_nMaxPhiSlice

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

private

Definition at line 136 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 115 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 108 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 160 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 159 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 161 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 162 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 116 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 107 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 141 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 139 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 140 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 130 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 132 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 126 of file GbtsSeedingTool.h.

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

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 121 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 122 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 129 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 163 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 164 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