ATLAS Offline Software
Loading...
Searching...
No Matches
FPGATrackSimReportingAlg.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3*/
4#include "FPGATrackSimReportingAlg.h"
5
6#include <format>
7
8FPGATrackSim::FPGATrackSimReportingAlg::FPGATrackSimReportingAlg(const std::string& name, ISvcLocator* pSvcLocator) : AthReentrantAlgorithm(name, pSvcLocator) {
9}
10
26
27StatusCode FPGATrackSim::FPGATrackSimReportingAlg::execute(const EventContext& ctx) const
28{
29 // Process xAOD Pixel Clusters
30 std::vector<SG::ReadHandle<xAOD::PixelClusterContainer>> xAODPixelClusterContainers = m_xAODPixelClusterContainerKeys.makeHandles(ctx);
31 for (SG::ReadHandle<xAOD::PixelClusterContainer>& clusterContainer : xAODPixelClusterContainers)
32 {
33 if (!clusterContainer.isValid()) {
34 ATH_MSG_WARNING("SG key not available " << clusterContainer.key());
35 continue;
36 }
37 processxAODClusters<xAOD::PixelCluster>(clusterContainer);
38 }
39 // Process xAOD Strip Clusters
40 std::vector<SG::ReadHandle<xAOD::StripClusterContainer>> xAODStripClusterContainers = m_xAODStripClusterContainerKeys.makeHandles(ctx);
41 for (SG::ReadHandle<xAOD::StripClusterContainer>& clusterContainer : xAODStripClusterContainers)
42 {
43 if (!clusterContainer.isValid()) {
44 ATH_MSG_WARNING("SG key not available " << clusterContainer.key());
45 continue;
46 }
47 processxAODClusters<xAOD::StripCluster>(clusterContainer);
48 }
49 // Process xAOD SpacePoints
50 std::vector<SG::ReadHandle<xAOD::SpacePointContainer>> xAODSpacePointContainers = m_xAODSpacePointContainerKeys.makeHandles(ctx);
51 for (SG::ReadHandle<xAOD::SpacePointContainer>& spContainer : xAODSpacePointContainers)
52 {
53 if (!spContainer.isValid()) {
54 ATH_MSG_WARNING("SG key not available " << spContainer.key());
55 }
56 else {processxAODSpacePoints(spContainer);}
57 }
58 if (!m_isDataPrep.value()) {
59 // Process FPGATrackSim Roads
60 SG::ReadHandle<FPGATrackSimRoadCollection> FPGATrackSimRoads(m_FPGARoadsKey, ctx);
61 if (FPGATrackSimRoads.isValid()) {
62 processFPGARoads(FPGATrackSimRoads);
63 }
64 else ATH_MSG_WARNING("Could not find FPGA Roads Collection with key " << FPGATrackSimRoads.key());
65
66
67 // Process FPGATrackSim Tracks
68 SG::ReadHandle<FPGATrackSimTrackCollection> FPGATrackSimTracks(m_FPGATracksKey, ctx);
69 if (FPGATrackSimTracks.isValid()) {
70 processFPGATracks(FPGATrackSimTracks);
71 }
72 else ATH_MSG_WARNING("Could not find FPGA Track Collection with key " << FPGATrackSimTracks.key());
73
74 // Process FPGATrackSim Prototracks
75 std::vector<SG::ReadHandle<ActsTrk::ProtoTrackCollection>> FPGATrackSimProtoTracks = m_FPGAProtoTrackCollections.makeHandles(ctx);
76 for (SG::ReadHandle<ActsTrk::ProtoTrackCollection>& prototrackContainer : FPGATrackSimProtoTracks)
77 {
78 if (!prototrackContainer.isValid()) {
79 ATH_MSG_WARNING("SG key not available " << prototrackContainer.key());
80 continue;
81 }
82 processFPGAPrototracks(prototrackContainer);
83 }
84 } // if it's not the data preparation chain
85 // Process Acts tracks
86 std::vector<SG::ReadHandle<ActsTrk::TrackContainer>> FPGAActsTracks = m_ActsTrackCollections.makeHandles(ctx);
87 for (SG::ReadHandle<ActsTrk::TrackContainer>& actsTrackContainer : FPGAActsTracks)
88 {
89 if (actsTrackContainer.cptr()) ATH_MSG_DEBUG("Proccessing " << actsTrackContainer.key());
90 else continue;
91 // initialize the ReadHandle pair if necessarys
92 m_allActsTracks.try_emplace(actsTrackContainer.key(), std::vector<FPGATrackSimActsEventTracks>{});
93
94 // fetch acts tracks
95 m_allActsTracks[actsTrackContainer.key()].push_back(m_ActsInspectionTool->getActsTracks(*(actsTrackContainer.cptr())));
96
97 // initialize ReadHandle stats map for all tracks if necessary
98 m_actsTrackStats.try_emplace(actsTrackContainer.key(), std::map<Acts::TrackStateFlag, std::vector<uint32_t>>{});
99
100 m_actsTrackStats[actsTrackContainer.key()].emplace(
101 Acts::TrackStateFlag::IsOutlier, std::vector<uint32_t>{});
102 m_actsTrackStats[actsTrackContainer.key()].emplace(
103 Acts::TrackStateFlag::IsHole, std::vector<uint32_t>{});
104 m_actsTrackStats[actsTrackContainer.key()].emplace(
105 Acts::TrackStateFlag::HasMeasurement, std::vector<uint32_t>{});
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::IsOutlier].push_back(t_nOutliers);
115 m_actsTrackStats[actsTrackContainer.key()][Acts::TrackStateFlag::IsHole].push_back(t_nHoles);
116 m_actsTrackStats[actsTrackContainer.key()][Acts::TrackStateFlag::HasMeasurement].push_back(t_nMeasurements);
117 }
118 if (m_printoutForEveryEvent) ATH_MSG_INFO("ACTS tracks in " << actsTrackContainer.key() << m_ActsInspectionTool->getPrintoutActsEventTracks(m_allActsTracks[actsTrackContainer.key()].back()));
119 }
120
121 std::vector<SG::ReadHandle<ActsTrk::SeedContainer>> FPGAActsSeeds = m_ActsSeedCollections.makeHandles(ctx);
122
123 for (SG::ReadHandle<ActsTrk::SeedContainer>& actsTrackContainer : FPGAActsSeeds)
124 {
125 if (!actsTrackContainer.isValid()) {
126 ATH_MSG_WARNING("SG key not available " << actsTrackContainer.key());
127 continue;
128 }
129 processFPGASeeds(actsTrackContainer);
130 }
131
132
133 std::vector<SG::ReadHandle<ActsTrk::BoundTrackParametersContainer>> FPGAActsSeedsParam = m_ActsSeedParamCollections.makeHandles(ctx);
134
135 for (SG::ReadHandle<ActsTrk::BoundTrackParametersContainer>& actsTrackContainer : FPGAActsSeedsParam)
136 {
137 if (!actsTrackContainer.isValid()) {
138 ATH_MSG_WARNING("SG key not available " << actsTrackContainer.key());
139 continue;
140 }
141 processFPGASeedsParam(actsTrackContainer);
142 }
143
144 return StatusCode::SUCCESS;
145}
146
147StatusCode FPGATrackSim::FPGATrackSimReportingAlg::finalize()
148{
149 ATH_MSG_INFO("Printing statistics for FPGA objects");
150
151 if (!m_isDataPrep.value()) {
152 // Printing summary for clusters/FPGATracks
153 std::string summaryTableFPGATracks = "\n"
154 "Number of measurements for FPGA Tracks\n"
155 "|-----------------------------------|\n"
156 "| | min | max | Avg |\n"
157 "|-----------------------------------|\n";
158
159 if (not m_pixelClustersPerFPGATrack.empty()) {
160 summaryTableFPGATracks += std::format("| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
161 *std::min_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
162 *std::max_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
163 std::accumulate(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end(), 0.0) / m_pixelClustersPerFPGATrack.size());
164 }
165 else summaryTableFPGATracks += std::format("| Pixels | ---- | ---- | inf |\n");
166
167 if (not m_stripClustersPerFPGATrack.empty()) {
168 summaryTableFPGATracks += std::format("| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
169 *std::min_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
170 *std::max_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
171 std::accumulate(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end(), 0.0) / m_stripClustersPerFPGATrack.size());
172 }
173 else summaryTableFPGATracks += std::format("| Strips | ---- | ---- | inf |\n");
174
175 summaryTableFPGATracks += "|-----------------------------------|";
176 ATH_MSG_INFO( summaryTableFPGATracks );
177
178
179 // Printing summary for clusters/prototracks
180 std::string summaryTableFPGAPrototracks = std::format("\n"
181 "Number of measurements for FPGA Prototracks\n"
182 "|-----------------------------------|\n"
183 "| | min | max | Avg |\n"
184 "|-----------------------------------|\n");
185
186 if (not m_pixelClustersPerPrototrack.empty()) {
187 summaryTableFPGAPrototracks += std::format("| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
188 *std::min_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
189 *std::max_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
190 std::accumulate(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end(), 0.0) / m_pixelClustersPerPrototrack.size());
191 }
192 else summaryTableFPGAPrototracks += std::format("| Pixels | ---- | ---- | inf |\n");
193
194 if (not m_stripClustersPerPrototrack.empty()) {
195 summaryTableFPGAPrototracks += std::format("| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
196 *std::min_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
197 *std::max_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
198 std::accumulate(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end(), 0.0) / m_stripClustersPerPrototrack.size());
199 }
200 else summaryTableFPGAPrototracks += std::format("| Strips | ---- | ---- | inf |\n");
201
202 summaryTableFPGAPrototracks += "|-----------------------------------|";
203 ATH_MSG_INFO( summaryTableFPGAPrototracks );
204 }
205
206 ATH_MSG_INFO(m_ActsInspectionTool->getPrintoutStatistics(m_actsTrackStats));
207 return StatusCode::SUCCESS;
208}
209
210template <class XAOD_CLUSTER>
215
216template <class XAOD_CLUSTER>
217void FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters(SG::ReadHandle<DataVector< XAOD_CLUSTER >>& clusterContainer) const
218{
219 std::string mainTable = "\n"
220 "|=========================================================================================|\n"
221 "| # | Global coordinates | Hash ID | Identifier |\n"
222 "| | x | y | z | | |\n"
223 "|-----------------------------------------------------------------------------------------|\n";
224 unsigned int counter = 0;
225 for (const auto& cluster : *clusterContainer)
226 {
227 ++counter;
228 mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>18} |\n",
229 counter,
230 cluster->globalPosition().x(),
231 cluster->globalPosition().y(),
232 cluster->globalPosition().z(),
233 cluster->identifierHash(),
234 cluster->identifier());
235 }
236 mainTable += "|=========================================================================================|";
237 ATH_MSG_INFO("Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
238}
239
240template <>
241void FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters(SG::ReadHandle<DataVector< xAOD::PixelCluster >>& clusterContainer) const
242{
243 std::string mainTable = "\n"
244 "|===================================================================================================================================================================================|\n"
245 "| # | Global coordinates | Local coordinates | Local Covariance | Size | Hash ID | Identifier |\n"
246 "| | x | y | z | 0 | 1 | 0,0 | 1,1 | phi | eta | | |\n"
247 "|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n";
248 unsigned int counter = 0;
249 std::map<int, int> counterMap;
250 for (const xAOD::PixelCluster* cluster : *clusterContainer)
251 {
252 ++counter;
253
254 mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:#018x} |\n",
255 counter,
256 cluster->globalPosition().x(),
257 cluster->globalPosition().y(),
258 cluster->globalPosition().z(),
259 cluster->localPosition<2>()[0],
260 cluster->localPosition<2>()[1],
261 cluster->localCovariance<2>()(0, 0),
262 cluster->localCovariance<2>()(1, 1),
263 cluster->channelsInPhi(),
264 cluster->channelsInEta(),
265 cluster->identifierHash(),
266 cluster->identifier());
267
268 counterMap[cluster->identifierHash()]++;
269 }
270 mainTable += "|=========================================================================================|";
271
272 ATH_MSG_INFO("Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
273}
274
275template <>
276void FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters(SG::ReadHandle<DataVector< xAOD::StripCluster >>& clusterContainer) const
277{
278 std::string mainTable = "\n"
279 "|======================================================================================================================================|\n"
280 "| # | Global coordinates | Local | Local | Size | Hash ID | Identifier |\n"
281 "| | x | y | z | Pos | Cov | | | |\n"
282 "|--------------------------------------------------------------------------------------------------------------------------------------|\n";
283 unsigned int counter = 0;
284 std::map<int, int> counterMap;
285 for (const xAOD::StripCluster* cluster : *clusterContainer)
286 {
287 ++counter;
288
289 mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:>12} | {:#018x} |\n",
290 counter,
291 cluster->globalPosition().x(),
292 cluster->globalPosition().y(),
293 cluster->globalPosition().z(),
294 cluster->localPosition<1>()[0],
295 cluster->localCovariance<1>()(0, 0),
296 cluster->channelsInPhi(),
297 cluster->identifierHash(),
298 cluster->identifier());
299
300 counterMap[cluster->identifierHash()]++;
301 }
302 mainTable += "|=========================================================================================|";
303
304 ATH_MSG_INFO("Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
305}
306
307
312
313void FPGATrackSim::FPGATrackSimReportingAlg::printxAODSpacePoints(SG::ReadHandle<DataVector< xAOD::SpacePoint >>& spContainer) const
314{
315 std::string mainTable = "\n"
316 "|============================================================================|\n"
317 "| # | Global coordinates | element ID list |\n"
318 "| | x | y | z | |\n"
319 "|----------------------------------------------------------------------------|\n";
320 unsigned int counter = 0;
321 for (const auto sp : *spContainer)
322 {
323 ++counter;
324 mainTable += std::format("| {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
325 counter,
326 sp->globalPosition().x(),
327 sp->globalPosition().y(),
328 sp->globalPosition().z(),
329 sp->elementIdList()[0],
330 sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
331 }
332 mainTable += "|=========================================================================================|";
333 ATH_MSG_INFO("Printout of xAOD space points coming from " << spContainer.key() << mainTable );
334}
335
336
341
342void FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeeds(SG::ReadHandle<ActsTrk::SeedContainer>& seedContainer) const
343{
344 std::string mainTable = "\n"
345 "|=====================================================================================|\n"
346 "| # | seed | Global coordinates | element ID list |\n"
347 "| | i | x | y | z | |\n"
348 "|-------------------------------------------------------------------------------------|\n";
349 unsigned int counter = 0;
350 for (const auto thisTrack : *seedContainer)
351 {
352 auto spList = thisTrack.sp();
353 ++counter;
354 for(int i = 0; i < 3; i++)
355 {
356 auto sp = spList.at(i);
357 mainTable += std::format("| {:>6} | {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
358 counter,
359 i,
360 sp->globalPosition().x(),
361 sp->globalPosition().y(),
362 sp->globalPosition().z(),
363 sp->elementIdList()[0],
364 sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
365 }
366
367 }
368 mainTable += "|=========================================================================================|";
369 ATH_MSG_INFO("Printout of ACTS seeds coming from " << seedContainer.key() << mainTable );
370}
371
372
377
378void FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeedsParam(SG::ReadHandle<ActsTrk::BoundTrackParametersContainer>& seedContainer) const
379{
380 std::string mainTable = "\n"
381 "|=============================================================================================|\n"
382 "| # | QopT | Theta | Phi | d0 | z0 |\n"
383 "|---------------------------------------------------------------------------------------------|\n";
384 unsigned int counter = 0;
385 for (const auto paramSet : *seedContainer)
386 {
387 ++counter;
388 auto parameters = paramSet->parameters();
389 mainTable += std::format("| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
390 counter,
391 parameters[Acts::eBoundQOverP],
392 parameters[Acts::eBoundTheta],
393 parameters[Acts::eBoundPhi],
394 parameters[Acts::eBoundLoc0],
395 parameters[Acts::eBoundLoc1]);
396 }
397 mainTable += "|=========================================================================================|";
398 ATH_MSG_INFO("Printout of ACTS seeds Param coming from " << seedContainer.key() << mainTable );
399}
400
401
402
403
404
409
410void FPGATrackSim::FPGATrackSimReportingAlg::printFPGARoads(SG::ReadHandle<FPGATrackSimRoadCollection>& FPGARoads) const
411{
412 std::string mainTable = "\n"
413 "|--------------------------------------------------------------------------------------------------|\n"
414 "| # | SubRegion | xBin | yBin | X | Y | RoadID | Sector |\n"
415 "|--------------------------------------------------------------------------------------------------|\n";
416
417 unsigned int roadCounter = 0, hitCounter = 0;
418 for (const FPGATrackSimRoad& road : *FPGARoads)
419 {
420 ++roadCounter;
421 mainTable += std::format("| {:>6} | {:>11} | {:>8} | {:>8} | {:>12} | {:>12} | {:>10} | {:>8} |\n",
422 roadCounter,
423 road.getSubRegion(),
424 road.getXBin(),
425 road.getYBin(),
426 road.getX(),
427 road.getY(),
428 road.getRoadID(),
429 road.getSector());
430 mainTable +=
431 "| __________________________________________________________________________________________|\n"
432 "| | layer | ## | type | Global coordinates | isReal |\n"
433 "| | | | | x | y | z | |\n"
434 "| |.........................................................................................|\n";
435 for (unsigned int i = 0; i < road.getNLayers(); ++i)
436 {
437 hitCounter = 0;
438 const std::vector<std::shared_ptr<const FPGATrackSimHit>>& hits = road.getHitPtrs(i);
439 for (auto const& hit : hits)
440 {
441 if (!hit) {
442 ATH_MSG_WARNING("Null pointer for FPGATrackSimHit");
443 continue;
444 }
445 try {
446 ++hitCounter;
447 mainTable += std::format("| | {:>9} | {:>6} | {:>8} | {:>13} | {:>13} | {:>13} | {:>7} |\n",
448 (hit->isMapped() ? hit->getLayer() : 9999),
449 hitCounter,
450 (hit->isPixel() ? "Pixel" : hit->isStrip() ? "Strip" : "FAILED"),
451 hit->getX(),
452 hit->getY(),
453 hit->getZ(),
454 hit->isReal());
455 } catch (const std::exception& e) {
456 ATH_MSG_ERROR("Exception while processing FPGATrackSimHit: " << e.what());
457 }
458
459 }
460 }
461 mainTable += "|--------------------------------------------------------------------------------------------------|\n";
462 }
463 ATH_MSG_INFO("List of FPGA roads for " << FPGARoads.key() << mainTable);
464}
465
466
467void FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks(SG::ReadHandle<FPGATrackSimTrackCollection>& FPGATracks) const
468{
469 for (auto const& track : *FPGATracks)
470 {
471 const auto& hits = track.getFPGATrackSimHitPtrs();
472 uint32_t pixelHits = 0, stripHits = 0;
473 for (const auto& hit_ptr : hits)
474 {
475 if (!hit_ptr) {
476 throw std::runtime_error("Null hit pointer in track");
477 }
478 if (hit_ptr->isPixel()) ++pixelHits;
479 if (hit_ptr->isStrip()) ++stripHits;
480 }
481 m_pixelClustersPerFPGATrack.push_back(pixelHits);
482 m_stripClustersPerFPGATrack.push_back(stripHits);
483 }
484 if (m_printoutForEveryEvent) printFPGATracks(FPGATracks);
485}
486
487void FPGATrackSim::FPGATrackSimReportingAlg::printFPGATracks(SG::ReadHandle<FPGATrackSimTrackCollection>& FPGATracks) const
488{
489 std::string maintable = "\n|--------------------------------------------------------------------------------------------------|\n";
490 unsigned int trackCounter = 0;
491 for (auto const& track : *FPGATracks)
492 {
493 ++trackCounter;
494 maintable += "| # | Eta | Phi | D0 | Z0 | QOverPt | chi2/ndf |\n"
495 "|--------------------------------------------------------------------------------------------------|\n";
496
497 try
498 {
499 maintable += std::format("| {:>6} | {:>12.8f} | {:>12.8f} | {:>12.8f} | {:>12.5f} | {:>12.9f} | {:>12.8f} |\n",
500 trackCounter,
501 track.getEta(),
502 track.getPhi(),
503 track.getD0(),
504 track.getZ0(),
505 track.getQOverPt(),
506 track.getChi2ndof());
507 }
508 catch (const std::exception& e)
509 {
510 ATH_MSG_ERROR("Exception while processing FPGATrackSimTrack: " << e.what());
511 continue;
512 }
513
514 maintable += "|__________________________________________________________________________________________________|\n"
515 "| | ## | type | layer | Global coordinates | isReal | HashID |\n"
516 "| | | | | x | y | z | | |\n"
517 "| |.........................................................................................|\n";
518 const auto& hits = track.getFPGATrackSimHitPtrs();
519 unsigned int hitCounter = 0;
520 for (const auto& hit_ptr : hits)
521 {
522 if (!hit_ptr) {
523 throw std::runtime_error("Null hit pointer in track");
524 }
525 try {
526 ++hitCounter;
527 maintable += std::format("| | {:>6} | {:>8} | {:>5} | {:>9.3f} | {:>9.3f} | {:>9.3f} | {:>6} | {:>14} |\n",
528 hitCounter,
529 (hit_ptr->isPixel() ? "Pixel" : hit_ptr->isStrip() ? "Strip" : "FAILED"),
530 hit_ptr->getLayer(),
531 hit_ptr->getX(),
532 hit_ptr->getY(),
533 hit_ptr->getZ(),
534 hit_ptr->isReal(),
535 hit_ptr->getIdentifierHash());
536 } catch (const std::exception& e) {
537 ATH_MSG_ERROR("Exception while processing FPGATrackSimHits: " << e.what());
538 }
539 }
540 maintable += "|--------------------------------------------------------------------------------------------------|\n";
541 }
542 ATH_MSG_INFO("List of FPGA tracks for " << FPGATracks.key() << maintable);
543}
544
545void FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks(SG::ReadHandle<ActsTrk::ProtoTrackCollection>& FPGAPrototracks) const
546{
547 unsigned int nPixelMeasurements, nStripMeasurements;
548 for (auto const& prototrack : *FPGAPrototracks)
549 {
550 nPixelMeasurements = 0, nStripMeasurements = 0;
551 const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
552 for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
553 {
554 const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
555 if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) ++nPixelMeasurements;
556 else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) ++nStripMeasurements;
557 }
558 m_pixelClustersPerPrototrack.push_back(nPixelMeasurements);
559 m_stripClustersPerPrototrack.push_back(nStripMeasurements);
560
561 }
562 if (m_printoutForEveryEvent) printFPGAPrototracks(FPGAPrototracks);
563}
564
565void FPGATrackSim::FPGATrackSimReportingAlg::printFPGAPrototracks(SG::ReadHandle<ActsTrk::ProtoTrackCollection>& FPGAPrototracks) const
566{
567 std::string mainTable = "\n";
568 if(not (*FPGAPrototracks).empty()) mainTable += "|---------------------------------------------------------------------------------------------|\n";
569
570 unsigned int prototrackCounter = 0;
571 for (auto const& prototrack : *FPGAPrototracks)
572 {
573 ++prototrackCounter;
574 const Acts::BoundTrackParameters& initialParameters = *prototrack.parameters;
575 const Acts::BoundVector& parameters = initialParameters.parameters();
576 mainTable +=
577 "| # | QopT | Theta | Phi | d0 | z0 |\n"
578 "|---------------------------------------------------------------------------------------------|\n";
579 mainTable += std::format("| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
580 prototrackCounter,
581 parameters[Acts::eBoundQOverP],
582 parameters[Acts::eBoundTheta],
583 parameters[Acts::eBoundPhi],
584 parameters[Acts::eBoundLoc0],
585 parameters[Acts::eBoundLoc1]);
586
587 const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
588 unsigned int measurementCounter = 0;
589 if (measurements->size())
590 {
591 mainTable +=
592 "| _____________________________________________________________________________________|\n"
593 "| | | type | Global coordinates | HashID | Identifier |\n"
594 "| | ## | | x | y | z | | |\n"
595 "| | |...........................................................................|\n";
596
597 }
598 for (const ActsTrk::ATLASUncalibSourceLink& measurementLink : *measurements)
599 {
600 ++measurementCounter;
601 const xAOD::UncalibratedMeasurement& measurement = ActsTrk::getUncalibratedMeasurement(measurementLink);
602 if (measurement.type() == xAOD::UncalibMeasType::PixelClusterType) {
603 const xAOD::PixelCluster* pixelCluster = dynamic_cast<const xAOD::PixelCluster*>(&measurement);
604 mainTable += std::format("| | {:>6} | Pixel | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
605 measurementCounter,
606 pixelCluster->globalPosition().cast<double>().x(),
607 pixelCluster->globalPosition().cast<double>().y(),
608 pixelCluster->globalPosition().cast<double>().z(),
609 pixelCluster->identifierHash(),
610 pixelCluster->identifier());
611 }
612 else if (measurement.type() == xAOD::UncalibMeasType::StripClusterType) {
613 const xAOD::StripCluster* stripCluster = dynamic_cast<const xAOD::StripCluster*>(&measurement);
614 mainTable += std::format("| | {:>6} | Strip | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
615 measurementCounter,
616 stripCluster->globalPosition().cast<double>().x(),
617 stripCluster->globalPosition().cast<double>().y(),
618 stripCluster->globalPosition().cast<double>().z(),
619 stripCluster->identifierHash(),
620 stripCluster->identifier());
621 }
622 }
623 mainTable += "|---------------------------------------------------------------------------------------------|\n";
624 }
625 ATH_MSG_INFO("Printing out prototracks coming from " << FPGAPrototracks.key() << mainTable);
626}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
sp
static Double_t sp
Definition LArPhysWaveHECTool.cxx:37
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition AthReentrantAlgorithm.h:74
DataVector
Derived DataVector<T>.
Definition DataVector.h:795
FPGATrackSim::FPGATrackSimReportingAlg::m_xAODStripClusterContainerKeys
SG::ReadHandleKeyArray< xAOD::StripClusterContainer > m_xAODStripClusterContainerKeys
Definition FPGATrackSimReportingAlg.h:55
FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeeds
void processFPGASeeds(SG::ReadHandle< ActsTrk::SeedContainer > &FPGASeeds) const
Definition FPGATrackSimReportingAlg.cxx:337
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsSeedParamCollections
SG::ReadHandleKeyArray< ActsTrk::BoundTrackParametersContainer > m_ActsSeedParamCollections
Definition FPGATrackSimReportingAlg.h:77
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsSeedCollections
SG::ReadHandleKeyArray< ActsTrk::SeedContainer > m_ActsSeedCollections
Definition FPGATrackSimReportingAlg.h:75
FPGATrackSim::FPGATrackSimReportingAlg::finalize
virtual StatusCode finalize() override final
Definition FPGATrackSimReportingAlg.cxx:147
FPGATrackSim::FPGATrackSimReportingAlg::FPGATrackSimReportingAlg
FPGATrackSimReportingAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition FPGATrackSimReportingAlg.cxx:8
FPGATrackSim::FPGATrackSimReportingAlg::printFPGAPrototracks
void printFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition FPGATrackSimReportingAlg.cxx:565
FPGATrackSim::FPGATrackSimReportingAlg::printFPGARoads
void printFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition FPGATrackSimReportingAlg.cxx:410
FPGATrackSim::FPGATrackSimReportingAlg::m_xAODSpacePointContainerKeys
SG::ReadHandleKeyArray< xAOD::SpacePointContainer > m_xAODSpacePointContainerKeys
Definition FPGATrackSimReportingAlg.h:60
FPGATrackSim::FPGATrackSimReportingAlg::printxAODClusters
void printxAODClusters(SG::ReadHandle< DataVector< XAOD_CLUSTER > > &clusterContainer) const
Definition FPGATrackSimReportingAlg.cxx:217
FPGATrackSim::FPGATrackSimReportingAlg::m_FPGAProtoTrackCollections
SG::ReadHandleKeyArray< ActsTrk::ProtoTrackCollection > m_FPGAProtoTrackCollections
Definition FPGATrackSimReportingAlg.h:71
FPGATrackSim::FPGATrackSimReportingAlg::initialize
virtual StatusCode initialize() override final
Definition FPGATrackSimReportingAlg.cxx:11
FPGATrackSim::FPGATrackSimReportingAlg::processFPGARoads
void processFPGARoads(SG::ReadHandle< FPGATrackSimRoadCollection > &FPGARoads) const
Definition FPGATrackSimReportingAlg.cxx:405
FPGATrackSim::FPGATrackSimReportingAlg::m_FPGATracksKey
SG::ReadHandleKey< FPGATrackSimTrackCollection > m_FPGATracksKey
Definition FPGATrackSimReportingAlg.h:69
FPGATrackSim::FPGATrackSimReportingAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override final
Definition FPGATrackSimReportingAlg.cxx:27
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsInspectionTool
ToolHandle< FPGATrackSim::ActsTrackInspectionTool > m_ActsInspectionTool
Definition FPGATrackSimReportingAlg.h:82
FPGATrackSim::FPGATrackSimReportingAlg::processFPGAPrototracks
void processFPGAPrototracks(SG::ReadHandle< ActsTrk::ProtoTrackCollection > &FPGAPrototracks) const
Definition FPGATrackSimReportingAlg.cxx:545
FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeeds
void printFPGASeeds(SG::ReadHandle< ActsTrk::SeedContainer > &FPGASeeds) const
Definition FPGATrackSimReportingAlg.cxx:342
FPGATrackSim::FPGATrackSimReportingAlg::printFPGATracks
void printFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition FPGATrackSimReportingAlg.cxx:487
FPGATrackSim::FPGATrackSimReportingAlg::processFPGATracks
void processFPGATracks(SG::ReadHandle< FPGATrackSimTrackCollection > &FPGATracks) const
Definition FPGATrackSimReportingAlg.cxx:467
FPGATrackSim::FPGATrackSimReportingAlg::processFPGASeedsParam
void processFPGASeedsParam(SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
Definition FPGATrackSimReportingAlg.cxx:373
FPGATrackSim::FPGATrackSimReportingAlg::m_FPGARoadsKey
SG::ReadHandleKey< FPGATrackSimRoadCollection > m_FPGARoadsKey
Definition FPGATrackSimReportingAlg.h:67
FPGATrackSim::FPGATrackSimReportingAlg::printFPGASeedsParam
void printFPGASeedsParam(SG::ReadHandle< ActsTrk::BoundTrackParametersContainer > &FPGASeedsParam) const
Definition FPGATrackSimReportingAlg.cxx:378
FPGATrackSim::FPGATrackSimReportingAlg::processxAODClusters
void processxAODClusters(SG::ReadHandle< DataVector< XAOD_CLUSTER > > &clusterContainer) const
Definition FPGATrackSimReportingAlg.cxx:211
FPGATrackSim::FPGATrackSimReportingAlg::m_ActsTrackCollections
SG::ReadHandleKeyArray< ActsTrk::TrackContainer > m_ActsTrackCollections
Definition FPGATrackSimReportingAlg.h:73
FPGATrackSim::FPGATrackSimReportingAlg::printxAODSpacePoints
void printxAODSpacePoints(SG::ReadHandle< DataVector< xAOD::SpacePoint > > &spContainer) const
Definition FPGATrackSimReportingAlg.cxx:313
FPGATrackSim::FPGATrackSimReportingAlg::processxAODSpacePoints
void processxAODSpacePoints(SG::ReadHandle< DataVector< xAOD::SpacePoint > > &spContainer) const
Definition FPGATrackSimReportingAlg.cxx:308
FPGATrackSim::FPGATrackSimReportingAlg::m_xAODPixelClusterContainerKeys
SG::ReadHandleKeyArray< xAOD::PixelClusterContainer > m_xAODPixelClusterContainerKeys
Definition FPGATrackSimReportingAlg.h:50
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
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
xAOD::UncalibratedMeasurement_v1::type
virtual xAOD::UncalibMeasType type() const =0
Returns the type of the measurement type as a simple enumeration.
ActsTrk::getUncalibratedMeasurement
const xAOD::UncalibratedMeasurement & getUncalibratedMeasurement(const ATLASUncalibSourceLink &source_link)
Definition ATLASSourceLink.h:26
ActsTrk::ATLASUncalibSourceLink
const xAOD::UncalibratedMeasurement * ATLASUncalibSourceLink
Definition ATLASSourceLink.h:24
xAOD::StripCluster
StripCluster_v1 StripCluster
Define the version of the strip cluster class.
Definition StripCluster.h:13
xAOD::PixelCluster
PixelCluster_v1 PixelCluster
Define the version of the pixel cluster class.
Definition Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/PixelCluster.h:13
xAOD::UncalibratedMeasurement
UncalibratedMeasurement_v1 UncalibratedMeasurement
Define the version of the uncalibrated measurement class.
Definition UncalibratedMeasurement.h:13
Generated on for ATLAS Offline Software by doxygen 1.14.0