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
 
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 493 of file FPGATrackSimReportingAlg.cxx.

494 {
495  std::string mainTable = "\n";
496  if(not (*FPGAPrototracks).empty()) mainTable += "|---------------------------------------------------------------------------------------------|\n";
497 
498  unsigned int prototrackCounter = 0;
499  for (auto const& prototrack : *FPGAPrototracks)
500  {
501  ++prototrackCounter;
502  const Acts::BoundTrackParameters& initialParameters = *prototrack.parameters;
503  const Acts::BoundVector& parameters = initialParameters.parameters();
504  mainTable +=
505  "| # | QopT | Theta | Phi | d0 | z0 |\n"
506  "|---------------------------------------------------------------------------------------------|\n";
507  mainTable += std::format("| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
508  prototrackCounter,
509  parameters[Acts::eBoundQOverP],
510  parameters[Acts::eBoundTheta],
511  parameters[Acts::eBoundPhi],
512  parameters[Acts::eBoundLoc0],
513  parameters[Acts::eBoundLoc1]);
514 
515  const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
516  unsigned int measurementCounter = 0;
517  if (measurements->size())
518  {
519  mainTable +=
520  "| _____________________________________________________________________________________|\n"
521  "| | | type | Global coordinates | HashID | Identifier |\n"
522  "| | ## | | x | y | z | | |\n"
523  "| | |...........................................................................|\n";
524 
525  }
526  for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
527  {
528  ++measurementCounter;
529  const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
530  if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) {
531  const xAOD::PixelCluster* pixelCluster = dynamic_cast<const xAOD::PixelCluster*>(&measurement);
532  mainTable += std::format("| | {:>6} | Pixel | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
533  measurementCounter,
534  pixelCluster->globalPosition().cast<double>().x(),
535  pixelCluster->globalPosition().cast<double>().y(),
536  pixelCluster->globalPosition().cast<double>().z(),
537  pixelCluster->identifierHash(),
538  pixelCluster->identifier());
539  }
540  else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) {
541  const xAOD::StripCluster* stripCluster = dynamic_cast<const xAOD::StripCluster*>(&measurement);
542  mainTable += std::format("| | {:>6} | Strip | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
543  measurementCounter,
544  stripCluster->globalPosition().cast<double>().x(),
545  stripCluster->globalPosition().cast<double>().y(),
546  stripCluster->globalPosition().cast<double>().z(),
547  stripCluster->identifierHash(),
548  stripCluster->identifier());
549  }
550  }
551  mainTable += "|---------------------------------------------------------------------------------------------|\n";
552  }
553  ATH_MSG_INFO("Printing out prototracks coming from " << FPGAPrototracks.key() << mainTable);
554 }

◆ printFPGARoads()

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

Definition at line 344 of file FPGATrackSimReportingAlg.cxx.

345 {
346  std::string mainTable = "\n"
347  "|--------------------------------------------------------------------------------------------------|\n"
348  "| # | SubRegion | xBin | yBin | X | Y | RoadID | Sector |\n"
349  "|--------------------------------------------------------------------------------------------------|\n";
350 
351  unsigned int roadCounter = 0, hitCounter = 0;
352  for (const FPGATrackSimRoad& road : *FPGARoads)
353  {
354  ++roadCounter;
355  mainTable += std::format("| {:>6} | {:>11} | {:>8} | {:>8} | {:>12} | {:>12} | {:>10} | {:>8} |\n",
356  roadCounter,
357  road.getSubRegion(),
358  road.getXBin(),
359  road.getYBin(),
360  road.getX(),
361  road.getY(),
362  road.getRoadID(),
363  road.getSector());
364  mainTable +=
365  "| __________________________________________________________________________________________|\n"
366  "| | layer | ## | type | Global coordinates | isReal |\n"
367  "| | | | | x | y | z | |\n"
368  "| |.........................................................................................|\n";
369  for (unsigned int i = 0; i < road.getNLayers(); ++i)
370  {
371  hitCounter = 0;
372  const std::vector<std::shared_ptr<const FPGATrackSimHit>>& hits = road.getHits(i);
373  for (auto const& hit : hits)
374  {
375  if (!hit) {
376  ATH_MSG_WARNING("Null pointer for FPGATrackSimHit");
377  continue;
378  }
379  try {
380  ++hitCounter;
381  mainTable += std::format("| | {:>9} | {:>6} | {:>8} | {:>13} | {:>13} | {:>13} | {:>7} |\n",
382  (hit->isMapped() ? hit->getLayer() : 9999),
383  hitCounter,
384  (hit->isPixel() ? "Pixel" : hit->isStrip() ? "Strip" : "FAILED"),
385  hit->getX(),
386  hit->getY(),
387  hit->getZ(),
388  hit->isReal());
389  } catch (const std::exception& e) {
390  ATH_MSG_ERROR("Exception while processing FPGATrackSimHit: " << e.what());
391  }
392 
393  }
394  }
395  mainTable += "|--------------------------------------------------------------------------------------------------|\n";
396  }
397  ATH_MSG_INFO("List of FPGA roads for " << FPGARoads.key() << mainTable);
398 }

