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 > &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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

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 AthReentrantAlgorithm::cardinality ( ) const
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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 > &  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 > &  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 > &  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 > &  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 
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(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  } // if it's not the data preparation chain
146  return StatusCode::SUCCESS;
147 }

◆ 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 & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

80 {
81  // If we didn't find any symlinks to add, just return the collection
82  // from the base class. Otherwise, return the extended collection.
83  if (!m_extendedExtraObjects.empty()) {
84  return m_extendedExtraObjects;
85  }
86  return Algorithm::extraOutputDeps();
87 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ finalize()

StatusCode FPGATrackSim::FPGATrackSimReportingAlg::finalize ( )
finaloverridevirtual

Definition at line 149 of file FPGATrackSimReportingAlg.cxx.

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

◆ 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(!m_isDataPrep));
20  ATH_CHECK(m_ActsSeedCollections.initialize(!m_isDataPrep));
21  ATH_CHECK(m_ActsSeedParamCollections.initialize(!m_isDataPrep));
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 AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, InDet::SiSPGNNTrackMaker, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

45 {
46  // Reentrant algorithms are clonable.
47  return true;
48 }

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

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

◆ printFPGARoads()

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

Definition at line 345 of file FPGATrackSimReportingAlg.cxx.

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

◆ printFPGASeeds()

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

Definition at line 277 of file FPGATrackSimReportingAlg.cxx.

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

◆ printFPGASeedsParam()

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

Definition at line 313 of file FPGATrackSimReportingAlg.cxx.

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

◆ printFPGATracks()

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

Definition at line 419 of file FPGATrackSimReportingAlg.cxx.

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

◆ printxAODClusters()

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

Definition at line 219 of file FPGATrackSimReportingAlg.cxx.

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

◆ printxAODSpacePoints()

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

Definition at line 248 of file FPGATrackSimReportingAlg.cxx.

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

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

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

◆ processFPGARoads()

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

Definition at line 340 of file FPGATrackSimReportingAlg.cxx.

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

◆ processFPGASeeds()

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

Definition at line 272 of file FPGATrackSimReportingAlg.cxx.

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

◆ processFPGASeedsParam()

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

Definition at line 308 of file FPGATrackSimReportingAlg.cxx.

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

◆ processFPGATracks()

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

Definition at line 402 of file FPGATrackSimReportingAlg.cxx.

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

◆ processxAODClusters()

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

Definition at line 213 of file FPGATrackSimReportingAlg.cxx.

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

◆ processxAODSpacePoints()

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

Definition at line 243 of file FPGATrackSimReportingAlg.cxx.

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

◆ 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 AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ summaryReportForEDMConversion()

StatusCode FPGATrackSim::FPGATrackSimReportingAlg::summaryReportForEDMConversion ( )
private

◆ sysExecute()

StatusCode AthReentrantAlgorithm::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 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::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 96 of file AthReentrantAlgorithm.cxx.

96  {
97  StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>::sysInitialize();
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ 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 AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.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:248
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:70
xAOD::UncalibMeasType::StripClusterType
@ StripClusterType
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
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:277
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
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
FPGATrackSim::FPGATrackSimReportingAlg::printFPGATracks
void printFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:419
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:494
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
xAOD::UncalibratedMeasurement_v1
Definition: UncalibratedMeasurement_v1.h:13
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthReentrantAlgorithm::AthReentrantAlgorithm
AthReentrantAlgorithm()
Default constructor:
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
calibdata.exception
exception
Definition: calibdata.py:496
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
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
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:228
FPGATrackSim::FPGATrackSimReportingAlg::printFPGARoads
void printFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition: FPGATrackSimReportingAlg.cxx:345
FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeedsParam
void processFPGASeedsParam(SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
Definition: FPGATrackSimReportingAlg.cxx:308
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
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:340
FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks
void processFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:402
Trk::pixelCluster
@ pixelCluster
Definition: MeasurementType.h:22
FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeeds
void processFPGASeeds(SG::ReadHandle< ActsTrk::SeedContainer > &FPGASeeds) const
Definition: FPGATrackSimReportingAlg.cxx:272
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:623
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
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:243
FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks
void processFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition: FPGATrackSimReportingAlg.cxx:474
test_pyathena.counter
counter
Definition: test_pyathena.py:15
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsTrackCollections
SG::ReadHandleKeyArray< ActsTrk::TrackContainer > m_ActsTrackCollections
Definition: FPGATrackSimReportingAlg.h:73
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeedsParam
void printFPGASeedsParam(SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
Definition: FPGATrackSimReportingAlg.cxx:313
FPGATrackSimRoad
Definition: FPGATrackSimRoad.h:30
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:219
ServiceHandle< ICondSvc >
Generated on Fri Jan 10 2025 21:53:13 for ATLAS Offline Software by   doxygen 1.8.18