InDet::SiSPGNNTrackMaker Class Reference

InDet::SiSPGNNTrackMaker is an algorithm that uses the GNN-based track finding tool to reconstruct tracks and the use track fitter to obtain track parameters. More...

#include <SiSPGNNTrackMaker.h>

Inheritance diagram for InDet::SiSPGNNTrackMaker:

Collaboration diagram for InDet::SiSPGNNTrackMaker:

Public Member Functions
	SiSPGNNTrackMaker (const std::string &name, ISvcLocator *pSvcLocator)
virtual StatusCode	initialize () override
virtual StatusCode	execute (const EventContext &ctx) const override
virtual bool	isClonable () const override
	Make this algorithm clonable.
MsgStream &	dump (MsgStream &out) const
std::ostream &	dump (std::ostream &out) const
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
MsgStream &	dumptools (MsgStream &out) const
MsgStream &	dumpevent (MsgStream &out) const
int	passEtaDepCuts (const Trk::Track &track) const
std::tuple< bool, int, std::unique_ptr< Trk::Track > >	doFitAndCut (const EventContext &ctx, std::vector< const Trk::SpacePoint * > &spacePoints, std::vector< const Trk::PrepRawData * > &clusters, int &trackCounter) const
	Fits a track and applies quality cuts to determine if it should be kept.
bool	prefitCheck (unsigned int nPix, unsigned int nStrip, unsigned int nClusters, unsigned int nSpacePoints) const
std::unique_ptr< Trk::Track >	fitTrack (const EventContext &ctx, std::vector< const Trk::PrepRawData * > clusters, const Trk::TrackParameters &initial_params, int trackCounter) const
std::pair< std::vector< const Trk::SpacePoint * >, std::vector< uint32_t > >	getSpacePoints (const std::vector< uint32_t > &trackIndices, const std::vector< const Trk::SpacePoint * > &allSpacePoints) const
std::vector< const Trk::PrepRawData * >	spacePointsToClusters (const std::vector< const Trk::SpacePoint * > &spacePoints) const
std::vector< const Trk::PrepRawData * >	getClusters (const std::vector< std::vector< uint32_t > > &clusterTracks, const std::vector< const Trk::PrepRawData * > &allClusters, int trackNumber) const
std::vector< const Trk::SpacePoint * >	getSpacePointsInEvent (const EventContext &ctx, int eventNumber) const
std::vector< const Trk::SpacePoint * >	getSpacePointsInEvent (const EventContext &ctx, const SG::ReadHandleKey< SpacePointContainer > &containerKey) const
std::vector< const Trk::SpacePoint * >	getSpacePointsInEvent (const EventContext &ctx, const SG::ReadHandleKey< SpacePointOverlapCollection > &containerKey) const
std::vector< const Trk::PrepRawData * >	getClustersInEvent (const EventContext &ctx, int eventNumber) const
std::vector< float >	getEdgeScores (const std::vector< uint32_t > &sortedID, const std::unordered_map< int, std::unordered_map< int, float > > &edgeMap) const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
SG::ReadHandleKey< SpacePointContainer >	m_SpacePointsPixelKey
SG::ReadHandleKey< SpacePointContainer >	m_SpacePointsSCTKey
SG::ReadHandleKey< SpacePointOverlapCollection >	m_SpacePointsOverlapKey {this, "SpacePointsOverlapName", "ITkOverlapSpacePoints"}
SG::ReadHandleKey< InDet::PixelClusterContainer >	m_ClusterPixelKey
SG::ReadHandleKey< InDet::SCT_ClusterContainer >	m_ClusterStripKey
SG::WriteHandleKey< TrackCollection >	m_outputTracksKey
SG::WriteHandleKey< std::vector< std::vector< float > > >	m_outputEdgeScoresKey
ToolHandle< IGNNTrackFinder >	m_gnnTrackFinder
	GNN-based track finding tool that produces track candidates.
ToolHandle< ISeedFitter >	m_seedFitter
ToolHandle< Trk::ITrackFitter >	m_trackFitter
	Track Fitter.
ToolHandle< Trk::IExtendedTrackSummaryTool >	m_trackSummaryTool
ToolHandle< IGNNTrackReaderTool >	m_gnnTrackReader
BooleanProperty	m_areInputClusters
BooleanProperty	m_doRecoTrackCuts
ServiceHandle< IInDetEtaDependentCutsSvc >	m_etaDependentCutsSvc
UnsignedIntegerProperty	m_minClusters {this, "minClusters", 6, "Min number clusters"}
UnsignedIntegerProperty	m_minPixelClusters {this, "minPixelClusters", 1, "min pixel clusters"}
UnsignedIntegerProperty	m_minStripClusters {this, "minStripClusters", 0, "Minimum number of strip clusters"}
DoubleProperty	m_pTmin {this, "pTmin", 400., "min pT"}
DoubleProperty	m_etamax {this, "etamax", 4., "max reco eta"}
BooleanProperty	m_doRecoverFailedFits
BooleanProperty	m_saveEdgeScore {this, "saveEdgeScore", false, "Save edge scores in a temporary container"}

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

InDet::SiSPGNNTrackMaker is an algorithm that uses the GNN-based track finding tool to reconstruct tracks and the use track fitter to obtain track parameters.

It turns a collection of Trk::Tracks.

Author

xiang.nosp@m.yang.nosp@m..ju@c.nosp@m.ern..nosp@m.ch

