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< StoreGateSvcStoreGateSvc_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 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::PixelClusterContainerm_xAODPixelClusterContainerKeys
 
SG::ReadHandleKeyArray< xAOD::StripClusterContainerm_xAODStripClusterContainerKeys
 
SG::ReadHandleKeyArray< xAOD::SpacePointContainerm_xAODSpacePointContainerKeys
 
SG::ReadHandleKey< FPGATrackSimRoadCollectionm_FPGARoadsKey { this, "FPGATrackSimRoads","","FPGATrackSim Roads key" }
 
SG::ReadHandleKey< FPGATrackSimTrackCollectionm_FPGATracksKey { this, "FPGATrackSimTracks","","FPGATrackSim Tracks key" }
 
SG::ReadHandleKeyArray< ActsTrk::ProtoTrackCollectionm_FPGAProtoTrackCollections {this, "FPGATrackSimProtoTracks",{},"FPGATrackSim PrototrackCollection"}
 
SG::ReadHandleKeyArray< ActsTrk::TrackContainerm_ActsTrackCollections {this, "FPGAActsTracks",{},"Acts track collections from (C)KF"}
 
ToolHandle< FPGATrackSim::ActsTrackInspectionToolm_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 28 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;
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 25 of file FPGATrackSimReportingAlg.cxx.

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

◆ 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()) {
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 124 of file FPGATrackSimReportingAlg.cxx.

125 {
126  ATH_MSG_INFO("Printing statistics for FPGA objects");
127 
128  if (!m_isDataPrep.value()) {
129  // Printing summary for clusters/FPGATracks
130  std::string summaryTableFPGATracks = "\n"
131  "Number of measurements for FPGA Tracks\n"
132  "|-----------------------------------|\n"
133  "| | min | max | Avg |\n"
134  "|-----------------------------------|\n";
135 
136  if (not m_pixelClustersPerFPGATrack.empty()) {
137  summaryTableFPGATracks += std::format("| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
138  *std::min_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
139  *std::max_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
140  std::accumulate(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end(), 0.0) / m_pixelClustersPerFPGATrack.size());
141  }
142  else summaryTableFPGATracks += std::format("| Pixels | ---- | ---- | inf |\n");
143 
144  if (not m_stripClustersPerFPGATrack.empty()) {
145  summaryTableFPGATracks += std::format("| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
146  *std::min_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
147  *std::max_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
148  std::accumulate(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end(), 0.0) / m_stripClustersPerFPGATrack.size());
149  }
150  else summaryTableFPGATracks += std::format("| Strips | ---- | ---- | inf |\n");
151 
152  summaryTableFPGATracks += "|-----------------------------------|";
153  ATH_MSG_INFO( summaryTableFPGATracks );
154 
155 
156  // Printing summary for clusters/prototracks
157  std::string summaryTableFPGAPrototracks = std::format("\n"
158  "Number of measurements for FPGA Prototracks\n"
159  "|-----------------------------------|\n"
160  "| | min | max | Avg |\n"
161  "|-----------------------------------|\n");
162 
163  if (not m_pixelClustersPerPrototrack.empty()) {
164  summaryTableFPGAPrototracks += std::format("| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
165  *std::min_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
166  *std::max_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
167  std::accumulate(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end(), 0.0) / m_pixelClustersPerPrototrack.size());
168  }
169  else summaryTableFPGAPrototracks += std::format("| Pixels | ---- | ---- | inf |\n");
170 
171  if (not m_stripClustersPerPrototrack.empty()) {
172  summaryTableFPGAPrototracks += std::format("| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
173  *std::min_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
174  *std::max_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
175  std::accumulate(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end(), 0.0) / m_stripClustersPerPrototrack.size());
176  }
177  else summaryTableFPGAPrototracks += std::format("| Strips | ---- | ---- | inf |\n");
178 
179  summaryTableFPGAPrototracks += "|-----------------------------------|";
180  ATH_MSG_INFO( summaryTableFPGAPrototracks );
181  }
182 
183  ATH_MSG_INFO(m_ActsInspectionTool->getPrintoutStatistics(m_actsTrackStats));
184  return StatusCode::SUCCESS;
185 }

◆ initialize()

StatusCode FPGATrackSim::FPGATrackSimReportingAlg::initialize ( )
finaloverridevirtual

◆ 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

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

401 {
402  std::string mainTable = "\n";
403  if(not (*FPGAPrototracks).empty()) mainTable += "|---------------------------------------------------------------------------------------------|\n";
404 
405  unsigned int prototrackCounter = 0;
406  for (auto const& prototrack : *FPGAPrototracks)
407  {
408  ++prototrackCounter;
409  const Acts::BoundTrackParameters& initialParameters = *prototrack.parameters;
410  const Acts::BoundVector& parameters = initialParameters.parameters();
411  mainTable +=
412  "| # | QopT | Theta | Phi | d0 | z0 |\n"
413  "|---------------------------------------------------------------------------------------------|\n";
414  mainTable += std::format("| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
415  prototrackCounter,
416  parameters[Acts::eBoundQOverP],
417  parameters[Acts::eBoundTheta],
418  parameters[Acts::eBoundPhi],
419  parameters[Acts::eBoundLoc0],
420  parameters[Acts::eBoundLoc1]);
421 
422  const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
423  unsigned int measurementCounter = 0;
424  if (measurements->size())
425  {
426  mainTable +=
427  "| _____________________________________________________________________________________|\n"
428  "| | | type | Global coordinates | HashID | Identifier |\n"
429  "| | ## | | x | y | z | | |\n"
430  "| | |...........................................................................|\n";
431 
432  }
433  for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
434  {
435  ++measurementCounter;
436  const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
437  if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) {
438  const xAOD::PixelCluster* pixelCluster = dynamic_cast<const xAOD::PixelCluster*>(&measurement);
439  mainTable += std::format("| | {:>6} | Pixel | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
440  measurementCounter,
441  pixelCluster->globalPosition().cast<double>().x(),
442  pixelCluster->globalPosition().cast<double>().y(),
443  pixelCluster->globalPosition().cast<double>().z(),
444  pixelCluster->identifierHash(),
445  pixelCluster->identifier());
446  }
447  else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) {
448  const xAOD::StripCluster* stripCluster = dynamic_cast<const xAOD::StripCluster*>(&measurement);
449  mainTable += std::format("| | {:>6} | Strip | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
450  measurementCounter,
451  stripCluster->globalPosition().cast<double>().x(),
452  stripCluster->globalPosition().cast<double>().y(),
453  stripCluster->globalPosition().cast<double>().z(),
454  stripCluster->identifierHash(),
455  stripCluster->identifier());
456  }
457  }
458  mainTable += "|---------------------------------------------------------------------------------------------|\n";
459  }
460  ATH_MSG_INFO("Printing out prototracks coming from " << FPGAPrototracks.key() << mainTable);
461 }