◆ printFPGASeeds()

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

Definition at line 276 of file FPGATrackSimReportingAlg.cxx.

277 {
278  std::string mainTable = "\n"
279  "|=====================================================================================|\n"
280  "| # | seed | Global coordinates | element ID list |\n"
281  "| | i | x | y | z | |\n"
282  "|-------------------------------------------------------------------------------------|\n";
283  unsigned int counter = 0;
284  for (const auto thisTrack : *seedContainer)
285  {
286  auto spList = thisTrack->sp();
287  ++counter;
288  for(int i = 0; i < 3; i++)
289  {
290  auto sp = spList.at(i);
291  mainTable += std::format("| {:>6} | {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
292  counter,
293  i,
294  sp->globalPosition().x(),
295  sp->globalPosition().y(),
296  sp->globalPosition().z(),
297  sp->elementIdList()[0],
298  sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
299  }
300 
301  }
302  mainTable += "|=========================================================================================|";
303  ATH_MSG_INFO("Printout of ACTS seeds coming from " << seedContainer.key() << mainTable );
304 }

◆ printFPGASeedsParam()

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

Definition at line 312 of file FPGATrackSimReportingAlg.cxx.

313 {
314  std::string mainTable = "\n"
315  "|=============================================================================================|\n"
316  "| # | QopT | Theta | Phi | d0 | z0 |\n"
317  "|---------------------------------------------------------------------------------------------|\n";
318  unsigned int counter = 0;
319  for (const auto paramSet : *seedContainer)
320  {
321  ++counter;
322  auto parameters = paramSet->parameters();
323  mainTable += std::format("| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
324  counter,
325  parameters[Acts::eBoundQOverP],
326  parameters[Acts::eBoundTheta],
327  parameters[Acts::eBoundPhi],
328  parameters[Acts::eBoundLoc0],
329  parameters[Acts::eBoundLoc1]);
330  }
331  mainTable += "|=========================================================================================|";
332  ATH_MSG_INFO("Printout of ACTS seeds Param coming from " << seedContainer.key() << mainTable );
333 }

◆ printFPGATracks()

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

Definition at line 418 of file FPGATrackSimReportingAlg.cxx.

419 {
420  std::string maintable = "\n|--------------------------------------------------------------------------------------------------|\n";
421  unsigned int trackCounter = 0;
422  for (auto const& track : *FPGATracks)
423  {
424  ++trackCounter;
425  maintable += "| # | Eta | Phi | D0 | Z0 | QOverPt | chi2/ndf |\n"
426  "|--------------------------------------------------------------------------------------------------|\n";
427 
428  try
429  {
430  maintable += std::format("| {:>6} | {:>12.8f} | {:>12.8f} | {:>12.8f} | {:>12.5f} | {:>12.9f} | {:>12.8f} |\n",
431  trackCounter,
432  track.getEta(),
433  track.getPhi(),
434  track.getD0(),
435  track.getZ0(),
436  track.getQOverPt(),
437  track.getChi2ndof());
438  }
439  catch (const std::exception& e)
440  {
441  ATH_MSG_ERROR("Exception while processing FPGATrackSimTrack: " << e.what());
442  continue;
443  }
444 
445  maintable += "|__________________________________________________________________________________________________|\n"
446  "| | ## | type | layer | Global coordinates | isReal | HashID |\n"
447  "| | | | | x | y | z | | |\n"
448  "| |.........................................................................................|\n";
449  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
450  unsigned int hitCounter = 0;
451  for (auto const& hit : hits)
452  {
453  try {
454  ++hitCounter;
455  maintable += std::format("| | {:>6} | {:>8} | {:>5} | {:>9.3f} | {:>9.3f} | {:>9.3f} | {:>6} | {:>14} |\n",
456  hitCounter,
457  (hit.isPixel() ? "Pixel" : hit.isStrip() ? "Strip" : "FAILED"),
458  hit.getLayer(),
459  hit.getX(),
460  hit.getY(),
461  hit.getZ(),
462  hit.isReal(),
463  hit.getIdentifierHash());
464  } catch (const std::exception& e) {
465  ATH_MSG_ERROR("Exception while processing FPGATrackSimHits: " << e.what());
466  }
467  }
468  maintable += "|--------------------------------------------------------------------------------------------------|\n";
469  }
470  ATH_MSG_INFO("List of FPGA tracks for " << FPGATracks.key() << maintable);
471 }

◆ printxAODClusters()

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 247 of file FPGATrackSimReportingAlg.cxx.

248 {
249  std::string mainTable = "\n"
250  "|============================================================================|\n"
251  "| # | Global coordinates | element ID list |\n"
252  "| | x | y | z | |\n"
253  "|----------------------------------------------------------------------------|\n";
254  unsigned int counter = 0;
255  for (const auto sp : *spContainer)
256  {
257  ++counter;
258  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
259  counter,
260  sp->globalPosition().x(),
261  sp->globalPosition().y(),
262  sp->globalPosition().z(),
263  sp->elementIdList()[0],
264  sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
265  }
266  mainTable += "|=========================================================================================|";
267  ATH_MSG_INFO("Printout of xAOD space points coming from " << spContainer.key() << mainTable );
268 }

◆ 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 473 of file FPGATrackSimReportingAlg.cxx.

474 {
475  unsigned int nPixelMeasurements, nStripMeasurements;
476  for (auto const& prototrack : *FPGAPrototracks)
477  {
478  nPixelMeasurements = 0, nStripMeasurements = 0;
479  const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
480  for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
481  {
482  const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
483  if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) ++nPixelMeasurements;
484  else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) ++nStripMeasurements;
485  }
486  m_pixelClustersPerPrototrack.push_back(nPixelMeasurements);
487  m_stripClustersPerPrototrack.push_back(nStripMeasurements);
488 
489  }
490  if (m_printoutForEveryEvent) printFPGAPrototracks(FPGAPrototracks);
491 }