Definition at line 42 of file SiSPGNNTrackMaker.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

SiSPGNNTrackMaker()

InDet::SiSPGNNTrackMaker::SiSPGNNTrackMaker	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 16 of file SiSPGNNTrackMaker.cxx.

  : AthReentrantAlgorithm(name, pSvcLocator)
{
  
}

Member Function Documentation

cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

doFitAndCut()

std::tuple< bool, int, std::unique_ptr< Trk::Track > > InDet::SiSPGNNTrackMaker::doFitAndCut ( const EventContext & ctx, std::vector< const Trk::SpacePoint * > & spacePoints, std::vector< const Trk::PrepRawData * > & clusters, int & trackCounter ) const

protected

Fits a track and applies quality cuts to determine if it should be kept.

Parameters

ctx	Event context for conditions access
clusters	Vector of cluster measurements used to fit the track
initial_params	Initial track parameters from seed finding
trackCounter	Index/ID of the track candidate being processed

Returns

std::tuple<bool, int, std::unique_ptr<Trk::Track>>

• bool: Whether the fit was successful
• int: Error/status code (0 for success, >0 for specific failure modes)
• Track: The fitted track (nullptr if fit fails or track rejected)

This function performs the following steps:

1. Fits the track using the provided clusters and initial parameters
2. Checks basic kinematic cuts (pT, eta)
3. Computes track summary (hits, holes)
4. Applies eta-dependent quality cuts if configured

Error codes:

• 0: Success, track passes all cuts
• 1: Failed minimum silicon hits requirement
• 2: Failed minimum pixel hits requirement
• 3: Failed minimum pT requirement
• 4: Failed maximum z0 requirement
• 5: Failed maximum d0 requirement
• 6: Failed maximum holes requirement
• 999: Track fit failed

Note

The track fitting is performed using the configured track fitter tool

Quality cuts are configurable via job options

Definition at line 531 of file SiSPGNNTrackMaker.cxx.

  {
    // get cluster list
    int nPIX(0), nStrip(0);
 
    for (const Trk::PrepRawData* cl : clusters) {
      if (cl->type(Trk::PrepRawDataType::PixelCluster)) nPIX++;
      if (cl->type(Trk::PrepRawDataType::SCT_Cluster)) nStrip++;
    }
 
    ATH_MSG_DEBUG("Track " << trackCounter << " has " << spacePoints.size()
                           << " space points, " << clusters.size()
                           << " clusters, " << nPIX << " pixel clusters, "
                           << nStrip << " strip clusters");
 
    // check hit counts
    if (not prefitCheck(nPIX, nStrip, clusters.size(), spacePoints.size())) {
      ATH_MSG_DEBUG("Track " << trackCounter << " does not pass prefit cuts, skipping");
      return std::make_tuple(false, 999, nullptr);
    }
 
    // conformal mapping for track parameters
    auto trkParameters = m_seedFitter->fit(spacePoints);
    if (trkParameters == nullptr) {
      ATH_MSG_DEBUG("Conformal mapping failed");
      return std::make_tuple(false, 999, nullptr);
    }
 
    std::unique_ptr<Trk::Track> track = fitTrack(ctx, clusters, *trkParameters, trackCounter);
 
    if (track == nullptr || track->perigeeParameters() == nullptr) {
      ATH_MSG_DEBUG("Track " << trackCounter
                             << " fails the chi2 fit, skipping");
      return std::make_tuple(false, 999, nullptr);
    }
 
    // compute pT and skip if pT too low
    if (track->perigeeParameters()->pT() < m_pTmin) {
      ATH_MSG_DEBUG("Track " << trackCounter
                             << "with pt = " << track->perigeeParameters()->pT()
                             << " has pT too low, skipping track!");
      return std::make_tuple(false, 999, nullptr);
    }
 
    // get rid of tracks with eta too large
    if (std::abs(track->perigeeParameters()->eta()) > m_etamax) {
      ATH_MSG_DEBUG("Track " << trackCounter << "with eta = "
                             << std::abs(track->perigeeParameters()->eta())
                             << " has eta too high, skipping track!");
      return std::make_tuple(false, 999, nullptr);
    }
 
    // if track fit succeeds, eta and pT within range, compute track summary. This is quite expensive.
    m_trackSummaryTool->computeAndReplaceTrackSummary(
        ctx, *track, false /* DO NOT suppress hole search*/);
    
    int passTrackCut = (m_doRecoTrackCuts) ? passEtaDepCuts(*track) : -1;
    
    return std::make_tuple(true, passTrackCut, std::move(track));
    
  }

dump() [1/2]

MsgStream & InDet::SiSPGNNTrackMaker::dump

(

MsgStream &

out

)

const

Definition at line 686 of file SiSPGNNTrackMaker.cxx.

{
  out<<std::endl;
  if(msgLvl(MSG::DEBUG))  return dumpevent(out);
  else return dumptools(out);
}

dump() [2/2]

std::ostream & InDet::SiSPGNNTrackMaker::dump

(

std::ostream &

out

)

const

Definition at line 716 of file SiSPGNNTrackMaker.cxx.

{
  return out;
}

dumpevent()

MsgStream & InDet::SiSPGNNTrackMaker::dumpevent ( MsgStream & out ) const

protected

Definition at line 711 of file SiSPGNNTrackMaker.cxx.

{
  return out;
}

dumptools()

MsgStream & InDet::SiSPGNNTrackMaker::dumptools ( MsgStream & out ) const

