ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
FPGATrackSim::FPGATrackSimReportingAlg Class Reference

#include <FPGATrackSimReportingAlg.h>

Inheritance diagram for FPGATrackSim::FPGATrackSimReportingAlg:
Collaboration diagram for FPGATrackSim::FPGATrackSimReportingAlg:

Public Member Functions

 FPGATrackSimReportingAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~FPGATrackSimReportingAlg ()=default
 
virtual StatusCode initialize () override final
 
virtual StatusCode execute (const EventContext &ctx) const override final
 
virtual StatusCode finalize () override final
 
template<>
void printxAODClusters (SG::ReadHandle< DataVector< xAOD::PixelCluster >> &clusterContainer) const
 
template<>
void printxAODClusters (SG::ReadHandle< DataVector< xAOD::StripCluster >> &clusterContainer) 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, V, H > &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

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

template<class XAOD_CLUSTER >
void processxAODClusters (SG::ReadHandle< DataVector< XAOD_CLUSTER >> &clusterContainer) const
 
template<class XAOD_CLUSTER >
void printxAODClusters (SG::ReadHandle< DataVector< XAOD_CLUSTER >> &clusterContainer) const
 
void processxAODSpacePoints (SG::ReadHandle< DataVector< xAOD::SpacePoint >> &spContainer) const
 
void printxAODSpacePoints (SG::ReadHandle< DataVector< xAOD::SpacePoint >> &spContainer) const
 
void processFPGAClusters (SG::ReadHandle< FPGATrackSimClusterCollection > &FPGAClusters) const
 
void printFPGAClusters (SG::ReadHandle< FPGATrackSimClusterCollection > &FPGAClusters) const
 