◆ printFPGARoads()

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

Definition at line 252 of file FPGATrackSimReportingAlg.cxx.

253 {
254  std::string mainTable = "\n"
255  "|--------------------------------------------------------------------------------------------------|\n"
256  "| # | SubRegion | xBin | yBin | X | Y | RoadID |\n"
257  "|--------------------------------------------------------------------------------------------------|\n";
258 
259  unsigned int roadCounter = 0, hitCounter = 0;
260  for (const FPGATrackSimRoad& road : *FPGARoads)
261  {
262  ++roadCounter;
263  mainTable += std::format("| {:>6} | {:>11} | {:>10} | {:>10} | {:>12} | {:>12} | {:>12} |\n",
264  roadCounter,
265  road.getSubRegion(),
266  road.getXBin(),
267  road.getYBin(),
268  road.getX(),
269  road.getY(),
270  road.getRoadID());
271  mainTable +=
272  "| __________________________________________________________________________________________|\n"
273  "| | layer | ## | type | Global coordinates | isReal |\n"
274  "| | | | | x | y | z | |\n"
275  "| |.........................................................................................|\n";
276  for (unsigned int i = 0; i < road.getNLayers(); ++i)
277  {
278  hitCounter = 0;
279  const std::vector<std::shared_ptr<const FPGATrackSimHit>>& hits = road.getHits(i);
280  for (auto const& hit : hits)
281  {
282  if (!hit) {
283  ATH_MSG_WARNING("Null pointer for FPGATrackSimHit");
284  continue;
285  }
286  try {
287  ++hitCounter;
288  mainTable += std::format("| | {:>9} | {:>6} | {:>8} | {:>13} | {:>13} | {:>13} | {:>7} |\n",
289  (hit->isMapped() ? hit->getLayer() : 9999),
290  hitCounter,
291  (hit->isPixel() ? "Pixel" : hit->isStrip() ? "Strip" : "FAILED"),
292  hit->getX(),
293  hit->getY(),
294  hit->getZ(),
295  hit->isReal());
296  } catch (const std::exception& e) {
297  ATH_MSG_ERROR("Exception while processing FPGATrackSimHit: " << e.what());
298  }
299 
300  }
301  }
302  mainTable += "|--------------------------------------------------------------------------------------------------|\n";
303  }
304  ATH_MSG_INFO("List of FPGA roads for " << FPGARoads.key() << mainTable);
305 }