protected

Definition at line 697 of file SiSPGNNTrackMaker.cxx.

{
  out<<"| Location of output tracks                       | "
     <<std::endl;
  out<<"|----------------------------------------------------------------"
     <<"----------------------------------------------------|"
     <<std::endl;
  return out;
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode InDet::SiSPGNNTrackMaker::execute ( const EventContext & ctx ) const

overridevirtual

Definition at line 88 of file SiSPGNNTrackMaker.cxx.

{ 
  SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
  ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
 
  SG::WriteHandle<std::vector<std::vector<float>>> outputEdgeScores{m_outputEdgeScoresKey, ctx};
  ATH_CHECK(outputEdgeScores.record(std::make_unique<std::vector<std::vector<float>>>()));
  
  // get event info
  uint32_t runNumber = ctx.eventID().run_number();
  uint32_t eventNumber = ctx.eventID().event_number();
 
  // get all space points from event
  std::vector<const Trk::SpacePoint*> spacePoints = getSpacePointsInEvent(ctx, eventNumber);
 
  // get all clusters from event
  std::vector<const Trk::PrepRawData*> allClusters = getClustersInEvent(ctx, eventNumber);
 
  // get tracks from GNN chain
  std::vector<std::vector<uint32_t> > TT;
  std::vector<std::vector<uint32_t> > clusterTracks;
  std::unordered_map<int, std::unordered_map<int, float>> edgeMap;
  if (m_gnnTrackFinder.isSet()) {
    ATH_CHECK(m_gnnTrackFinder->getTracks(
      spacePoints, 
      TT, 
      m_saveEdgeScore ? &edgeMap : nullptr
      )
    );
  } else if (m_gnnTrackReader.isSet()) {
    // if track candidates are built from cluster, get both clusters and SPs
    m_areInputClusters ? 
      m_gnnTrackReader->getTracks(runNumber, eventNumber, clusterTracks, TT) :
      m_gnnTrackReader->getTracks(runNumber, eventNumber, TT); 
  } else {
    ATH_MSG_ERROR("Both GNNTrackFinder and GNNTrackReader are not set");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Event " << eventNumber << " obtained " << TT.size() << " Tracks");
 
  // loop over all track candidates
  // and perform track fitting for each.
  int trackCounter = -1;
  std::vector<int> status_codes;
  // track processing loop
  for (auto& trackIndices : TT) {
    // For each track candidate:
    trackCounter++;
 
    // 1. Sort space points by distance from origin (and retrieve SP ID for edge scores)
    std::pair<std::vector<const Trk::SpacePoint*>, std::vector<uint32_t> > trackInfos = getSpacePoints(trackIndices, spacePoints);
    std::vector<const Trk::SpacePoint*> trackCandidate = trackInfos.first;
    std::vector<uint32_t> sortedID = trackInfos.second;
 
    // 2. Get associated clusters
    // if track candidates are built from cluster, get both clusters and SPs
    std::vector<const Trk::PrepRawData*> clusters = m_areInputClusters ? 
      getClusters (clusterTracks, allClusters, trackCounter) 
      : spacePointsToClusters(trackCandidate) ;
 
    // 3. Perform track fitting:
    //    - Initial conformal mapping
    //    - First chi2 fit without outlier removal
    //    - Second chi2 fit with improved initial estimate of track parameters and with outlier removal
    // 4. Apply quality cuts (pT, eta)
    // 5. Compute track summary
    // 6. Store track if it passes all criteria
    auto [fitSuccess, passTrackCut, track] = doFitAndCut(ctx, trackCandidate, clusters, trackCounter);
 
    if (not fitSuccess) {
      continue;
    }
 
    if (passTrackCut <= 0) {
      outputTracks->push_back(track.release());
      if (m_saveEdgeScore){
        std::vector<float> edges = getEdgeScores(sortedID, edgeMap);
        outputEdgeScores->push_back(edges);
      }
    }
 
    status_codes.push_back(passTrackCut);
 
  }
 
  if (m_doRecoTrackCuts) {
    ATH_MSG_INFO("Event " << eventNumber << " has " << status_codes.size() << " tracks found, " 
                << std::count(status_codes.begin(), status_codes.end(), 0)
                << " tracks remains after applying track cuts");
  } else {
    ATH_MSG_INFO("Event " << eventNumber << " has " << status_codes.size() << " tracks found, all tracks are kept");
  }
 
  return StatusCode::SUCCESS;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

fitTrack()

std::unique_ptr< Trk::Track > InDet::SiSPGNNTrackMaker::fitTrack ( const EventContext & ctx, std::vector< const Trk::PrepRawData * > clusters, const Trk::TrackParameters & initial_params, int trackCounter ) const

protected

Definition at line 598 of file SiSPGNNTrackMaker.cxx.

  {
 
    Trk::ParticleHypothesis matEffects = Trk::pion;
    // first fit the track with local parameters and without outlier removal.
    bool keepOnTrying = true;
    std::unique_ptr<Trk::Track> track;
    while (keepOnTrying) {
      track = m_trackFitter->fit(ctx, clusters, initial_params, false, matEffects);
      // any need to recover a failed fit ?
      if (track == nullptr || track->perigeeParameters() == nullptr) {
        clusters.pop_back();
        if (clusters.size()<m_minClusters || !m_doRecoverFailedFits) {
          keepOnTrying = false;
        }
      } else {
        keepOnTrying = false;
      }
    }
 
    if (track == nullptr || track->perigeeParameters() == nullptr) {
      ATH_MSG_DEBUG("Track " << trackCounter
                             << " fails the first chi2 fit, skipping");
      return track;
    }
 
    // reject track with pT too low, default 400 MeV
    if (track->perigeeParameters()->pT() < m_pTmin) {
      ATH_MSG_DEBUG("Track " << trackCounter
                             << " fails the first chi2 fit, skipping");
      return nullptr;
    }
 
    // finally fit with outlier removal
    Trk::Perigee origPerigee = *track->perigeeParameters();
    keepOnTrying = true;
    while (keepOnTrying) {
      track = m_trackFitter->fit(ctx, clusters, origPerigee, true, matEffects);
      // any need to recover a failed or bad fit ?
      bool doRefit=false;
      if (track == nullptr || track->trackSummary() == nullptr || track->outliersOnTrack()->size()>=3) {
        doRefit=true;
      } 
      if (doRefit && m_doRecoverFailedFits) {
        clusters.pop_back();
        if (clusters.size()<m_minClusters) {
          keepOnTrying=false;
        }
      } else {
        keepOnTrying=false;
      }
    }
 
    if (!track) ATH_MSG_DEBUG("Track " << trackCounter
                  << " fails the second chi2 fit, skipping");
 
    return track;
 
  }

getClusters()

std::vector< const Trk::PrepRawData * > InDet::SiSPGNNTrackMaker::getClusters ( const std::vector< std::vector< uint32_t > > & clusterTracks, const std::vector< const Trk::PrepRawData * > & allClusters, int trackNumber ) const

protected

Definition at line 480 of file SiSPGNNTrackMaker.cxx.

        {
  std::vector<uint32_t> clusterIndices = clusterTracks[trackNumber];
  std::vector<const Trk::PrepRawData*> clusters;
  clusters.reserve(clusterIndices.size());
  for (uint32_t id : clusterIndices) {
    if (id > allClusters.size()) {
      ATH_MSG_ERROR("Cluster index out of range");
      continue;
    }
    clusters.push_back(allClusters[id]);
  }
  return clusters;
}

getClustersInEvent()

std::vector< const Trk::PrepRawData * > InDet::SiSPGNNTrackMaker::getClustersInEvent ( const EventContext & ctx, int eventNumber ) const

protected

Definition at line 356 of file SiSPGNNTrackMaker.cxx.

        {
  std::vector<const Trk::PrepRawData*> allClusters;
  if (m_areInputClusters) {
    SG::ReadHandle<InDet::PixelClusterContainer> pixcontainer(m_ClusterPixelKey,
                                                            ctx);
    SG::ReadHandle<InDet::SCT_ClusterContainer> strip_container(m_ClusterStripKey,
                                                            ctx);
 
    if (!pixcontainer.isValid()) {
      ATH_MSG_ERROR("Pixel container invalid, returning");
      return allClusters;
    }
 
    if (!strip_container.isValid()) {
      ATH_MSG_ERROR("Strip container invalid, returning");
      return allClusters;
    }
 
    auto pixcollection = pixcontainer->begin();
    auto pixcollectionEnd = pixcontainer->end();
    for (; pixcollection != pixcollectionEnd; ++pixcollection) {
      if ((*pixcollection)->empty()) {
        ATH_MSG_WARNING("Empty pixel cluster collection encountered");
        continue;
      }
      auto const* clusterCollection = (*pixcollection);
      auto thisCluster = clusterCollection->begin();
      auto clusterEnd = clusterCollection->end();
      for (; thisCluster != clusterEnd; ++thisCluster) {
        const PixelCluster* cl = (*thisCluster);
        allClusters.push_back(cl);
      }
    }
 
    auto strip_collection = strip_container->begin();
    auto strip_collectionEnd = strip_container->end();
    for (; strip_collection != strip_collectionEnd; ++strip_collection) {
      if ((*strip_collection)->empty()) {
        ATH_MSG_WARNING("Empty strip cluster collection encountered");
        continue;
      }
      auto const* clusterCollection = (*strip_collection);
      auto thisCluster = clusterCollection->begin();
      auto clusterEnd = clusterCollection->end();
      for (; thisCluster != clusterEnd; ++thisCluster) {
        const SCT_Cluster* cl = (*thisCluster);
        allClusters.push_back(cl);
      }
    }
 
    ATH_MSG_DEBUG("Event " << eventNumber << " has " << allClusters.size()
                          << " clusters");
  }
  return allClusters;
}

getEdgeScores()

std::vector< float > InDet::SiSPGNNTrackMaker::getEdgeScores ( const std::vector< uint32_t > & sortedID, const std::unordered_map< int, std::unordered_map< int, float > > & edgeMap ) const

protected

Definition at line 185 of file SiSPGNNTrackMaker.cxx.

        {
  
  std::vector<float> edges;
  edges.reserve(sortedID.size() - 1);
 
  if (sortedID.size() < 2) {
    ATH_MSG_WARNING("Not enough SP in this track, returning empty edge list!");
    return edges;
  }
  if (edgeMap.empty()) {
    ATH_MSG_WARNING("Empty edgeMap, returning empty edge list! ");
    return edges;
  }
 
  for (std::size_t i = 0; i < sortedID.size() - 1; ++i) {
      uint32_t src = sortedID[i];
      uint32_t dst = sortedID[i+1];
      
      auto srcMap = edgeMap.find(src);
        if (srcMap == edgeMap.end()) {
            edges.push_back(-1.f);
            continue;
        }
 
        auto dstMap = srcMap->second.find(dst);
        if (dstMap == srcMap->second.end()) {
            edges.push_back(-1.f);
            continue;
        }
 
        float score = dstMap->second;
        edges.push_back(score);
  }
 
  return edges;
}

getSpacePoints()

std::pair< std::vector< const Trk::SpacePoint * >, std::vector< uint32_t > > InDet::SiSPGNNTrackMaker::getSpacePoints ( const std::vector< uint32_t > & trackIndices, const std::vector< const Trk::SpacePoint * > & allSpacePoints ) const

protected

Definition at line 416 of file SiSPGNNTrackMaker.cxx.

        {
 
  std::vector<const Trk::SpacePoint*> trackCandidate;
  std::vector<uint32_t> sorted_idx;
  trackCandidate.reserve(trackIndices.size());
  sorted_idx.reserve(trackIndices.size());
 
  std::vector<std::tuple<double, const Trk::SpacePoint*, uint32_t> > distanceSortedSPs;
 
  // get track space points
  // sort SPs in track by distance from origin
  for (auto& id : trackIndices) {
    if (id > allSpacePoints.size()) {
      ATH_MSG_WARNING("SpacePoint index "
                      << id << " out of range: " << allSpacePoints.size());
      continue;
    }
 
    const Trk::SpacePoint* sp = allSpacePoints[id];
 
    // store distance - hit paire
    if (sp != nullptr) {
      distanceSortedSPs.push_back(
        std::make_tuple(
          pow(sp->globalPosition().x(), 2) + pow(sp->globalPosition().y(), 2),
          sp,
          id
        )
      );
    }
  }
 
  // sort by distance
  std::sort(distanceSortedSPs.begin(), distanceSortedSPs.end());
 
  // add SP to trk candidate in the same order
  for (size_t i = 0; i < distanceSortedSPs.size(); i++) {
    trackCandidate.push_back(std::get<1>(distanceSortedSPs[i]));
 
    if (m_saveEdgeScore) {
      sorted_idx.push_back(std::get<2>(distanceSortedSPs[i]));
    }
  }
  
  return std::make_pair(trackCandidate, sorted_idx);
}

getSpacePointsInEvent() [1/3]

std::vector< const Trk::SpacePoint * > InDet::SiSPGNNTrackMaker::getSpacePointsInEvent ( const EventContext & ctx, const SG::ReadHandleKey< SpacePointContainer > & containerKey ) const

protected

Definition at line 307 of file SiSPGNNTrackMaker.cxx.

        {
  std::vector<const Trk::SpacePoint*> spacePoints;
  if (not containerKey.empty()){
 
    SG::ReadHandle<SpacePointContainer> container{containerKey, ctx};
 
    if (container.isValid()){
      // loop over spacepoint collection
      auto spc = container->begin();
      auto spce = container->end();
      for(; spc != spce; ++spc){
        const SpacePointCollection* spCollection = (*spc);
        auto sp = spCollection->begin();
        auto spe = spCollection->end();
        for(; sp != spe; ++sp) {
          const Trk::SpacePoint* spacePoint = (*sp);
          spacePoints.push_back(spacePoint);
        }
      }
    }
  }
 
  return spacePoints;
}

getSpacePointsInEvent() [2/3]

std::vector< const Trk::SpacePoint * > InDet::SiSPGNNTrackMaker::getSpacePointsInEvent ( const EventContext & ctx, const SG::ReadHandleKey< SpacePointOverlapCollection > & containerKey ) const

protected

Definition at line 335 of file SiSPGNNTrackMaker.cxx.

        {
 
  std::vector<const Trk::SpacePoint*> spacePoints;
 
  if (not containerKey.empty()){
 
    SG::ReadHandle<SpacePointOverlapCollection> collection{containerKey, ctx};
 
    if (collection.isValid()){
      for (const Trk::SpacePoint *sp : *collection) {
        spacePoints.push_back(sp);
      }
    }
  }
 
  return spacePoints;
}

getSpacePointsInEvent() [3/3]

std::vector< const Trk::SpacePoint * > InDet::SiSPGNNTrackMaker::getSpacePointsInEvent ( const EventContext & ctx, int eventNumber ) const

protected

Definition at line 279 of file SiSPGNNTrackMaker.cxx.

        {
  std::vector<const Trk::SpacePoint*> spacePoints;
 
  int npixsp(0), nstrip(0), n_overlap(0);
  for (const Trk::SpacePoint* sp : getSpacePointsInEvent(ctx, m_SpacePointsPixelKey)) {
    spacePoints.push_back(sp);
    npixsp++;
  }
  for (const Trk::SpacePoint* sp : getSpacePointsInEvent(ctx, m_SpacePointsSCTKey)) {
    spacePoints.push_back(sp);
    nstrip++;
  }
  for (const Trk::SpacePoint* sp : getSpacePointsInEvent(ctx, m_SpacePointsOverlapKey)) {
    spacePoints.push_back(sp);
    n_overlap++;
  }
  ATH_MSG_DEBUG("Event " << eventNumber << " has " << npixsp
                         << " pixel space points, " << nstrip 
                         << " strips space points, " << n_overlap
                         << " overlapping spacepoints, " << spacePoints.size()
                          << " space points");
 
  return spacePoints;
}

initialize()

StatusCode InDet::SiSPGNNTrackMaker::initialize ( )

overridevirtual

Definition at line 23 of file SiSPGNNTrackMaker.cxx.

{
  ATH_CHECK(m_SpacePointsPixelKey.initialize());
  ATH_CHECK(m_SpacePointsSCTKey.initialize());
  ATH_CHECK(m_SpacePointsOverlapKey.initialize());
  ATH_CHECK(m_ClusterPixelKey.initialize());
  ATH_CHECK(m_ClusterStripKey.initialize());
 
  ATH_CHECK(m_outputTracksKey.initialize());
  ATH_CHECK(m_outputEdgeScoresKey.initialize());
 
  ATH_CHECK(m_trackFitter.retrieve());
  ATH_CHECK(m_seedFitter.retrieve());
  ATH_CHECK(m_trackSummaryTool.retrieve());
 
  if (!m_gnnTrackFinder.empty() && !m_gnnTrackReader.empty()) {
    ATH_MSG_ERROR("Use either track finder or track reader, not both.");
    return StatusCode::FAILURE;
  }
 
  if (!m_gnnTrackFinder.empty()) {
    ATH_MSG_INFO("Use GNN Track Finder");
    ATH_CHECK(m_gnnTrackFinder.retrieve());
  }
  if (!m_gnnTrackReader.empty()) {
    ATH_MSG_INFO("Use GNN Track Reader");
    ATH_CHECK(m_gnnTrackReader.retrieve());
  }
  if (m_areInputClusters) {
    ATH_MSG_INFO("Use input clusters");
  }
  // retrieve eta dependent cut svc
  ATH_CHECK(m_etaDependentCutsSvc.retrieve());
 
  ATH_MSG_INFO("Applying the following cuts during GNN-based track reconstruction: ");
  ATH_MSG_INFO("Min pT: " << m_pTmin);
  ATH_MSG_INFO("Max eta: " << m_etamax);
  ATH_MSG_INFO("Min number of clusters: " << m_minClusters);
  ATH_MSG_INFO("Min number of pixel clusters: " << m_minPixelClusters);
  ATH_MSG_INFO("Min number of strip clusters: " << m_minStripClusters);
 
 
  if (m_doRecoTrackCuts) {
    ATH_MSG_INFO("Applying the following eta dependant track cuts after GNN-based track reconstruction: ");
    std::vector <double> etaBins, minPT, maxz0, maxd0;
    std::vector <int> minClusters, minPixelHits, maxHoles;
    m_etaDependentCutsSvc->getValue(InDet::CutName::etaBins, etaBins);
    ATH_MSG_INFO("Eta bins: " << etaBins );
    m_etaDependentCutsSvc->getValue(InDet::CutName::minClusters, minClusters);
    ATH_MSG_INFO("Min Si Hits: " << minClusters );
    m_etaDependentCutsSvc->getValue(InDet::CutName::minPixelHits, minPixelHits);
    ATH_MSG_INFO("Min pixel hits: " << minPixelHits );
    m_etaDependentCutsSvc->getValue(InDet::CutName::maxHoles, maxHoles);
    ATH_MSG_INFO("Max holes: " << maxHoles);
    m_etaDependentCutsSvc->getValue(InDet::CutName::minPT, minPT);
    ATH_MSG_INFO("Min pT: " << minPT);
    m_etaDependentCutsSvc->getValue(InDet::CutName::maxZImpact, maxz0);
    ATH_MSG_INFO("Max z0: " << maxz0);
    m_etaDependentCutsSvc->getValue(InDet::CutName::maxPrimaryImpact, maxd0);
    ATH_MSG_INFO("Max d0: " << maxd0);
  }
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

isClonable()

virtual bool InDet::SiSPGNNTrackMaker::isClonable ( ) const

inlineoverridevirtual

Make this algorithm clonable.

Reimplemented from AthCommonReentrantAlgorithm< Gaudi::Algorithm >.

Definition at line 49 of file SiSPGNNTrackMaker.h.

{ return true; };

msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< Gaudi::Algorithm >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

passEtaDepCuts()

int InDet::SiSPGNNTrackMaker::passEtaDepCuts ( const Trk::Track & track ) const

protected

Definition at line 230 of file SiSPGNNTrackMaker.cxx.

{
  const Trk::Perigee* origPerigee = track.perigeeParameters();
  double pt = origPerigee->pT();
 
  double eta = std::abs(origPerigee->eta());
 
  double d0 = std::abs(origPerigee->parameters()[Trk::d0]);
 
  double z0 = std::abs(origPerigee->parameters()[Trk::z0]);
 
  int nHolesOnTrack = track.trackSummary()->get(Trk::numberOfPixelHoles) +
                      track.trackSummary()->get(Trk::numberOfSCTHoles);
 
  int nPixels = track.trackSummary()->get(Trk::numberOfPixelHits);
  int nStrips = track.trackSummary()->get(Trk::numberOfSCTHits);
  int nClusters = nPixels + nStrips;
 
  ATH_MSG_DEBUG("track params: (pt,eta,d0,z0)=(" << pt << "," << eta << "," << d0 << "," << z0
                                 << ") Nclusters:" << nClusters << " pixel "<< nPixels
                                 << " strips " << nStrips);
 
  // min Si hits
  if (nClusters < m_etaDependentCutsSvc->getMinSiHitsAtEta(eta))
    return 1;
 
  // min pixel hits
  if (nPixels < m_etaDependentCutsSvc->getMinPixelHitsAtEta(eta))
    return 2;
 
  // min pT, default 400
  if (pt < m_etaDependentCutsSvc->getMinPtAtEta(eta))
    return 3;
 
  // max z0
  if (z0 > m_etaDependentCutsSvc->getMaxZImpactAtEta(eta))
    return 4;
 
  // max d0
  if (d0 > m_etaDependentCutsSvc->getMaxPrimaryImpactAtEta(eta))
    return 5;
 
  // max holes
  if (nHolesOnTrack > m_etaDependentCutsSvc->getMaxSiHolesAtEta(eta))
    return 6;
 
  return 0;
}

prefitCheck()

bool InDet::SiSPGNNTrackMaker::prefitCheck ( unsigned int nPix, unsigned int nStrip, unsigned int nClusters, unsigned int nSpacePoints ) const

protected

Definition at line 225 of file SiSPGNNTrackMaker.cxx.

                                                                                                                                        {
  return nPix >= m_minPixelClusters && nStrip >= m_minStripClusters && nClusters >= m_minClusters && nSpacePoints >= 3;
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state, const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

spacePointsToClusters()

std::vector< const Trk::PrepRawData * > InDet::SiSPGNNTrackMaker::spacePointsToClusters ( const std::vector< const Trk::SpacePoint * > & spacePoints ) const

protected

Definition at line 467 of file SiSPGNNTrackMaker.cxx.

        {
  std::vector<const Trk::PrepRawData*> clusters;
  for (const Trk::SpacePoint* sp : spacePoints) {
    clusters.push_back(sp->clusterList().first);
    if (sp->clusterList().second != nullptr) {
      clusters.push_back(sp->clusterList().second);
    }
  }
  return clusters;
}

sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize ( )

overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_areInputClusters

BooleanProperty InDet::SiSPGNNTrackMaker::m_areInputClusters

protected

Initial value:

{
          this, "areInputClusters", false,
          "Read track candidates as list of clusters"}

Definition at line 108 of file SiSPGNNTrackMaker.h.

                                        {
          this, "areInputClusters", false,
          "Read track candidates as list of clusters"};

m_ClusterPixelKey

SG::ReadHandleKey<InDet::PixelClusterContainer> InDet::SiSPGNNTrackMaker::m_ClusterPixelKey

protected

Initial value:

{
          this, "PixelClusterContainer", "ITkPixelClusters"}

Definition at line 67 of file SiSPGNNTrackMaker.h.

                                                                   {
          this, "PixelClusterContainer", "ITkPixelClusters"};

m_ClusterStripKey

SG::ReadHandleKey<InDet::SCT_ClusterContainer> InDet::SiSPGNNTrackMaker::m_ClusterStripKey

protected

Initial value:

{
          this, "StripClusterContainer", "ITkStripClusters"}

Definition at line 69 of file SiSPGNNTrackMaker.h.

                                                                  {
          this, "StripClusterContainer", "ITkStripClusters"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_doRecoTrackCuts

BooleanProperty InDet::SiSPGNNTrackMaker::m_doRecoTrackCuts

protected

Initial value:

{this, "doRecoTrackCuts", false,
                                      "Apply Loose track cuts"}

Definition at line 111 of file SiSPGNNTrackMaker.h.

                                       {this, "doRecoTrackCuts", false,
                                      "Apply Loose track cuts"};

m_doRecoverFailedFits

BooleanProperty InDet::SiSPGNNTrackMaker::m_doRecoverFailedFits

protected

Initial value:

{this, "doRecoverFailedFits", true,
    "Try to recover failed track fits by removing hits, at the end of the track"}

Definition at line 125 of file SiSPGNNTrackMaker.h.

                                           {this, "doRecoverFailedFits", true,
    "Try to recover failed track fits by removing hits, at the end of the track"};

m_etaDependentCutsSvc

ServiceHandle<IInDetEtaDependentCutsSvc> InDet::SiSPGNNTrackMaker::m_etaDependentCutsSvc

protected

Initial value:

{
          this, "InDetEtaDependentCutsSvc", "InDetEtaDependentCutsSvc"}

Definition at line 114 of file SiSPGNNTrackMaker.h.

                                                                    {
          this, "InDetEtaDependentCutsSvc", "InDetEtaDependentCutsSvc"};

m_etamax

DoubleProperty InDet::SiSPGNNTrackMaker::m_etamax {this, "etamax", 4., "max reco eta"}

protected

Definition at line 121 of file SiSPGNNTrackMaker.h.

{this, "etamax", 4., "max reco eta"};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

m_gnnTrackFinder

ToolHandle<IGNNTrackFinder> InDet::SiSPGNNTrackMaker::m_gnnTrackFinder

protected

Initial value:

{
        this, "GNNTrackFinderTool", 
        "InDet::SiGNNTrackFinderTool", "Track Finder"
      }

GNN-based track finding tool that produces track candidates.

---

@name Tool handles

Definition at line 85 of file SiSPGNNTrackMaker.h.

                                                  {
        this, "GNNTrackFinderTool", 
        "InDet::SiGNNTrackFinderTool", "Track Finder"
      };

m_gnnTrackReader

ToolHandle<IGNNTrackReaderTool> InDet::SiSPGNNTrackMaker::m_gnnTrackReader

protected

Initial value:

{
        this, "GNNTrackReaderTool",
        "InDet::GNNTrackReaderTool", "Track Reader"
      }

Definition at line 100 of file SiSPGNNTrackMaker.h.

                                                      {
        this, "GNNTrackReaderTool",
        "InDet::GNNTrackReaderTool", "Track Reader"
      };

m_minClusters

UnsignedIntegerProperty InDet::SiSPGNNTrackMaker::m_minClusters {this, "minClusters", 6, "Min number clusters"}

protected

Definition at line 117 of file SiSPGNNTrackMaker.h.

{this, "minClusters", 6, "Min number clusters"};

m_minPixelClusters

UnsignedIntegerProperty InDet::SiSPGNNTrackMaker::m_minPixelClusters {this, "minPixelClusters", 1, "min pixel clusters"}

protected

Definition at line 118 of file SiSPGNNTrackMaker.h.

{this, "minPixelClusters", 1, "min pixel clusters"};

m_minStripClusters

UnsignedIntegerProperty InDet::SiSPGNNTrackMaker::m_minStripClusters {this, "minStripClusters", 0, "Minimum number of strip clusters"}

protected

Definition at line 119 of file SiSPGNNTrackMaker.h.

{this, "minStripClusters", 0, "Minimum number of strip clusters"};

m_outputEdgeScoresKey

SG::WriteHandleKey<std::vector<std::vector<float> > > InDet::SiSPGNNTrackMaker::m_outputEdgeScoresKey

protected

Initial value:

{
        this, "EdgeScoresKey", "GNNEdgeScores"}

Definition at line 77 of file SiSPGNNTrackMaker.h.

                                                                         {
        this, "EdgeScoresKey", "GNNEdgeScores"};

m_outputTracksKey

SG::WriteHandleKey<TrackCollection> InDet::SiSPGNNTrackMaker::m_outputTracksKey

protected

Initial value:

{
        this, "TracksLocation", "SiSPGNNTracks"}

Definition at line 73 of file SiSPGNNTrackMaker.h.

                                                         {
        this, "TracksLocation", "SiSPGNNTracks"};

m_pTmin

DoubleProperty InDet::SiSPGNNTrackMaker::m_pTmin {this, "pTmin", 400., "min pT"}

protected

Definition at line 120 of file SiSPGNNTrackMaker.h.

{this, "pTmin", 400., "min pT"};

m_saveEdgeScore

BooleanProperty InDet::SiSPGNNTrackMaker::m_saveEdgeScore {this, "saveEdgeScore", false, "Save edge scores in a temporary container"}

protected

Definition at line 128 of file SiSPGNNTrackMaker.h.

{this, "saveEdgeScore", false, "Save edge scores in a temporary container"};

m_seedFitter

ToolHandle<ISeedFitter> InDet::SiSPGNNTrackMaker::m_seedFitter

protected

Initial value:

{
        this, "SeedFitterTool",
        "InDet::SiSeedFitterTool", "Seed Fitter"
      }

Definition at line 89 of file SiSPGNNTrackMaker.h.

                                          {
        this, "SeedFitterTool",
        "InDet::SiSeedFitterTool", "Seed Fitter"
      };

m_SpacePointsOverlapKey

SG::ReadHandleKey<SpacePointOverlapCollection> InDet::SiSPGNNTrackMaker::m_SpacePointsOverlapKey {this, "SpacePointsOverlapName", "ITkOverlapSpacePoints"}

protected

Definition at line 65 of file SiSPGNNTrackMaker.h.

{this, "SpacePointsOverlapName", "ITkOverlapSpacePoints"};

m_SpacePointsPixelKey

SG::ReadHandleKey<SpacePointContainer> InDet::SiSPGNNTrackMaker::m_SpacePointsPixelKey

protected

Initial value:

{
        this, "SpacePointsPixelName", "ITkPixelSpacePoints"}

---

@name Data handles

Definition at line 61 of file SiSPGNNTrackMaker.h.

                                                                {
        this, "SpacePointsPixelName", "ITkPixelSpacePoints"};

m_SpacePointsSCTKey

SG::ReadHandleKey<SpacePointContainer> InDet::SiSPGNNTrackMaker::m_SpacePointsSCTKey

protected

Initial value:

{
        this, "SpacePointsSCTName", "ITkStripSpacePoints"}

Definition at line 63 of file SiSPGNNTrackMaker.h.

                                                              {
        this, "SpacePointsSCTName", "ITkStripSpacePoints"};

m_trackFitter

ToolHandle<Trk::ITrackFitter> InDet::SiSPGNNTrackMaker::m_trackFitter

protected

Initial value:

{
        this, "TrackFitter", 
        "Trk::GlobalChi2Fitter/InDetTrackFitter", "Track Fitter"
      }

Track Fitter.

Definition at line 94 of file SiSPGNNTrackMaker.h.

                                                {
        this, "TrackFitter", 
        "Trk::GlobalChi2Fitter/InDetTrackFitter", "Track Fitter"
      };

m_trackSummaryTool

ToolHandle<Trk::IExtendedTrackSummaryTool> InDet::SiSPGNNTrackMaker::m_trackSummaryTool

protected

Initial value:

{
      this, "TrackSummaryTool", "InDetTrackSummaryTool"}

Definition at line 98 of file SiSPGNNTrackMaker.h.

                                                                 {
      this, "TrackSummaryTool", "InDetTrackSummaryTool"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• SiSPGNNTrackMaker.h
• SiSPGNNTrackMaker.cxx