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

MsgStream &	dump (MsgStream &out) const

std::ostream &	dump (std::ostream &out) const

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

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

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T > &t)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) 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. More...

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::vector< const Trk::SpacePoint * >	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

void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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

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

ToolHandle< IGNNTrackFinder >	m_gnnTrackFinder
	GNN-based track finding tool that produces track candidates. More...

ToolHandle< ISeedFitter >	m_seedFitter

ToolHandle< Trk::ITrackFitter >	m_trackFitter
	Track Fitter. More...

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Private Attributes
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

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 43 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 13 of file SiSPGNNTrackMaker.cxx.

   : AthReentrantAlgorithm(name, pSvcLocator)
 {
   
 }

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality

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() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	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());
  
   }

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(name, property, doc);
   }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

   {
     typedef typename SG::HandleClassifier<T>::type htype;
     return declareProperty (name, property, doc, htype());
   }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T > & 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.

95 { 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:

Fits the track using the provided clusters and initial parameters
Checks basic kinematic cuts (pT, eta)
Computes track summary (hits, holes)
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 466 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(
         *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 621 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 651 of file SiSPGNNTrackMaker.cxx.

 {
   return out;
 }

◆ dumpevent()

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

protected

Definition at line 646 of file SiSPGNNTrackMaker.cxx.

 {
   return out;
 }

◆ dumptools()

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

protected

Definition at line 632 of file SiSPGNNTrackMaker.cxx.

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

◆ evtStore() [1/2]

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.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

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

overridevirtual

Definition at line 84 of file SiSPGNNTrackMaker.cxx.

 { 
   SG::WriteHandle<TrackCollection> outputTracks{m_outputTracksKey, ctx};
   ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
  
   // 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;
   if (m_gnnTrackFinder.isSet()) {
     ATH_CHECK(m_gnnTrackFinder->getTracks(spacePoints, TT));
   } 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
     std::vector<const Trk::SpacePoint*> trackCandidate = getSpacePoints(trackIndices, spacePoints);
  
     // 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());
     }
  
     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

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 533 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 415 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 298 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;
 }

◆ getSpacePoints()

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

protected

Definition at line 358 of file SiSPGNNTrackMaker.cxx.

         {
  
   std::vector<const Trk::SpacePoint*> trackCandidate;
   trackCandidate.reserve(trackIndices.size());
  
   std::vector<std::pair<double, const Trk::SpacePoint*> > 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_pair(
           pow(sp->globalPosition().x(), 2) + pow(sp->globalPosition().y(), 2),
           sp
         )
       );
     }
   }
  
   // 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(distanceSortedSPs[i].second);
   }
  
   return trackCandidate;
 }

◆ getSpacePointsInEvent() [1/3]

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

protected

Definition at line 249 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 277 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 221 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 20 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_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() [1/2]

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

inlineoverridevirtual

Make this algorithm clonable.

Definition at line 50 of file SiSPGNNTrackMaker.h.

50 { return true; };

◆ isClonable() [2/2]

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

 {
   // Reentrant algorithms are clonable.
   return true;
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ 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 172 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
                                  << " " << nClusters << nStrips
                                  << " " << nPixels);
  
   // 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 167 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 402 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 InputMakerBase, and HypoBase.

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 105 of file SiSPGNNTrackMaker.h.

◆ m_ClusterPixelKey

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

protected

Initial value:

{

this, "PixelClusterContainer", "ITkPixelClusters"}

Definition at line 68 of file SiSPGNNTrackMaker.h.

◆ m_ClusterStripKey

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

protected

Initial value:

{

this, "StripClusterContainer", "ITkStripClusters"}

Definition at line 70 of file SiSPGNNTrackMaker.h.

◆ 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 108 of file SiSPGNNTrackMaker.h.

◆ 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 122 of file SiSPGNNTrackMaker.h.

◆ m_etaDependentCutsSvc

ServiceHandle<IInDetEtaDependentCutsSvc> InDet::SiSPGNNTrackMaker::m_etaDependentCutsSvc

protected

Initial value:

{

this, "InDetEtaDependentCutsSvc", "InDetEtaDependentCutsSvc"}

Definition at line 111 of file SiSPGNNTrackMaker.h.

◆ m_etamax

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

protected

Definition at line 118 of file SiSPGNNTrackMaker.h.

◆ 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 82 of file SiSPGNNTrackMaker.h.

◆ m_gnnTrackReader

ToolHandle<IGNNTrackReaderTool> InDet::SiSPGNNTrackMaker::m_gnnTrackReader

protected

Initial value:

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

Definition at line 97 of file SiSPGNNTrackMaker.h.

◆ m_minClusters

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

protected

Definition at line 114 of file SiSPGNNTrackMaker.h.

◆ m_minPixelClusters

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

protected

Definition at line 115 of file SiSPGNNTrackMaker.h.

◆ m_minStripClusters

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

protected

Definition at line 116 of file SiSPGNNTrackMaker.h.

◆ m_outputTracksKey

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

protected

Initial value:

{

this, "TracksLocation", "SiSPGNNTracks"}

Definition at line 74 of file SiSPGNNTrackMaker.h.

◆ m_pTmin

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

protected

Definition at line 117 of file SiSPGNNTrackMaker.h.

◆ m_seedFitter

ToolHandle<ISeedFitter> InDet::SiSPGNNTrackMaker::m_seedFitter

protected

Initial value:

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

Definition at line 86 of file SiSPGNNTrackMaker.h.

◆ m_SpacePointsOverlapKey

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

protected

Definition at line 66 of file SiSPGNNTrackMaker.h.

◆ m_SpacePointsPixelKey

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

protected

Initial value:

{

this, "SpacePointsPixelName", "ITkPixelSpacePoints"}

@name Data handles

Definition at line 62 of file SiSPGNNTrackMaker.h.

◆ m_SpacePointsSCTKey

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

protected

Initial value:

{

this, "SpacePointsSCTName", "ITkStripSpacePoints"}

Definition at line 64 of file SiSPGNNTrackMaker.h.

◆ m_trackFitter

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

protected

Initial value:

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

Track Fitter.

Definition at line 91 of file SiSPGNNTrackMaker.h.

◆ m_trackSummaryTool

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

protected

Initial value:

{

this, "TrackSummaryTool", "InDetTrackSummaryTool"}

Definition at line 95 of file SiSPGNNTrackMaker.h.

◆ 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:

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ SiSPGNNTrackMaker()

Member Function Documentation

◆ cardinality()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ doFitAndCut()

◆ dump() [1/2]

◆ dump() [2/2]

◆ dumpevent()

◆ dumptools()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ fitTrack()

◆ getClusters()

◆ getClustersInEvent()

◆ getSpacePoints()

◆ getSpacePointsInEvent() [1/3]

◆ getSpacePointsInEvent() [2/3]

◆ getSpacePointsInEvent() [3/3]

◆ initialize()

◆ inputHandles()

◆ isClonable() [1/2]

◆ isClonable() [2/2]

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ passEtaDepCuts()

◆ prefitCheck()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ spacePointsToClusters()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_areInputClusters

◆ m_ClusterPixelKey

◆ m_ClusterStripKey

◆ m_detStore

◆ m_doRecoTrackCuts

◆ m_doRecoverFailedFits

◆ m_etaDependentCutsSvc

◆ m_etamax

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_gnnTrackFinder

@name Tool handles

◆ m_gnnTrackReader

◆ m_minClusters

◆ m_minPixelClusters

◆ m_minStripClusters

◆ m_outputTracksKey

◆ m_pTmin

◆ m_seedFitter