◆ printFPGATracks()

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

Definition at line 325 of file FPGATrackSimReportingAlg.cxx.

326 {
327  std::string maintable = "\n|--------------------------------------------------------------------------------------------------|\n";
328  unsigned int trackCounter = 0;
329  for (auto const& track : *FPGATracks)
330  {
331  ++trackCounter;
332  maintable += "| # | Eta | Phi | D0 | Z0 | QOverPt | chi2/ndf |\n"
333  "|--------------------------------------------------------------------------------------------------|\n";
334 
335  try
336  {
337  maintable += std::format("| {:>6} | {:>12.8f} | {:>12.8f} | {:>12.8f} | {:>12.5f} | {:>12.9f} | {:>12.8f} |\n",
338  trackCounter,
339  track.getEta(),
340  track.getPhi(),
341  track.getD0(),
342  track.getZ0(),
343  track.getQOverPt(),
344  track.getChi2ndof());
345  }
346  catch (const std::exception& e)
347  {
348  ATH_MSG_ERROR("Exception while processing FPGATrackSimTrack: " << e.what());
349  continue;
350  }
351 
352  maintable += "|__________________________________________________________________________________________________|\n"
353  "| | ## | type | layer | Global coordinates | isReal | HashID |\n"
354  "| | | | | x | y | z | | |\n"
355  "| |.........................................................................................|\n";
356  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
357  unsigned int hitCounter = 0;
358  for (auto const& hit : hits)
359  {
360  try {
361  ++hitCounter;
362  maintable += std::format("| | {:>6} | {:>8} | {:>5} | {:>9.3f} | {:>9.3f} | {:>9.3f} | {:>6} | {:>14} |\n",
363  hitCounter,
364  (hit.isPixel() ? "Pixel" : hit.isStrip() ? "Strip" : "FAILED"),
365  hit.getLayer(),
366  hit.getX(),
367  hit.getY(),
368  hit.getZ(),
369  hit.isReal(),
370  hit.getIdentifierHash());
371  } catch (const std::exception& e) {
372  ATH_MSG_ERROR("Exception while processing FPGATrackSimHits: " << e.what());
373  }
374  }
375  maintable += "|--------------------------------------------------------------------------------------------------|\n";
376  }
377  ATH_MSG_INFO("List of FPGA tracks for " << FPGATracks.key() << maintable);
378 }

◆ printxAODClusters()

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

Definition at line 194 of file FPGATrackSimReportingAlg.cxx.

195 {
196  std::string mainTable = "\n"
197  "|=========================================================================================|\n"
198  "| # | Global coordinates | Hash ID | Identifier |\n"
199  "| | x | y | z | | |\n"
200  "|-----------------------------------------------------------------------------------------|\n";
201  unsigned int counter = 0;
202  for (const auto& cluster : *clusterContainer)
203  {
204  ++counter;
205  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>18} |\n",
206  counter,
207  cluster->globalPosition().x(),
208  cluster->globalPosition().y(),
209  cluster->globalPosition().z(),
210  cluster->identifierHash(),
211  cluster->identifier());
212  }
213  mainTable += "|=========================================================================================|";
214  ATH_MSG_INFO("Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
215 }

◆ printxAODSpacePoints()

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

Definition at line 223 of file FPGATrackSimReportingAlg.cxx.

224 {
225  std::string mainTable = "\n"
226  "|============================================================================|\n"
227  "| # | Global coordinates | element ID list |\n"
228  "| | x | y | z | |\n"
229  "|----------------------------------------------------------------------------|\n";
230  unsigned int counter = 0;
231  for (const auto& sp : *spContainer)
232  {
233  ++counter;
234  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
235  counter,
236  sp->globalPosition().x(),
237  sp->globalPosition().y(),
238  sp->globalPosition().z(),
239  sp->elementIdList()[0],
240  sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
241  }
242  mainTable += "|=========================================================================================|";
243  ATH_MSG_INFO("Printout of xAOD space points coming from " << spContainer.key() << mainTable );
244 }

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