◆ processFPGARoads()

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

Definition at line 339 of file FPGATrackSimReportingAlg.cxx.

340 {
341  if (m_printoutForEveryEvent) printFPGARoads(FPGARoads);
342 }

◆ processFPGASeeds()

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

Definition at line 271 of file FPGATrackSimReportingAlg.cxx.

272 {
273  if (m_printoutForEveryEvent) printFPGASeeds(spContainer);
274 }

◆ processFPGASeedsParam()

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

Definition at line 307 of file FPGATrackSimReportingAlg.cxx.

308 {
309  if (m_printoutForEveryEvent) printFPGASeedsParam(spContainer);
310 }

◆ processFPGATracks()

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

Definition at line 401 of file FPGATrackSimReportingAlg.cxx.

402 {
403  for (auto const& track : *FPGATracks)
404  {
405  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
406  uint32_t pixelHits = 0, stripHits = 0;
407  for (const FPGATrackSimHit& hit : hits)
408  {
409  if (hit.isPixel()) ++pixelHits;
410  if (hit.isStrip()) ++stripHits;
411  }
412  m_pixelClustersPerFPGATrack.push_back(pixelHits);
413  m_stripClustersPerFPGATrack.push_back(stripHits);
414  }
415  if (m_printoutForEveryEvent) printFPGATracks(FPGATracks);
416 }

◆ 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 242 of file FPGATrackSimReportingAlg.cxx.

243 {
244  if (m_printoutForEveryEvent) printxAODSpacePoints(spContainer);
245 }

◆ 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:247
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
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:276
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:418
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:493
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:344
FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeedsParam
void processFPGASeedsParam(SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
Definition: FPGATrackSimReportingAlg.cxx:307
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:339
FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks
void processFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:401
Trk::pixelCluster
@ pixelCluster
Definition: MeasurementType.h:22
FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeeds
void processFPGASeeds(SG::ReadHandle< ActsTrk::SeedContainer > &FPGASeeds) const
Definition: FPGATrackSimReportingAlg.cxx:271
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:60
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:242
FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks
void processFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition: FPGATrackSimReportingAlg.cxx:473
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:312
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 Mon Sep 1 2025 22:00:03 for ATLAS Offline Software by   doxygen 1.8.18