ATLAS Offline Software
FPGATrackSimReportingAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 #include "FPGATrackSimReportingAlg.h"
5 
6 
7 
8 FPGATrackSim::FPGATrackSimReportingAlg::FPGATrackSimReportingAlg(const std::string& name, ISvcLocator* pSvcLocator) : AthReentrantAlgorithm(name, pSvcLocator) {
9 }
10 
11 StatusCode FPGATrackSim::FPGATrackSimReportingAlg::initialize()
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_FPGAProtoTrackCollection.initialize(!m_isDataPrep));
18  ATH_CHECK(m_FPGATracksKey.initialize(!m_isDataPrep));
19 
20  return StatusCode::SUCCESS;
21 }
22 
23 StatusCode FPGATrackSim::FPGATrackSimReportingAlg::execute(const EventContext& ctx) const
24 {
25  // Process xAOD Pixel Clusters
26  std::vector<SG::ReadHandle<xAOD::PixelClusterContainer>> xAODPixelClusterContainers = m_xAODPixelClusterContainerKeys.makeHandles(ctx);
27  for (SG::ReadHandle<xAOD::PixelClusterContainer>& clusterContainer : xAODPixelClusterContainers)
28  {
29  if (!clusterContainer.isValid()) {
30  ATH_MSG_ERROR("Invalid SG key " << clusterContainer.key());
31  return StatusCode::FAILURE;
32  }
33  processxAODClusters<xAOD::PixelCluster>(clusterContainer);
34  }
35  // Process xAOD Strip Clusters
36  std::vector<SG::ReadHandle<xAOD::StripClusterContainer>> xAODStripClusterContainers = m_xAODStripClusterContainerKeys.makeHandles(ctx);
37  for (SG::ReadHandle<xAOD::StripClusterContainer>& clusterContainer : xAODStripClusterContainers)
38  {
39  if (!clusterContainer.isValid()) {
40  ATH_MSG_ERROR("Invalid SG key " << clusterContainer.key());
41  return StatusCode::FAILURE;
42  }
43  processxAODClusters<xAOD::StripCluster>(clusterContainer);
44  }
45  // Process xAOD SpacePoints
46  std::vector<SG::ReadHandle<xAOD::SpacePointContainer>> xAODSpacePointContainers = m_xAODSpacePointContainerKeys.makeHandles(ctx);
47  for (SG::ReadHandle<xAOD::SpacePointContainer>& spContainer : xAODSpacePointContainers)
48  {
49  if (!spContainer.isValid()) {
50  ATH_MSG_WARNING("Invalid SG key " << spContainer.key());
51  }
52  else {processxAODSpacePoints(spContainer);}
53  }
54  if (!m_isDataPrep.value()) {
55  // Process FPGATrackSim Roads
56  SG::ReadHandle<FPGATrackSimRoadCollection> FPGATrackSimRoads(m_FPGARoadsKey, ctx);
57  if (!FPGATrackSimRoads.isValid()) {
58  ATH_MSG_ERROR("Could not find FPGA Roads Collection with key " << FPGATrackSimRoads.key());
59  return StatusCode::FAILURE;
60  }
61  processFPGARoads(FPGATrackSimRoads);
62 
63  // Process FPGATrackSim Tracks
64  SG::ReadHandle<FPGATrackSimTrackCollection> FPGATrackSimTracks(m_FPGATracksKey, ctx);
65  if (!FPGATrackSimTracks.isValid()) {
66  ATH_MSG_ERROR("Could not find FPGA Track Collection with key " << FPGATrackSimTracks.key());
67  return StatusCode::FAILURE;
68  }
69  processFPGATracks(FPGATrackSimTracks);
70 
71  // Process FPGATrackSim Prototracks
72  SG::ReadHandle<ActsTrk::ProtoTrackCollection> FPGATrackSimProtoTracks(m_FPGAProtoTrackCollection, ctx);
73  if (!FPGATrackSimProtoTracks.isValid()) {
74  ATH_MSG_ERROR("Could not find FPGA Prototrack Collection with key " << FPGATrackSimProtoTracks.key());
75  return StatusCode::FAILURE;
76  }
77  processFPGAPrototracks(FPGATrackSimProtoTracks);
78  }
79  return StatusCode::SUCCESS;
80 }
81 
82 StatusCode FPGATrackSim::FPGATrackSimReportingAlg::finalize()
83 {
84  ATH_MSG_INFO("Printing statistics for FPGA objects");
85 
86  if (!m_isDataPrep.value()) {
87  // Printing summary for clusters/FPGATracks
88  std::string summaryTableFPGATracks = "\n"
89  "Number of measurements for FPGA Tracks\n"
90  "|-----------------------------------|\n"
91  "| | min | max | Avg |\n"
92  "|-----------------------------------|\n";
93 
94  if (not m_pixelClustersPerFPGATrack.empty()) {
95  summaryTableFPGATracks += std::format("| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
96  *std::min_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
97  *std::max_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
98  std::accumulate(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end(), 0.0) / m_pixelClustersPerFPGATrack.size());
99  }
100  else summaryTableFPGATracks += std::format("| Pixels | ---- | ---- | inf |\n");
101 
102  if (not m_stripClustersPerFPGATrack.empty()) {
103  summaryTableFPGATracks += std::format("| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
104  *std::min_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
105  *std::max_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
106  std::accumulate(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end(), 0.0) / m_stripClustersPerFPGATrack.size());
107  }
108  else summaryTableFPGATracks += std::format("| Strips | ---- | ---- | inf |\n");
109 
110  summaryTableFPGATracks += "|-----------------------------------|";
111  ATH_MSG_INFO( summaryTableFPGATracks );
112 
113 
114  // Printing summary for clusters/prototracks
115  std::string summaryTableFPGAPrototracks = std::format("\n"
116  "Number of measurements for FPGA Prototracks\n"
117  "|-----------------------------------|\n"
118  "| | min | max | Avg |\n"
119  "|-----------------------------------|\n");
120 
121  if (not m_pixelClustersPerPrototrack.empty()) {
122  summaryTableFPGAPrototracks += std::format("| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
123  *std::min_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
124  *std::max_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
125  std::accumulate(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end(), 0.0) / m_pixelClustersPerPrototrack.size());
126  }
127  else summaryTableFPGAPrototracks += std::format("| Pixels | ---- | ---- | inf |\n");
128 
129  if (not m_stripClustersPerPrototrack.empty()) {
130  summaryTableFPGAPrototracks += std::format("| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
131  *std::min_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
132  *std::max_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
133  std::accumulate(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end(), 0.0) / m_stripClustersPerPrototrack.size());
134  }
135  else summaryTableFPGAPrototracks += std::format("| Strips | ---- | ---- | inf |\n");
136 
137  summaryTableFPGAPrototracks += "|-----------------------------------|";
138  ATH_MSG_INFO( summaryTableFPGAPrototracks );
139  }
140 
141  return StatusCode::SUCCESS;
142 }
143 
144 template <class XAOD_CLUSTER>
145 void FPGATrackSim::FPGATrackSimReportingAlg::processxAODClusters(SG::ReadHandle<DataVector< XAOD_CLUSTER >>& clusterContainer) const
146 {
147  if (m_printoutForEveryEvent) printxAODClusters(clusterContainer);
148 }
149 
150 template <class XAOD_CLUSTER>
151 void FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters(SG::ReadHandle<DataVector< XAOD_CLUSTER >>& clusterContainer) const
152 {
153  std::string mainTable = "\n"
154  "|=========================================================================================|\n"
155  "| # | Global coordinates | Hash ID | Identifier |\n"
156  "| | x | y | z | | |\n"
157  "|-----------------------------------------------------------------------------------------|\n";
158  unsigned int counter = 0;
159  for (const auto& cluster : *clusterContainer)
160  {
161  ++counter;
162  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>18} |\n",
163  counter,
164  cluster->globalPosition().x(),
165  cluster->globalPosition().y(),
166  cluster->globalPosition().z(),
167  cluster->identifierHash(),
168  cluster->identifier());
169  }
170  mainTable += "|=========================================================================================|";
171  ATH_MSG_INFO("Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
172 }
173 
174 
175 void FPGATrackSim::FPGATrackSimReportingAlg::processxAODSpacePoints(SG::ReadHandle<DataVector< xAOD::SpacePoint >>& spContainer) const
176 {
177  if (m_printoutForEveryEvent) printxAODSpacePoints(spContainer);
178 }
179 
180 void FPGATrackSim::FPGATrackSimReportingAlg::printxAODSpacePoints(SG::ReadHandle<DataVector< xAOD::SpacePoint >>& spContainer) const
181 {
182  std::string mainTable = "\n"
183  "|============================================================================|\n"
184  "| # | Global coordinates | element ID list |\n"
185  "| | x | y | z | |\n"
186  "|----------------------------------------------------------------------------|\n";
187  unsigned int counter = 0;
188  for (const auto& sp : *spContainer)
189  {
190  ++counter;
191  mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
192  counter,
193  sp->globalPosition().x(),
194  sp->globalPosition().y(),
195  sp->globalPosition().z(),
196  sp->elementIdList()[0],
197  sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
198  }
199  mainTable += "|=========================================================================================|";
200  ATH_MSG_INFO("Printout of xAOD space points coming from " << spContainer.key() << mainTable );
201 }
202 
203 
204 void FPGATrackSim::FPGATrackSimReportingAlg::processFPGARoads(SG::ReadHandle<FPGATrackSimRoadCollection>& FPGARoads) const
205 {
206  if (m_printoutForEveryEvent) printFPGARoads(FPGARoads);
207 }
208 
209 void FPGATrackSim::FPGATrackSimReportingAlg::printFPGARoads(SG::ReadHandle<FPGATrackSimRoadCollection>& FPGARoads) const
210 {
211  std::string mainTable = "\n"
212  "|--------------------------------------------------------------------------------------------------|\n"
213  "| # | SubRegion | xBin | yBin | X | Y | RoadID |\n"
214  "|--------------------------------------------------------------------------------------------------|\n";
215 
216  unsigned int roadCounter = 0, hitCounter = 0;
217  for (const FPGATrackSimRoad& road : *FPGARoads)
218  {
219  ++roadCounter;
220  mainTable += std::format("| {:>6} | {:>11} | {:>10} | {:>10} | {:>12} | {:>12} | {:>12} |\n",
221  roadCounter,
222  road.getSubRegion(),
223  road.getXBin(),
224  road.getYBin(),
225  road.getX(),
226  road.getY(),
227  road.getRoadID());
228  mainTable +=
229  "| __________________________________________________________________________________________|\n"
230  "| | layer | ## | type | Global coordinates | isReal |\n"
231  "| | | | | x | y | z | |\n"
232  "| |.........................................................................................|\n";
233  for (unsigned int i = 0; i < road.getNLayers(); ++i)
234  {
235  hitCounter = 0;
236  const std::vector <std::shared_ptr<const FPGATrackSimHit>>& hits = road.getHits(i);
237  for (auto const& hit : hits)
238  {
239  ++hitCounter;
240  mainTable += std::format("| | {:>9} | {:>6} | {:>8} | {:>13} | {:>13} | {:>13} | {:>7} |\n",
241  (hit->isMapped() ? hit->getLayer() : 9999),
242  hitCounter,
243  (hit->isPixel() ? "Pixel" : hit->isStrip() ? "Strip" : "FAILED"),
244  hit->getX(),
245  hit->getY(),
246  hit->getZ(),
247  hit->isReal());
248  }
249  }
250  mainTable += "|--------------------------------------------------------------------------------------------------|\n";
251  }
252  ATH_MSG_INFO("List of FPGA roads for " << FPGARoads.key() << mainTable);
253 }
254 
255 
256 void FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks(SG::ReadHandle<FPGATrackSimTrackCollection>& FPGATracks) const
257 {
258  for (auto const& track : *FPGATracks)
259  {
260  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
261  uint32_t pixelHits = 0, stripHits = 0;
262  for (const FPGATrackSimHit& hit : hits)
263  {
264  if (hit.isPixel()) ++pixelHits;
265  if (hit.isStrip()) ++stripHits;
266  }
267  m_pixelClustersPerFPGATrack.push_back(pixelHits);
268  m_stripClustersPerFPGATrack.push_back(stripHits);
269  }
270  if (m_printoutForEveryEvent) printFPGATracks(FPGATracks);
271 }
272 
273 void FPGATrackSim::FPGATrackSimReportingAlg::printFPGATracks(SG::ReadHandle<FPGATrackSimTrackCollection>& FPGATracks) const
274 {
275 
276  std::string maintable = "\n|--------------------------------------------------------------------------------------------------|\n";
277  unsigned int trackCounter = 0;
278  for (auto const& track : *FPGATracks)
279  {
280  ++trackCounter;
281  maintable += "| # | Eta | Phi | D0 | Z0 | QOverPt | chi2/ndf |\n"
282  "|--------------------------------------------------------------------------------------------------|\n";
283 
284  maintable += std::format("| {:>6} | {:>12.8f} | {:>12.8f} | {:>12.8f} | {:>12.5f} | {:>12.9f} | {:>12.8f} |\n",
285  trackCounter,
286  track.getEta(),
287  track.getPhi(),
288  track.getD0(),
289  track.getZ0(),
290  track.getQOverPt(),
291  track.getChi2ndof());
292 
293  maintable += "|__________________________________________________________________________________________________|\n"
294  "| | ## | type | layer | Global coordinates | isReal | HashID |\n"
295  "| | | | | x | y | z | | |\n"
296  "| |.........................................................................................|\n";
297  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
298  unsigned int hitCounter = 0;
299  for (auto const& hit : hits)
300  {
301  ++hitCounter;
302  maintable += std::format("| | {:>6} | {:>8} | {:>5} | {:>9.3f} | {:>9.3f} | {:>9.3f} | {:>6} | {:>14} |\n",
303  hitCounter,
304  (hit.isPixel() ? "Pixel" : hit.isStrip() ? "Strip" : "FAILED"),
305  hit.getLayer(),
306  hit.getX(),
307  hit.getY(),
308  hit.getZ(),
309  hit.isReal(),
310  hit.getIdentifierHash());
311  }
312  maintable += "|--------------------------------------------------------------------------------------------------|\n";
313  }
314  ATH_MSG_INFO("List of FPGA tracks for " << FPGATracks.key() << maintable);
315 }
316 
317 void FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks(SG::ReadHandle<ActsTrk::ProtoTrackCollection>& FPGAPrototracks) const
318 {
319  unsigned int nPixelMeasurements, nStripMeasurements;
320  for (auto const& prototrack : *FPGAPrototracks)
321  {
322  nPixelMeasurements = 0, nStripMeasurements = 0;
323  const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
324  for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
325  {
326  const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
327  if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) ++nPixelMeasurements;
328  else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) ++nStripMeasurements;
329  }
330  m_pixelClustersPerPrototrack.push_back(nPixelMeasurements);
331  m_stripClustersPerPrototrack.push_back(nStripMeasurements);
332 
333  }
334  if (m_printoutForEveryEvent) printFPGAPrototracks(FPGAPrototracks);
335 }
336 
337 void FPGATrackSim::FPGATrackSimReportingAlg::printFPGAPrototracks(SG::ReadHandle<ActsTrk::ProtoTrackCollection>& FPGAPrototracks) const
338 {
339  std::string mainTable = "\n";
340  if(not (*FPGAPrototracks).empty()) mainTable += "|---------------------------------------------------------------------------------------------|\n";
341 
342  unsigned int prototrackCounter = 0;
343  for (auto const& prototrack : *FPGAPrototracks)
344  {
345  ++prototrackCounter;
346  const Acts::BoundTrackParameters& initialParameters = *prototrack.parameters;
347  const Acts::BoundVector& parameters = initialParameters.parameters();
348  mainTable +=
349  "| # | QopT | Theta | Phi | d0 | z0 |\n"
350  "|---------------------------------------------------------------------------------------------|\n";
351  mainTable += std::format("| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
352  prototrackCounter,
353  parameters[Acts::eBoundQOverP],
354  parameters[Acts::eBoundTheta],
355  parameters[Acts::eBoundPhi],
356  parameters[Acts::eBoundLoc0],
357  parameters[Acts::eBoundLoc1]);
358 
359  const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
360  unsigned int measurementCounter = 0;
361  if (measurements->size())
362  {
363  mainTable +=
364  "| _____________________________________________________________________________________|\n"
365  "| | | type | Global coordinates | HashID | Identifier |\n"
366  "| | ## | | x | y | z | | |\n"
367  "| | |...........................................................................|\n";
368 
369  }
370  for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
371  {
372  ++measurementCounter;
373  const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
374  if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) {
375  const xAOD::PixelCluster* pixelCluster = dynamic_cast<const xAOD::PixelCluster*>(&measurement);
376  mainTable += std::format("| | {:>6} | Pixel | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
377  measurementCounter,
378  pixelCluster->globalPosition().cast<double>().x(),
379  pixelCluster->globalPosition().cast<double>().y(),
380  pixelCluster->globalPosition().cast<double>().z(),
381  pixelCluster->identifierHash(),
382  pixelCluster->identifier());
383  }
384  else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) {
385  const xAOD::StripCluster* stripCluster = dynamic_cast<const xAOD::StripCluster*>(&measurement);
386  mainTable += std::format("| | {:>6} | Strip | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
387  measurementCounter,
388  stripCluster->globalPosition().cast<double>().x(),
389  stripCluster->globalPosition().cast<double>().y(),
390  stripCluster->globalPosition().cast<double>().z(),
391  stripCluster->identifierHash(),
392  stripCluster->identifier());
393  }
394  }
395  mainTable += "|---------------------------------------------------------------------------------------------|\n";
396  }
397  ATH_MSG_INFO("Printing out prototracks coming from " << FPGAPrototracks.key() << mainTable);
398 }
FPGATrackSim::FPGATrackSimReportingAlg::processxAODClusters
void processxAODClusters(SG::ReadHandle< DataVector< XAOD_CLUSTER >> &clusterContainer) const
Definition: FPGATrackSimReportingAlg.cxx:145
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSim::FPGATrackSimReportingAlg::printxAODSpacePoints
void printxAODSpacePoints(SG::ReadHandle< DataVector< xAOD::SpacePoint >> &spContainer) const
Definition: FPGATrackSimReportingAlg.cxx:180
vtune_athena.format
format
Definition: vtune_athena.py:14
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FPGATrackSim::FPGATrackSimReportingAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override final
Definition: FPGATrackSimReportingAlg.cxx:23
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
xAOD::UncalibMeasType::StripClusterType
@ StripClusterType
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
Trk::stripCluster
@ stripCluster
Definition: MeasurementType.h:23
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:83
FPGATrackSim::FPGATrackSimReportingAlg::printFPGATracks
void printFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:273
FPGATrackSim::FPGATrackSimReportingAlg::printFPGAPrototracks
void printFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition: FPGATrackSimReportingAlg.cxx:337
xAOD::UncalibratedMeasurement_v1
Definition: UncalibratedMeasurement_v1.h:13
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
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
FPGATrackSim::FPGATrackSimReportingAlg::initialize
virtual StatusCode initialize() override final
Definition: FPGATrackSimReportingAlg.cxx:11
xAOD::StripCluster_v1
Definition: StripCluster_v1.h:17
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
FPGATrackSim::FPGATrackSimReportingAlg::printFPGARoads
void printFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition: FPGATrackSimReportingAlg.cxx:209
ActsTrk::getUncalibratedMeasurement
const xAOD::UncalibratedMeasurement & getUncalibratedMeasurement(const ATLASUncalibSourceLink &source_link)
Definition: ATLASSourceLink.h:26
SG::VarHandleBase::key
virtual const std::string & key() const override final
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleBase.cxx:64
FPGATrackSim::FPGATrackSimReportingAlg::processFPGARoads
void processFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition: FPGATrackSimReportingAlg.cxx:204
FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks
void processFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition: FPGATrackSimReportingAlg.cxx:256
Trk::pixelCluster
@ pixelCluster
Definition: MeasurementType.h:22
xAOD::PixelCluster_v1
Definition: PixelCluster_v1.h:17
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
FPGATrackSim::FPGATrackSimReportingAlg::finalize
virtual StatusCode finalize() override final
Definition: FPGATrackSimReportingAlg.cxx:82
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
FPGATrackSimReportingAlg.h
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
FPGATrackSim::FPGATrackSimReportingAlg::processxAODSpacePoints
void processxAODSpacePoints(SG::ReadHandle< DataVector< xAOD::SpacePoint >> &spContainer) const
Definition: FPGATrackSimReportingAlg.cxx:175
FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks
void processFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition: FPGATrackSimReportingAlg.cxx:317
test_pyathena.counter
counter
Definition: test_pyathena.py:15
FPGATrackSim::FPGATrackSimReportingAlg::FPGATrackSimReportingAlg
FPGATrackSimReportingAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: FPGATrackSimReportingAlg.cxx:8
FPGATrackSimRoad
Definition: FPGATrackSimRoad.h:30
xAOD::UncalibMeasType::PixelClusterType
@ PixelClusterType
FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters
void printxAODClusters(SG::ReadHandle< DataVector< XAOD_CLUSTER >> &clusterContainer) const
Definition: FPGATrackSimReportingAlg.cxx:151
Generated on Tue Oct 1 2024 21:15:33 for ATLAS Offline Software by   doxygen 1.8.18