void processFPGARoads (SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
 
void printFPGARoads (SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
 
void processFPGATracks (SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
 
void printFPGATracks (SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
 
void processFPGASeeds (SG::ReadHandle< ActsTrk::SeedContainer > &FPGASeeds) const
 
void printFPGASeeds (SG::ReadHandle< ActsTrk::SeedContainer > &FPGASeeds) const
 
void processFPGASeedsParam (SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
 
void printFPGASeedsParam (SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
 
void processFPGAPrototracks (SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
 
void printFPGAPrototracks (SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
 
void processActsTracks (SG::ReadHandle< ActsTrk::TrackContainer > &ActsTracks) const
 
StatusCode summaryReportForEDMConversion ()
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::vector< uint32_t > m_pixelClustersPerFPGATrack ATLAS_THREAD_SAFE
 
std::vector< uint32_t > m_pixelClustersPerFPGATrack m_stripClustersPerFPGATrack ATLAS_THREAD_SAFE
 
std::vector< uint32_t > m_pixelClustersPerPrototrack ATLAS_THREAD_SAFE
 
std::vector< uint32_t > m_pixelClustersPerPrototrack m_stripClustersPerPrototrack ATLAS_THREAD_SAFE
 
std::map< std::string, std::vector< FPGATrackSimActsEventTracks > > m_allActsTracks ATLAS_THREAD_SAFE
 
std::map< std::string, std::map< uint32_t, std::vector< uint32_t > > > m_actsTrackStats ATLAS_THREAD_SAFE
 
Gaudi::Property< bool > m_printoutForEveryEvent {this, "perEventReports", false, "A flag to enable per event printout"}
 
Gaudi::Property< bool > m_isDataPrep {this, "isDataPrep", false, "If True, this is for data prep pipeline only"}
 
SG::ReadHandleKeyArray< xAOD::PixelClusterContainer > m_xAODPixelClusterContainerKeys
 
SG::ReadHandleKeyArray< xAOD::StripClusterContainer > m_xAODStripClusterContainerKeys
 
SG::ReadHandleKeyArray< xAOD::SpacePointContainer > m_xAODSpacePointContainerKeys
 
SG::ReadHandleKey< FPGATrackSimRoadCollection > m_FPGARoadsKey { this, "FPGATrackSimRoads","","FPGATrackSim Roads key" }
 
SG::ReadHandleKey< FPGATrackSimTrackCollection > m_FPGATracksKey { this, "FPGATrackSimTracks","","FPGATrackSim Tracks key" }
 
SG::ReadHandleKeyArray< ActsTrk::ProtoTrackCollection > m_FPGAProtoTrackCollections {this, "FPGATrackSimProtoTracks",{},"FPGATrackSim PrototrackCollection"}
 
SG::ReadHandleKeyArray< ActsTrk::TrackContainer > m_ActsTrackCollections {this, "FPGAActsTracks",{},"Acts track collections from (C)KF"}
 
SG::ReadHandleKeyArray< ActsTrk::SeedContainer > m_ActsSeedCollections {this, "FPGAActsSeeds",{},"Acts Seeds collections from (C)KF"}
 
SG::ReadHandleKeyArray< ActsTrk::BoundTrackParametersContainer > m_ActsSeedParamCollections {this, "FPGAActsSeedsParam",{},"Acts Seeds param collections from (C)KF"}
 
ToolHandle< FPGATrackSim::ActsTrackInspectionTool > m_ActsInspectionTool {this, "ActsInspectionTool", "FPGATrackSim::ActsTrackInspectionTool/ActsTrackInspectionTool", "Monitoring tool for acts tracks"}
 
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

Definition at line 30 of file FPGATrackSimReportingAlg.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

◆ FPGATrackSimReportingAlg()

FPGATrackSim::FPGATrackSimReportingAlg::FPGATrackSimReportingAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 8 of file FPGATrackSimReportingAlg.cxx.

8  : AthReentrantAlgorithm(name, pSvcLocator) {
9 }

◆ ~FPGATrackSimReportingAlg()

virtual FPGATrackSim::FPGATrackSimReportingAlg::~FPGATrackSimReportingAlg ( )
virtualdefault

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.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

200  {
201  return PBASE::declareProperty(t);
202  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

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

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ 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; }

◆ 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 FPGATrackSim::FPGATrackSimReportingAlg::execute ( const EventContext &  ctx) const
finaloverridevirtual

Definition at line 27 of file FPGATrackSimReportingAlg.cxx.

28 {
29  // Process xAOD Pixel Clusters
30  std::vector<SG::ReadHandle<xAOD::PixelClusterContainer>> xAODPixelClusterContainers = m_xAODPixelClusterContainerKeys.makeHandles(ctx);
31  for (SG::ReadHandle<xAOD::PixelClusterContainer>& clusterContainer : xAODPixelClusterContainers)
32  {
33  if (!clusterContainer.isValid()) {
34  ATH_MSG_WARNING("SG key not available " << clusterContainer.key());
35  continue;
36  }
37  processxAODClusters<xAOD::PixelCluster>(clusterContainer);
38  }
39  // Process xAOD Strip Clusters
40  std::vector<SG::ReadHandle<xAOD::StripClusterContainer>> xAODStripClusterContainers = m_xAODStripClusterContainerKeys.makeHandles(ctx);
41  for (SG::ReadHandle<xAOD::StripClusterContainer>& clusterContainer : xAODStripClusterContainers)
42  {
43  if (!clusterContainer.isValid()) {
44  ATH_MSG_WARNING("SG key not available " << clusterContainer.key());
45  continue;
46  }
47  processxAODClusters<xAOD::StripCluster>(clusterContainer);
48  }
49  // Process xAOD SpacePoints
50  std::vector<SG::ReadHandle<xAOD::SpacePointContainer>> xAODSpacePointContainers = m_xAODSpacePointContainerKeys.makeHandles(ctx);
51  for (SG::ReadHandle<xAOD::SpacePointContainer>& spContainer : xAODSpacePointContainers)
52  {
53  if (!spContainer.isValid()) {
54  ATH_MSG_WARNING("SG key not available " << spContainer.key());
55  }
56  else {processxAODSpacePoints(spContainer);}
57  }
58  if (!m_isDataPrep.value()) {
59  // Process FPGATrackSim Roads
60  SG::ReadHandle<FPGATrackSimRoadCollection> FPGATrackSimRoads(m_FPGARoadsKey, ctx);
61  if (FPGATrackSimRoads.isValid()) {
62  processFPGARoads(FPGATrackSimRoads);
63  }
64  else ATH_MSG_WARNING("Could not find FPGA Roads Collection with key " << FPGATrackSimRoads.key());
65 
66 
67  // Process FPGATrackSim Tracks
68  SG::ReadHandle<FPGATrackSimTrackCollection> FPGATrackSimTracks(m_FPGATracksKey, ctx);
69  if (FPGATrackSimTracks.isValid()) {
70  processFPGATracks(FPGATrackSimTracks);
71  }
72  else ATH_MSG_WARNING("Could not find FPGA Track Collection with key " << FPGATrackSimTracks.key());
73 
74  // Process FPGATrackSim Prototracks
75  std::vector<SG::ReadHandle<ActsTrk::ProtoTrackCollection>> FPGATrackSimProtoTracks = m_FPGAProtoTrackCollections.makeHandles(ctx);
76  for (SG::ReadHandle<ActsTrk::ProtoTrackCollection>& prototrackContainer : FPGATrackSimProtoTracks)
77  {
78  if (!prototrackContainer.isValid()) {
79  ATH_MSG_WARNING("SG key not available " << prototrackContainer.key());
80  continue;
81  }
82  processFPGAPrototracks(prototrackContainer);
83  }
84  } // if it's not the data preparation chain
85  // Process Acts tracks
86  std::vector<SG::ReadHandle<ActsTrk::TrackContainer>> FPGAActsTracks = m_ActsTrackCollections.makeHandles(ctx);
87  for (SG::ReadHandle<ActsTrk::TrackContainer>& actsTrackContainer : FPGAActsTracks)
88  {
89  if (actsTrackContainer.cptr()) ATH_MSG_DEBUG("Proccessing " << actsTrackContainer.key());
90  else continue;
91  // initialize the ReadHandle pair if necessarys
92  m_allActsTracks.try_emplace(actsTrackContainer.key(), std::vector<FPGATrackSimActsEventTracks>{});
93 
94  // fetch acts tracks
95  m_allActsTracks[actsTrackContainer.key()].push_back(m_ActsInspectionTool->getActsTracks(*(actsTrackContainer.cptr())));
96 
97  // initialize ReadHandle stats map for all tracks if necessary
98  m_actsTrackStats.try_emplace(actsTrackContainer.key(), std::map<uint32_t, std::vector<uint32_t>>{});
99 
100  m_actsTrackStats[actsTrackContainer.key()].emplace(
101  Acts::TrackStateFlag::OutlierFlag, std::vector<uint32_t>{});
102  m_actsTrackStats[actsTrackContainer.key()].emplace(
103  Acts::TrackStateFlag::HoleFlag, std::vector<uint32_t>{});
104  m_actsTrackStats[actsTrackContainer.key()].emplace(
105  Acts::TrackStateFlag::MeasurementFlag, std::vector<uint32_t>{});
106 
107  for (const auto& track : m_allActsTracks[actsTrackContainer.key()].back()) {
108  uint32_t t_nOutliers = 0, t_nMeasurements = 0, t_nHoles = 0;
109  for (const auto& measurement : track->trackMeasurements)
110  {
111  if (measurement->outlierFlag) ++t_nOutliers;
112  if (measurement->measurementFlag) ++t_nMeasurements;
113  if (measurement->holeFlag) ++t_nHoles;
114  }
115  m_actsTrackStats[actsTrackContainer.key()][Acts::TrackStateFlag::OutlierFlag].push_back(t_nOutliers);
116  m_actsTrackStats[actsTrackContainer.key()][Acts::TrackStateFlag::HoleFlag].push_back(t_nHoles);
117  m_actsTrackStats[actsTrackContainer.key()][Acts::TrackStateFlag::MeasurementFlag].push_back(t_nMeasurements);
118  }
119  if (m_printoutForEveryEvent) ATH_MSG_INFO("ACTS tracks in " << actsTrackContainer.key() << m_ActsInspectionTool->getPrintoutActsEventTracks(m_allActsTracks[actsTrackContainer.key()].back()));
120  }
121 
122  std::vector<SG::ReadHandle<ActsTrk::SeedContainer>> FPGAActsSeeds = m_ActsSeedCollections.makeHandles(ctx);
123 
124  for (SG::ReadHandle<ActsTrk::SeedContainer>& actsTrackContainer : FPGAActsSeeds)
125  {
126  if (!actsTrackContainer.isValid()) {
127  ATH_MSG_WARNING("SG key not available " << actsTrackContainer.key());
128  continue;
129  }
130  processFPGASeeds(actsTrackContainer);
131  }
132 
133 
134  std::vector<SG::ReadHandle<ActsTrk::BoundTrackParametersContainer>> FPGAActsSeedsParam = m_ActsSeedParamCollections.makeHandles(ctx);
135 
136  for (SG::ReadHandle<ActsTrk::BoundTrackParametersContainer>& actsTrackContainer : FPGAActsSeedsParam)
137  {
138  if (!actsTrackContainer.isValid()) {
139  ATH_MSG_WARNING("SG key not available " << actsTrackContainer.key());
140  continue;
141  }
142  processFPGASeedsParam(actsTrackContainer);
143  }
144 
145  return StatusCode::SUCCESS;
146 }

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

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

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ finalize()

StatusCode FPGATrackSim::FPGATrackSimReportingAlg::finalize ( )
finaloverridevirtual

Definition at line 148 of file FPGATrackSimReportingAlg.cxx.

149 {
150  ATH_MSG_INFO("Printing statistics for FPGA objects");
151 
152  if (!m_isDataPrep.value()) {
153  // Printing summary for clusters/FPGATracks
154  std::string summaryTableFPGATracks = "\n"
155  "Number of measurements for FPGA Tracks\n"
156  "|-----------------------------------|\n"
157  "| | min | max | Avg |\n"
158  "|-----------------------------------|\n";
159 
160  if (not m_pixelClustersPerFPGATrack.empty()) {
161  summaryTableFPGATracks += std::format("| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
162  *std::min_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
163  *std::max_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
164  std::accumulate(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end(), 0.0) / m_pixelClustersPerFPGATrack.size());
165  }
166  else summaryTableFPGATracks += std::format("| Pixels | ---- | ---- | inf |\n");
167 
168  if (not m_stripClustersPerFPGATrack.empty()) {
169  summaryTableFPGATracks += std::format("| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
170  *std::min_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
171  *std::max_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
172  std::accumulate(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end(), 0.0) / m_stripClustersPerFPGATrack.size());
173  }
174  else summaryTableFPGATracks += std::format("| Strips | ---- | ---- | inf |\n");
175 
176  summaryTableFPGATracks += "|-----------------------------------|";
177  ATH_MSG_INFO( summaryTableFPGATracks );
178 
179 
180  // Printing summary for clusters/prototracks
181  std::string summaryTableFPGAPrototracks = std::format("\n"
182  "Number of measurements for FPGA Prototracks\n"
183  "|-----------------------------------|\n"
184  "| | min | max | Avg |\n"
185  "|-----------------------------------|\n");
186 
187  if (not m_pixelClustersPerPrototrack.empty()) {
188  summaryTableFPGAPrototracks += std::format("| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
189  *std::min_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
190  *std::max_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
191  std::accumulate(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end(), 0.0) / m_pixelClustersPerPrototrack.size());
192  }
193  else summaryTableFPGAPrototracks += std::format("| Pixels | ---- | ---- | inf |\n");
194 
195  if (not m_stripClustersPerPrototrack.empty()) {
196  summaryTableFPGAPrototracks += std::format("| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
197  *std::min_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
198  *std::max_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
199  std::accumulate(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end(), 0.0) / m_stripClustersPerPrototrack.size());
200  }
201  else summaryTableFPGAPrototracks += std::format("| Strips | ---- | ---- | inf |\n");
202 
203  summaryTableFPGAPrototracks += "|-----------------------------------|";
204  ATH_MSG_INFO( summaryTableFPGAPrototracks );
205  }
206 
207  ATH_MSG_INFO(m_ActsInspectionTool->getPrintoutStatistics(m_actsTrackStats));
208  return StatusCode::SUCCESS;
209 }

◆ initialize()

StatusCode FPGATrackSim::FPGATrackSimReportingAlg::initialize ( )
finaloverridevirtual

Definition at line 11 of file FPGATrackSimReportingAlg.cxx.

12 {
13  ATH_CHECK(m_xAODPixelClusterContainerKeys.initialize());
14  ATH_CHECK(m_xAODStripClusterContainerKeys.initialize());
15  ATH_CHECK(m_xAODSpacePointContainerKeys.initialize());
16  ATH_CHECK(m_FPGARoadsKey.initialize(!m_isDataPrep));
17  ATH_CHECK(m_FPGAProtoTrackCollections.initialize(!m_isDataPrep));
18  ATH_CHECK(m_FPGATracksKey.initialize(!m_isDataPrep));
19  ATH_CHECK(m_ActsTrackCollections.initialize());
20  ATH_CHECK(m_ActsSeedCollections.initialize());
21  ATH_CHECK(m_ActsSeedParamCollections.initialize());
22 
23  ATH_CHECK(m_ActsInspectionTool.retrieve());
24  return StatusCode::SUCCESS;
25 }

◆ 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()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

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

◆ printFPGAClusters()

void FPGATrackSim::FPGATrackSimReportingAlg::printFPGAClusters ( SG::ReadHandle< FPGATrackSimClusterCollection > &  FPGAClusters) const
private

◆ printFPGAPrototracks()

void FPGATrackSim::FPGATrackSimReportingAlg::printFPGAPrototracks ( SG::ReadHandle< ActsTrk::ProtoTrackCollection > &  FPGAPrototracks) const
private

Definition at line 560 of file FPGATrackSimReportingAlg.cxx.

561 {
562  std::string mainTable = "\n";
563  if(not (*FPGAPrototracks).empty()) mainTable += "|---------------------------------------------------------------------------------------------|\n";
564 
565  unsigned int prototrackCounter = 0;
566  for (auto const& prototrack : *FPGAPrototracks)
567  {
568  ++prototrackCounter;
569  const Acts::BoundTrackParameters& initialParameters = *prototrack.parameters;
570  const Acts::BoundVector& parameters = initialParameters.parameters();
571  mainTable +=
572  "| # | QopT | Theta | Phi | d0 | z0 |\n"
573  "|---------------------------------------------------------------------------------------------|\n";
574  mainTable += std::format("| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
575  prototrackCounter,
576  parameters[Acts::eBoundQOverP],
577  parameters[Acts::eBoundTheta],
578  parameters[Acts::eBoundPhi],
579  parameters[Acts::eBoundLoc0],
580  parameters[Acts::eBoundLoc1]);
581 
582  const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
583  unsigned int measurementCounter = 0;
584  if (measurements->size())
585  {
586  mainTable +=
587  "| _____________________________________________________________________________________|\n"
588  "| | | type | Global coordinates | HashID | Identifier |\n"
589  "| | ## | | x | y | z | | |\n"
590  "| | |...........................................................................|\n";
591 
592  }
593  for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
594  {
595  ++measurementCounter;
596  const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
597  if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) {
598  const xAOD::PixelCluster* pixelCluster = dynamic_cast<const xAOD::PixelCluster*>(&measurement);
599  mainTable += std::format("| | {:>6} | Pixel | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
600  measurementCounter,
601  pixelCluster->globalPosition().cast<double>().x(),
602  pixelCluster->globalPosition().cast<double>().y(),
603  pixelCluster->globalPosition().cast<double>().z(),
604  pixelCluster->identifierHash(),
605  pixelCluster->identifier());
606  }
607  else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) {
608  const xAOD::StripCluster* stripCluster = dynamic_cast<const xAOD::StripCluster*>(&measurement);
609  mainTable += std::format("| | {:>6} | Strip | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
610  measurementCounter,
611  stripCluster->globalPosition().cast<double>().x(),
612  stripCluster->globalPosition().cast<double>().y(),
613  stripCluster->globalPosition().cast<double>().z(),
614  stripCluster->identifierHash(),
615  stripCluster->identifier());
616  }
617  }
618  mainTable += "|---------------------------------------------------------------------------------------------|\n";
619  }
620  ATH_MSG_INFO("Printing out prototracks coming from " << FPGAPrototracks.key() << mainTable);
621 }

◆ printFPGARoads()

void FPGATrackSim::FPGATrackSimReportingAlg::printFPGARoads ( SG::ReadHandle< FPGATrackSimRoadCollection > &  FPGARoads) const
private

Definition at line 411 of file FPGATrackSimReportingAlg.cxx.

412 {
413  std::string mainTable = "\n"
414  "|--------------------------------------------------------------------------------------------------|\n"
415  "| # | SubRegion | xBin | yBin | X | Y | RoadID | Sector |\n"
416  "|--------------------------------------------------------------------------------------------------|\n";
417 
418  unsigned int roadCounter = 0, hitCounter = 0;
419  for (const FPGATrackSimRoad& road : *FPGARoads)
420  {
421  ++roadCounter;
422  mainTable += std::format("| {:>6} | {:>11} | {:>8} | {:>8} | {:>12} | {:>12} | {:>10} | {:>8} |\n",
423  roadCounter,
424  road.getSubRegion(),
425  road.getXBin(),
426  road.getYBin(),
427  road.getX(),
428  road.getY(),
429  road.getRoadID(),
430  road.getSector());
431  mainTable +=
432  "| __________________________________________________________________________________________|\n"
433  "| | layer | ## | type | Global coordinates | isReal |\n"
434  "| | | | | x | y | z | |\n"
435  "| |.........................................................................................|\n";
436  for (unsigned int i = 0; i < road.getNLayers(); ++i)
437  {
438  hitCounter = 0;
439  const std::vector<std::shared_ptr<const FPGATrackSimHit>>& hits = road.getHits(i);
440  for (auto const& hit : hits)
441  {
442  if (!hit) {
443  ATH_MSG_WARNING("Null pointer for FPGATrackSimHit");
444  continue;
445  }
446  try {
447  ++hitCounter;
448  mainTable += std::format("| | {:>9} | {:>6} | {:>8} | {:>13} | {:>13} | {:>13} | {:>7} |\n",
449  (hit->isMapped() ? hit->getLayer() : 9999),
450  hitCounter,
451  (hit->isPixel() ? "Pixel" : hit->isStrip() ? "Strip" : "FAILED"),
452  hit->getX(),
453  hit->getY(),
454  hit->getZ(),
455  hit->isReal());
456  } catch (const std::exception& e) {
457  ATH_MSG_ERROR("Exception while processing FPGATrackSimHit: " << e.what());
458  }
459 
460  }
461  }
462  mainTable += "|--------------------------------------------------------------------------------------------------|\n";
463  }
464  ATH_MSG_INFO("List of FPGA roads for " << FPGARoads.key() << mainTable);
465 }

◆ printFPGASeeds()

void FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeeds ( SG::ReadHandle< ActsTrk::SeedContainer > &  FPGASeeds) const
private

Definition at line 343 of file FPGATrackSimReportingAlg.cxx.

344 {
345  std::string mainTable = "\n"
346  "|=====================================================================================|\n"
347  "| # | seed | Global coordinates | element ID list |\n"
348  "| | i | x | y | z | |\n"
349  "|-------------------------------------------------------------------------------------|\n";
350  unsigned int counter = 0;
351  for (const auto thisTrack : *seedContainer)
352  {
353  auto spList = thisTrack.sp();
354  ++counter;
355  for(int i = 0; i < 3; i++)
356  {
357  auto sp = spList.at(i);
358  mainTable += std::format("| {:>6} | {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
359  counter,
360  i,
361  sp->globalPosition().x(),
362  sp->globalPosition().y(),
363  sp->globalPosition().z(),
364  sp->elementIdList()[0],
365  sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
366  }
367 
368  }
369  mainTable += "|=========================================================================================|";
370  ATH_MSG_INFO("Printout of ACTS seeds coming from " << seedContainer.key() << mainTable );
371 }

◆ printFPGASeedsParam()

void FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeedsParam ( SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &  FPGASeedsParam) const
private

Definition at line 379 of file FPGATrackSimReportingAlg.cxx.

380 {
381  std::string mainTable = "\n"
382  "|=============================================================================================|\n"
383  "| # | QopT | Theta | Phi | d0 | z0 |\n"
384  "|---------------------------------------------------------------------------------------------|\n";
385  unsigned int counter = 0;
386  for (const auto paramSet : *seedContainer)
387  {
388  ++counter;
389  auto parameters = paramSet->parameters();
390  mainTable += std::format("| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
391  counter,
392  parameters[Acts::eBoundQOverP],
393  parameters[Acts::eBoundTheta],
394  parameters[Acts::eBoundPhi],
395  parameters[Acts::eBoundLoc0],
396  parameters[Acts::eBoundLoc1]);
397  }
398  mainTable += "|=========================================================================================|";
399  ATH_MSG_INFO("Printout of ACTS seeds Param coming from " << seedContainer.key() << mainTable );
400 }

◆ printFPGATracks()

void FPGATrackSim::FPGATrackSimReportingAlg::printFPGATracks ( SG::ReadHandle< FPGATrackSimTrackCollection > &  FPGATracks) const
private

Definition at line 485 of file FPGATrackSimReportingAlg.cxx.

486 {
487  std::string maintable = "\n|--------------------------------------------------------------------------------------------------|\n";
488  unsigned int trackCounter = 0;
489  for (auto const& track : *FPGATracks)
490  {
491  ++trackCounter;
492  maintable += "| # | Eta | Phi | D0 | Z0 | QOverPt | chi2/ndf |\n"
493  "|--------------------------------------------------------------------------------------------------|\n";
494 
495  try
496  {
497  maintable += std::format("| {:>6} | {:>12.8f} | {:>12.8f} | {:>12.8f} | {:>12.5f} | {:>12.9f} | {:>12.8f} |\n",
498  trackCounter,
499  track.getEta(),
500  track.getPhi(),
501  track.getD0(),
502  track.getZ0(),
503  track.getQOverPt(),
504  track.getChi2ndof());
505  }
506  catch (const std::exception& e)
507  {
508  ATH_MSG_ERROR("Exception while processing FPGATrackSimTrack: " << e.what());
509  continue;
510  }
511 
512  maintable += "|__________________________________________________________________________________________________|\n"
513  "| | ## | type | layer | Global coordinates | isReal | HashID |\n"
514  "| | | | | x | y | z | | |\n"
515  "| |.........................................................................................|\n";
516  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
517  unsigned int hitCounter = 0;
518  for (auto const& hit : hits)
519  {
520  try {
521  ++hitCounter;
522  maintable += std::format("| | {:>6} | {:>8} | {:>5} | {:>9.3f} | {:>9.3f} | {:>9.3f} | {:>6} | {:>14} |\n",
523  hitCounter,
524  (hit.isPixel() ? "Pixel" : hit.isStrip() ? "Strip" : "FAILED"),
525  hit.getLayer(),
526  hit.getX(),
527  hit.getY(),
528  hit.getZ(),
529  hit.isReal(),
530  hit.getIdentifierHash());
531  } catch (const std::exception& e) {
532  ATH_MSG_ERROR("Exception while processing FPGATrackSimHits: " << e.what());
533  }
534  }
535  maintable += "|--------------------------------------------------------------------------------------------------|\n";
536  }
537  ATH_MSG_INFO("List of FPGA tracks for " << FPGATracks.key() << maintable);
538 }

◆ printxAODClusters() [1/3]

template<>
void FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters ( SG::ReadHandle< DataVector< xAOD::PixelCluster >> &  clusterContainer) const

Definition at line 242 of file FPGATrackSimReportingAlg.cxx.

243 {
244  std::string mainTable = "\n"
245  "|===================================================================================================================================================================================|\n"
246  "| # | Global coordinates | Local coordinates | Local Covariance | Size | Hash ID | Identifier |\n"
247  "| | x | y | z | 0 | 1 | 0,0 | 1,1 | phi | eta | | |\n"
248  "|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n";
249  unsigned int counter = 0;
250  std::map<int, int> counterMap;
251  for (const auto& cluster : *clusterContainer)
252  {
253  ++counter;
254 
255  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:#018x} |\n",
256  counter,
257  cluster->globalPosition().x(),
258  cluster->globalPosition().y(),
259  cluster->globalPosition().z(),
260  cluster->localPosition<2>()[0],
261  cluster->localPosition<2>()[1],
262  cluster->localCovariance<2>()(0, 0),
263  cluster->localCovariance<2>()(1, 1),
264  cluster->channelsInPhi(),
265  cluster->channelsInEta(),
266  cluster->identifierHash(),
267  cluster->identifier());
268 
269  counterMap[cluster->identifierHash()]++;
270  }
271  mainTable += "|=========================================================================================|";
272 
273  ATH_MSG_INFO("Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
274 }

◆ printxAODClusters() [2/3]

template<>
void FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters ( SG::ReadHandle< DataVector< xAOD::StripCluster >> &  clusterContainer) const

Definition at line 277 of file FPGATrackSimReportingAlg.cxx.

278 {
279  std::string mainTable = "\n"
280  "|======================================================================================================================================|\n"
281  "| # | Global coordinates | Local | Local | Size | Hash ID | Identifier |\n"
282  "| | x | y | z | Pos | Cov | | | |\n"
283  "|--------------------------------------------------------------------------------------------------------------------------------------|\n";
284  unsigned int counter = 0;
285  std::map<int, int> counterMap;
286  for (const auto& cluster : *clusterContainer)
287  {
288  ++counter;
289 
290  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:#018x} |\n",
291  counter,
292  cluster->globalPosition().x(),
293  cluster->globalPosition().y(),
294  cluster->globalPosition().z(),
295  cluster->localPosition<1>()[0],
296  cluster->localCovariance<1>()(0, 0),
297  cluster->channelsInPhi(),
298  cluster->identifierHash(),
299  cluster->identifier());
300 
301  counterMap[cluster->identifierHash()]++;
302  }
303  mainTable += "|=========================================================================================|";
304 
305  ATH_MSG_INFO("Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
306 }

◆ printxAODClusters() [3/3]

template<class XAOD_CLUSTER >
void FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters ( SG::ReadHandle< DataVector< XAOD_CLUSTER >> &  clusterContainer) const
private

Definition at line 218 of file FPGATrackSimReportingAlg.cxx.

219 {
220  std::string mainTable = "\n"
221  "|=========================================================================================|\n"
222  "| # | Global coordinates | Hash ID | Identifier |\n"
223  "| | x | y | z | | |\n"
224  "|-----------------------------------------------------------------------------------------|\n";
225  unsigned int counter = 0;
226  for (const auto& cluster : *clusterContainer)
227  {
228  ++counter;
229  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>18} |\n",
230  counter,
231  cluster->globalPosition().x(),
232  cluster->globalPosition().y(),
233  cluster->globalPosition().z(),
234  cluster->identifierHash(),
235  cluster->identifier());
236  }
237  mainTable += "|=========================================================================================|";
238  ATH_MSG_INFO("Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
239 }

◆ printxAODSpacePoints()

void FPGATrackSim::FPGATrackSimReportingAlg::printxAODSpacePoints ( SG::ReadHandle< DataVector< xAOD::SpacePoint >> &  spContainer) const
private

Definition at line 314 of file FPGATrackSimReportingAlg.cxx.

315 {
316  std::string mainTable = "\n"
317  "|============================================================================|\n"
318  "| # | Global coordinates | element ID list |\n"
319  "| | x | y | z | |\n"
320  "|----------------------------------------------------------------------------|\n";
321  unsigned int counter = 0;
322  for (const auto sp : *spContainer)
323  {
324  ++counter;
325  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
326  counter,
327  sp->globalPosition().x(),
328  sp->globalPosition().y(),
329  sp->globalPosition().z(),
330  sp->elementIdList()[0],
331  sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
332  }
333  mainTable += "|=========================================================================================|";
334  ATH_MSG_INFO("Printout of xAOD space points coming from " << spContainer.key() << mainTable );
335 }

◆ processActsTracks()

void FPGATrackSim::FPGATrackSimReportingAlg::processActsTracks ( SG::ReadHandle< ActsTrk::TrackContainer > &  ActsTracks) const
private

◆ processFPGAClusters()

void FPGATrackSim::FPGATrackSimReportingAlg::processFPGAClusters ( SG::ReadHandle< FPGATrackSimClusterCollection > &  FPGAClusters) const
private

◆ processFPGAPrototracks()

void FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks ( SG::ReadHandle< ActsTrk::ProtoTrackCollection > &  FPGAPrototracks) const
private

Definition at line 540 of file FPGATrackSimReportingAlg.cxx.

541 {
542  unsigned int nPixelMeasurements, nStripMeasurements;
543  for (auto const& prototrack : *FPGAPrototracks)
544  {
545  nPixelMeasurements = 0, nStripMeasurements = 0;
546  const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
547  for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
548  {
549  const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
550  if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) ++nPixelMeasurements;
551  else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) ++nStripMeasurements;
552  }
553  m_pixelClustersPerPrototrack.push_back(nPixelMeasurements);
554  m_stripClustersPerPrototrack.push_back(nStripMeasurements);
555 
556  }
557  if (m_printoutForEveryEvent) printFPGAPrototracks(FPGAPrototracks);
558 }

◆ processFPGARoads()

void FPGATrackSim::FPGATrackSimReportingAlg::processFPGARoads ( SG::ReadHandle< FPGATrackSimRoadCollection > &  FPGARoads) const
private

Definition at line 406 of file FPGATrackSimReportingAlg.cxx.

407 {
408  if (m_printoutForEveryEvent) printFPGARoads(FPGARoads);
409 }

◆ processFPGASeeds()

void FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeeds ( SG::ReadHandle< ActsTrk::SeedContainer > &  FPGASeeds) const
private

Definition at line 338 of file FPGATrackSimReportingAlg.cxx.

339 {
340  if (m_printoutForEveryEvent) printFPGASeeds(spContainer);
341 }

◆ processFPGASeedsParam()

void FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeedsParam ( SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &  FPGASeedsParam) const
private

Definition at line 374 of file FPGATrackSimReportingAlg.cxx.

375 {
376  if (m_printoutForEveryEvent) printFPGASeedsParam(spContainer);
377 }

◆ processFPGATracks()

void FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks ( SG::ReadHandle< FPGATrackSimTrackCollection > &  FPGATracks) const
private

Definition at line 468 of file FPGATrackSimReportingAlg.cxx.

469 {
470  for (auto const& track : *FPGATracks)
471  {
472  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
473  uint32_t pixelHits = 0, stripHits = 0;
474  for (const FPGATrackSimHit& hit : hits)
475  {
476  if (hit.isPixel()) ++pixelHits;
477  if (hit.isStrip()) ++stripHits;
478  }
479  m_pixelClustersPerFPGATrack.push_back(pixelHits);
480  m_stripClustersPerFPGATrack.push_back(stripHits);
481  }
482  if (m_printoutForEveryEvent) printFPGATracks(FPGATracks);
483 }

◆ processxAODClusters()

template<class XAOD_CLUSTER >
void FPGATrackSim::FPGATrackSimReportingAlg::processxAODClusters ( SG::ReadHandle< DataVector< XAOD_CLUSTER >> &  clusterContainer) const
private

Definition at line 212 of file FPGATrackSimReportingAlg.cxx.

213 {
214  if (m_printoutForEveryEvent) printxAODClusters(clusterContainer);
215 }

◆ processxAODSpacePoints()

void FPGATrackSim::FPGATrackSimReportingAlg::processxAODSpacePoints ( SG::ReadHandle< DataVector< xAOD::SpacePoint >> &  spContainer) const
private

Definition at line 309 of file FPGATrackSimReportingAlg.cxx.

310 {
311  if (m_printoutForEveryEvent) printxAODSpacePoints(spContainer);
312 }

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

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

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

364  {
365  handlesArray.renounce();
366  }

◆ setFilterPassed()

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

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ summaryReportForEDMConversion()

StatusCode FPGATrackSim::FPGATrackSimReportingAlg::summaryReportForEDMConversion ( )
private

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

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

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

107  {
108  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

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

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/6]

std::vector<uint32_t> m_pixelClustersPerFPGATrack FPGATrackSim::FPGATrackSimReportingAlg::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 40 of file FPGATrackSimReportingAlg.h.

◆ ATLAS_THREAD_SAFE [2/6]

std::vector<uint32_t> m_pixelClustersPerFPGATrack m_stripClustersPerFPGATrack FPGATrackSim::FPGATrackSimReportingAlg::ATLAS_THREAD_SAFE
private

Definition at line 40 of file FPGATrackSimReportingAlg.h.

◆ ATLAS_THREAD_SAFE [3/6]

std::vector<uint32_t> m_pixelClustersPerPrototrack m_stripClustersPerPrototrack FPGATrackSim::FPGATrackSimReportingAlg::ATLAS_THREAD_SAFE
private

Definition at line 41 of file FPGATrackSimReportingAlg.h.

◆ ATLAS_THREAD_SAFE [4/6]

std::vector<uint32_t> m_pixelClustersPerPrototrack FPGATrackSim::FPGATrackSimReportingAlg::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 41 of file FPGATrackSimReportingAlg.h.

◆ ATLAS_THREAD_SAFE [5/6]

std::map<std::string, std::vector<FPGATrackSimActsEventTracks> > m_allActsTracks FPGATrackSim::FPGATrackSimReportingAlg::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 43 of file FPGATrackSimReportingAlg.h.

◆ ATLAS_THREAD_SAFE [6/6]

std::map<std::string, std::map<uint32_t,std::vector<uint32_t> > > m_actsTrackStats FPGATrackSim::FPGATrackSimReportingAlg::ATLAS_THREAD_SAFE
mutableprivate

Definition at line 44 of file FPGATrackSimReportingAlg.h.

◆ m_ActsInspectionTool

ToolHandle<FPGATrackSim::ActsTrackInspectionTool> FPGATrackSim::FPGATrackSimReportingAlg::m_ActsInspectionTool {this, "ActsInspectionTool", "FPGATrackSim::ActsTrackInspectionTool/ActsTrackInspectionTool", "Monitoring tool for acts tracks"}
private

Definition at line 82 of file FPGATrackSimReportingAlg.h.

◆ m_ActsSeedCollections

SG::ReadHandleKeyArray<ActsTrk::SeedContainer> FPGATrackSim::FPGATrackSimReportingAlg::m_ActsSeedCollections {this, "FPGAActsSeeds",{},"Acts Seeds collections from (C)KF"}
private

Definition at line 75 of file FPGATrackSimReportingAlg.h.

◆ m_ActsSeedParamCollections

SG::ReadHandleKeyArray<ActsTrk::BoundTrackParametersContainer> FPGATrackSim::FPGATrackSimReportingAlg::m_ActsSeedParamCollections {this, "FPGAActsSeedsParam",{},"Acts Seeds param collections from (C)KF"}
private

Definition at line 77 of file FPGATrackSimReportingAlg.h.

◆ m_ActsTrackCollections

SG::ReadHandleKeyArray<ActsTrk::TrackContainer> FPGATrackSim::FPGATrackSimReportingAlg::m_ActsTrackCollections {this, "FPGAActsTracks",{},"Acts track collections from (C)KF"}
private

Definition at line 73 of file FPGATrackSimReportingAlg.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_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_FPGAProtoTrackCollections

SG::ReadHandleKeyArray<ActsTrk::ProtoTrackCollection> FPGATrackSim::FPGATrackSimReportingAlg::m_FPGAProtoTrackCollections {this, "FPGATrackSimProtoTracks",{},"FPGATrackSim PrototrackCollection"}
private

Definition at line 71 of file FPGATrackSimReportingAlg.h.

◆ m_FPGARoadsKey

SG::ReadHandleKey<FPGATrackSimRoadCollection> FPGATrackSim::FPGATrackSimReportingAlg::m_FPGARoadsKey { this, "FPGATrackSimRoads","","FPGATrackSim Roads key" }
private

Definition at line 67 of file FPGATrackSimReportingAlg.h.

◆ m_FPGATracksKey

SG::ReadHandleKey<FPGATrackSimTrackCollection> FPGATrackSim::FPGATrackSimReportingAlg::m_FPGATracksKey { this, "FPGATrackSimTracks","","FPGATrackSim Tracks key" }
private

Definition at line 69 of file FPGATrackSimReportingAlg.h.

◆ m_isDataPrep

Gaudi::Property<bool> FPGATrackSim::FPGATrackSimReportingAlg::m_isDataPrep {this, "isDataPrep", false, "If True, this is for data prep pipeline only"}
private

Definition at line 47 of file FPGATrackSimReportingAlg.h.

◆ m_printoutForEveryEvent

Gaudi::Property<bool> FPGATrackSim::FPGATrackSimReportingAlg::m_printoutForEveryEvent {this, "perEventReports", false, "A flag to enable per event printout"}
private

Definition at line 46 of file FPGATrackSimReportingAlg.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.

◆ m_xAODPixelClusterContainerKeys

SG::ReadHandleKeyArray<xAOD::PixelClusterContainer> FPGATrackSim::FPGATrackSimReportingAlg::m_xAODPixelClusterContainerKeys
private
Initial value:
{
this, "xAODPixelClusterContainers", {},
"input list of xAOD Pixel Cluster Containers, as resulted from FPGATrackSim (hit/road) EDM conversion" }

Definition at line 50 of file FPGATrackSimReportingAlg.h.

◆ m_xAODSpacePointContainerKeys

SG::ReadHandleKeyArray<xAOD::SpacePointContainer> FPGATrackSim::FPGATrackSimReportingAlg::m_xAODSpacePointContainerKeys
private
Initial value:
{
this, "xAODSpacePointContainersFromFPGA", {"xAODStripSpacePoints_1stFromFPGA","xAODPixelSpacePoints_1stFromFPGA"},
"input list of xAOD SpacePoint Containers, as resulted from FPGATrackSim (hit/road) EDM conversion" }

Definition at line 60 of file FPGATrackSimReportingAlg.h.

◆ m_xAODStripClusterContainerKeys

SG::ReadHandleKeyArray<xAOD::StripClusterContainer> FPGATrackSim::FPGATrackSimReportingAlg::m_xAODStripClusterContainerKeys
private
Initial value:
{
this, "xAODStripClusterContainers", {"ITkStripClusters" ,"xAODStripClusters_1stFromFPGACluster", "xAODStripClusters_1stFromFPGAHit"},
"input list of xAOD Strip Cluster Containers, as resulted from FPGATrackSim (hit/road) EDM conversion" }

Definition at line 55 of file FPGATrackSimReportingAlg.h.

The documentation for this class was generated from the following files:
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
FPGATrackSim::FPGATrackSimReportingAlg::m_xAODPixelClusterContainerKeys
SG::ReadHandleKeyArray< xAOD::PixelClusterContainer > m_xAODPixelClusterContainerKeys
Definition: FPGATrackSimReportingAlg.h:50
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsSeedCollections
SG::ReadHandleKeyArray< ActsTrk::SeedContainer > m_ActsSeedCollections
Definition: FPGATrackSimReportingAlg.h:75
FPGATrackSim::FPGATrackSimReportingAlg::printxAODSpacePoints
void printxAODSpacePoints(SG::ReadHandle< DataVector< xAOD::SpacePoint >> &spContainer) const
Definition: FPGATrackSimReportingAlg.cxx:314
vtune_athena.format
format
Definition: vtune_athena.py:14
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
xAOD::UncalibMeasType::StripClusterType
@ StripClusterType
runITkAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runITkAlign.py:62
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
FPGATrackSim::FPGATrackSimReportingAlg::m_xAODSpacePointContainerKeys
SG::ReadHandleKeyArray< xAOD::SpacePointContainer > m_xAODSpacePointContainerKeys
Definition: FPGATrackSimReportingAlg.h:60
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeeds
void printFPGASeeds(SG::ReadHandle< ActsTrk::SeedContainer > &FPGASeeds) const
Definition: FPGATrackSimReportingAlg.cxx:343
FPGATrackSim::FPGATrackSimReportingAlg::m_FPGAProtoTrackCollections
SG::ReadHandleKeyArray< ActsTrk::ProtoTrackCollection > m_FPGAProtoTrackCollections
Definition: FPGATrackSimReportingAlg.h:71
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
Trk::stripCluster
@ stripCluster
Definition: MeasurementType.h:23
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
FPGATrackSim::FPGATrackSimReportingAlg::printFPGATracks
void printFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:485
FPGATrackSim::FPGATrackSimReportingAlg::m_printoutForEveryEvent
Gaudi::Property< bool > m_printoutForEveryEvent
Definition: FPGATrackSimReportingAlg.h:46
FPGATrackSim::FPGATrackSimReportingAlg::printFPGAPrototracks
void printFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition: FPGATrackSimReportingAlg.cxx:560
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
xAOD::UncalibratedMeasurement_v1
Definition: UncalibratedMeasurement_v1.h:13
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
xAOD::UncalibratedMeasurement_v1::type
virtual xAOD::UncalibMeasType type() const =0
Returns the type of the measurement type as a simple enumeration.
lumiFormat.i
int i
Definition: lumiFormat.py:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
calibdata.exception
exception
Definition: calibdata.py:495
xAOD::StripCluster_v1
Definition: StripCluster_v1.h:17
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
FPGATrackSim::FPGATrackSimReportingAlg::m_FPGATracksKey
SG::ReadHandleKey< FPGATrackSimTrackCollection > m_FPGATracksKey
Definition: FPGATrackSimReportingAlg.h:69
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsInspectionTool
ToolHandle< FPGATrackSim::ActsTrackInspectionTool > m_ActsInspectionTool
Definition: FPGATrackSimReportingAlg.h:82
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
FPGATrackSim::FPGATrackSimReportingAlg::printFPGARoads
void printFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition: FPGATrackSimReportingAlg.cxx:411
FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeedsParam
void processFPGASeedsParam(SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
Definition: FPGATrackSimReportingAlg.cxx:374
ActsTrk::getUncalibratedMeasurement
const xAOD::UncalibratedMeasurement & getUncalibratedMeasurement(const ATLASUncalibSourceLink &source_link)
Definition: ATLASSourceLink.h:26
FPGATrackSim::FPGATrackSimReportingAlg::m_FPGARoadsKey
SG::ReadHandleKey< FPGATrackSimRoadCollection > m_FPGARoadsKey
Definition: FPGATrackSimReportingAlg.h:67
FPGATrackSim::FPGATrackSimReportingAlg::m_isDataPrep
Gaudi::Property< bool > m_isDataPrep
Definition: FPGATrackSimReportingAlg.h:47
FPGATrackSim::FPGATrackSimReportingAlg::processFPGARoads
void processFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition: FPGATrackSimReportingAlg.cxx:406
FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks
void processFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:468
Trk::pixelCluster
@ pixelCluster
Definition: MeasurementType.h:22
FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeeds
void processFPGASeeds(SG::ReadHandle< ActsTrk::SeedContainer > &FPGASeeds) const
Definition: FPGATrackSimReportingAlg.cxx:338
a
TList * a
Definition: liststreamerinfos.cxx:10
xAOD::PixelCluster_v1
Definition: PixelCluster_v1.h:17
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsSeedParamCollections
SG::ReadHandleKeyArray< ActsTrk::BoundTrackParametersContainer > m_ActsSeedParamCollections
Definition: FPGATrackSimReportingAlg.h:77
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
FPGATrackSim::FPGATrackSimReportingAlg::m_xAODStripClusterContainerKeys
SG::ReadHandleKeyArray< xAOD::StripClusterContainer > m_xAODStripClusterContainerKeys
Definition: FPGATrackSimReportingAlg.h:55
FPGATrackSim::FPGATrackSimReportingAlg::processxAODSpacePoints
void processxAODSpacePoints(SG::ReadHandle< DataVector< xAOD::SpacePoint >> &spContainer) const
Definition: FPGATrackSimReportingAlg.cxx:309
FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks
void processFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition: FPGATrackSimReportingAlg.cxx:540
test_pyathena.counter
counter
Definition: test_pyathena.py:15
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsTrackCollections
SG::ReadHandleKeyArray< ActsTrk::TrackContainer > m_ActsTrackCollections
Definition: FPGATrackSimReportingAlg.h:73
FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeedsParam
void printFPGASeedsParam(SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
Definition: FPGATrackSimReportingAlg.cxx:379
FPGATrackSimRoad
Definition: FPGATrackSimRoad.h:31
xAOD::UncalibMeasType::PixelClusterType
@ PixelClusterType
fitman.k
k
Definition: fitman.py:528
FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters
void printxAODClusters(SG::ReadHandle< DataVector< XAOD_CLUSTER >> &clusterContainer) const
Definition: FPGATrackSimReportingAlg.cxx:218
ServiceHandle< ICondSvc >
Generated on Fri Nov 21 2025 21:57:10 for ATLAS Offline Software by   doxygen 1.8.18