381 {
382  unsigned int nPixelMeasurements, nStripMeasurements;
383  for (auto const& prototrack : *FPGAPrototracks)
384  {
385  nPixelMeasurements = 0, nStripMeasurements = 0;
386  const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
387  for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
388  {
389  const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
390  if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) ++nPixelMeasurements;
391  else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) ++nStripMeasurements;
392  }
393  m_pixelClustersPerPrototrack.push_back(nPixelMeasurements);
394  m_stripClustersPerPrototrack.push_back(nStripMeasurements);
395 
396  }
397  if (m_printoutForEveryEvent) printFPGAPrototracks(FPGAPrototracks);
398 }

◆ processFPGARoads()

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

Definition at line 247 of file FPGATrackSimReportingAlg.cxx.

248 {
249  if (m_printoutForEveryEvent) printFPGARoads(FPGARoads);
250 }

◆ processFPGATracks()

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

Definition at line 308 of file FPGATrackSimReportingAlg.cxx.

309 {
310  for (auto const& track : *FPGATracks)
311  {
312  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
313  uint32_t pixelHits = 0, stripHits = 0;
314  for (const FPGATrackSimHit& hit : hits)
315  {
316  if (hit.isPixel()) ++pixelHits;
317  if (hit.isStrip()) ++stripHits;
318  }
319  m_pixelClustersPerFPGATrack.push_back(pixelHits);
320  m_stripClustersPerFPGATrack.push_back(stripHits);
321  }
322  if (m_printoutForEveryEvent) printFPGATracks(FPGATracks);
323 }

◆ processxAODClusters()

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

Definition at line 188 of file FPGATrackSimReportingAlg.cxx.

189 {
190  if (m_printoutForEveryEvent) printxAODClusters(clusterContainer);
191 }

◆ processxAODSpacePoints()

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

Definition at line 218 of file FPGATrackSimReportingAlg.cxx.

219 {
221 }

◆ 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  {
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 38 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 38 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 39 of file FPGATrackSimReportingAlg.h.

◆ ATLAS_THREAD_SAFE [4/6]

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

Definition at line 39 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 41 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 42 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 75 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 71 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 69 of file FPGATrackSimReportingAlg.h.

◆ m_FPGARoadsKey

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

Definition at line 65 of file FPGATrackSimReportingAlg.h.

◆ m_FPGATracksKey

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

Definition at line 67 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 45 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 44 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 48 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 58 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 53 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:48
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSim::FPGATrackSimReportingAlg::printxAODSpacePoints
void printxAODSpacePoints(SG::ReadHandle< DataVector< xAOD::SpacePoint >> &spContainer) const
Definition: FPGATrackSimReportingAlg.cxx:223
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:58
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::m_FPGAProtoTrackCollections
SG::ReadHandleKeyArray< ActsTrk::ProtoTrackCollection > m_FPGAProtoTrackCollections
Definition: FPGATrackSimReportingAlg.h:69
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:27
FPGATrackSim::FPGATrackSimReportingAlg::printFPGATracks
void printFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:325
FPGATrackSim::FPGATrackSimReportingAlg::m_printoutForEveryEvent
Gaudi::Property< bool > m_printoutForEveryEvent
Definition: FPGATrackSimReportingAlg.h:44
FPGATrackSim::FPGATrackSimReportingAlg::printFPGAPrototracks
void printFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition: FPGATrackSimReportingAlg.cxx:400
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:67
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:75
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
FPGATrackSim::FPGATrackSimReportingAlg::printFPGARoads
void printFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition: FPGATrackSimReportingAlg.cxx:252
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:65
FPGATrackSim::FPGATrackSimReportingAlg::m_isDataPrep
Gaudi::Property< bool > m_isDataPrep
Definition: FPGATrackSimReportingAlg.h:45
FPGATrackSim::FPGATrackSimReportingAlg::processFPGARoads
void processFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition: FPGATrackSimReportingAlg.cxx:247
FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks
void processFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:308
Trk::pixelCluster
@ pixelCluster
Definition: MeasurementType.h:22
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
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:53
FPGATrackSim::FPGATrackSimReportingAlg::processxAODSpacePoints
void processxAODSpacePoints(SG::ReadHandle< DataVector< xAOD::SpacePoint >> &spContainer) const
Definition: FPGATrackSimReportingAlg.cxx:218
FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks
void processFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition: FPGATrackSimReportingAlg.cxx:380
test_pyathena.counter
counter
Definition: test_pyathena.py:15
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsTrackCollections
SG::ReadHandleKeyArray< ActsTrk::TrackContainer > m_ActsTrackCollections
Definition: FPGATrackSimReportingAlg.h:71
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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:194
ServiceHandle< ICondSvc >