13 ATH_CHECK(m_xAODPixelClusterContainerKeys.initialize());
14 ATH_CHECK(m_xAODStripClusterContainerKeys.initialize());
15 ATH_CHECK(m_xAODSpacePointContainerKeys.initialize());
16 ATH_CHECK(m_FPGARoadsKey.initialize(!m_isDataPrep));
17 ATH_CHECK(m_FPGAProtoTrackCollections.initialize(!m_isDataPrep));
18 ATH_CHECK(m_FPGATracksKey.initialize(!m_isDataPrep));
19 ATH_CHECK(m_ActsTrackCollections.initialize());
20 ATH_CHECK(m_ActsSeedCollections.initialize());
21 ATH_CHECK(m_ActsSeedParamCollections.initialize());
23 ATH_CHECK(m_ActsInspectionTool.retrieve());
24 return StatusCode::SUCCESS;
30 std::vector<SG::ReadHandle<xAOD::PixelClusterContainer>> xAODPixelClusterContainers = m_xAODPixelClusterContainerKeys.makeHandles(ctx);
33 if (!clusterContainer.isValid()) {
37 processxAODClusters<xAOD::PixelCluster>(clusterContainer);
40 std::vector<SG::ReadHandle<xAOD::StripClusterContainer>> xAODStripClusterContainers = m_xAODStripClusterContainerKeys.makeHandles(ctx);
43 if (!clusterContainer.isValid()) {
47 processxAODClusters<xAOD::StripCluster>(clusterContainer);
50 std::vector<SG::ReadHandle<xAOD::SpacePointContainer>> xAODSpacePointContainers = m_xAODSpacePointContainerKeys.makeHandles(ctx);
53 if (!spContainer.isValid()) {
56 else {processxAODSpacePoints(spContainer);}
58 if (!m_isDataPrep.value()) {
61 if (FPGATrackSimRoads.
isValid()) {
62 processFPGARoads(FPGATrackSimRoads);
64 else ATH_MSG_WARNING(
"Could not find FPGA Roads Collection with key " << FPGATrackSimRoads.
key());
69 if (FPGATrackSimTracks.
isValid()) {
70 processFPGATracks(FPGATrackSimTracks);
72 else ATH_MSG_WARNING(
"Could not find FPGA Track Collection with key " << FPGATrackSimTracks.
key());
75 std::vector<SG::ReadHandle<ActsTrk::ProtoTrackCollection>> FPGATrackSimProtoTracks = m_FPGAProtoTrackCollections.makeHandles(ctx);
78 if (!prototrackContainer.isValid()) {
82 processFPGAPrototracks(prototrackContainer);
86 std::vector<SG::ReadHandle<ActsTrk::TrackContainer>> FPGAActsTracks = m_ActsTrackCollections.makeHandles(ctx);
89 if (actsTrackContainer.cptr())
ATH_MSG_DEBUG(
"Proccessing " << actsTrackContainer.key());
92 m_allActsTracks.try_emplace(actsTrackContainer.key(), std::vector<FPGATrackSimActsEventTracks>{});
95 m_allActsTracks[actsTrackContainer.key()].push_back(m_ActsInspectionTool->getActsTracks(*(actsTrackContainer.cptr())));
98 m_actsTrackStats.try_emplace(actsTrackContainer.key(), std::map<
uint32_t, std::vector<uint32_t>>{});
100 m_actsTrackStats[actsTrackContainer.key()].emplace(
101 Acts::TrackStateFlag::OutlierFlag, std::vector<uint32_t>{});
102 m_actsTrackStats[actsTrackContainer.key()].emplace(
103 Acts::TrackStateFlag::HoleFlag, std::vector<uint32_t>{});
104 m_actsTrackStats[actsTrackContainer.key()].emplace(
105 Acts::TrackStateFlag::MeasurementFlag, std::vector<uint32_t>{});
107 for (
const auto&
track : m_allActsTracks[actsTrackContainer.key()].back()) {
108 uint32_t t_nOutliers = 0, t_nMeasurements = 0, t_nHoles = 0;
109 for (
const auto& measurement :
track->trackMeasurements)
111 if (measurement->outlierFlag) ++t_nOutliers;
112 if (measurement->measurementFlag) ++t_nMeasurements;
113 if (measurement->holeFlag) ++t_nHoles;
115 m_actsTrackStats[actsTrackContainer.key()][Acts::TrackStateFlag::OutlierFlag].push_back(t_nOutliers);
116 m_actsTrackStats[actsTrackContainer.key()][Acts::TrackStateFlag::HoleFlag].push_back(t_nHoles);
117 m_actsTrackStats[actsTrackContainer.key()][Acts::TrackStateFlag::MeasurementFlag].push_back(t_nMeasurements);
119 if (m_printoutForEveryEvent)
ATH_MSG_INFO(
"ACTS tracks in " << actsTrackContainer.key() << m_ActsInspectionTool->getPrintoutActsEventTracks(m_allActsTracks[actsTrackContainer.key()].back()));
122 std::vector<SG::ReadHandle<ActsTrk::SeedContainer>> FPGAActsSeeds = m_ActsSeedCollections.makeHandles(ctx);
126 if (!actsTrackContainer.isValid()) {
130 processFPGASeeds(actsTrackContainer);
134 std::vector<SG::ReadHandle<ActsTrk::BoundTrackParametersContainer>> FPGAActsSeedsParam = m_ActsSeedParamCollections.makeHandles(ctx);
138 if (!actsTrackContainer.isValid()) {
142 processFPGASeedsParam(actsTrackContainer);
145 return StatusCode::SUCCESS;
152 if (!m_isDataPrep.value()) {
154 std::string summaryTableFPGATracks =
"\n"
155 "Number of measurements for FPGA Tracks\n"
156 "|-----------------------------------|\n"
157 "| | min | max | Avg |\n"
158 "|-----------------------------------|\n";
160 if (not m_pixelClustersPerFPGATrack.empty()) {
161 summaryTableFPGATracks +=
std::format(
"| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
162 *std::min_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
163 *std::max_element(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end()),
164 std::accumulate(m_pixelClustersPerFPGATrack.begin(), m_pixelClustersPerFPGATrack.end(), 0.0) / m_pixelClustersPerFPGATrack.size());
166 else summaryTableFPGATracks +=
std::format(
"| Pixels | ---- | ---- | inf |\n");
168 if (not m_stripClustersPerFPGATrack.empty()) {
169 summaryTableFPGATracks +=
std::format(
"| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
170 *std::min_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
171 *std::max_element(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end()),
172 std::accumulate(m_stripClustersPerFPGATrack.begin(), m_stripClustersPerFPGATrack.end(), 0.0) / m_stripClustersPerFPGATrack.size());
174 else summaryTableFPGATracks +=
std::format(
"| Strips | ---- | ---- | inf |\n");
176 summaryTableFPGATracks +=
"|-----------------------------------|";
181 std::string summaryTableFPGAPrototracks =
std::format(
"\n"
182 "Number of measurements for FPGA Prototracks\n"
183 "|-----------------------------------|\n"
184 "| | min | max | Avg |\n"
185 "|-----------------------------------|\n");
187 if (not m_pixelClustersPerPrototrack.empty()) {
188 summaryTableFPGAPrototracks +=
std::format(
"| Pixels | {:>4} | {:>4} | {:>10.2f} |\n",
189 *std::min_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
190 *std::max_element(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end()),
191 std::accumulate(m_pixelClustersPerPrototrack.begin(), m_pixelClustersPerPrototrack.end(), 0.0) / m_pixelClustersPerPrototrack.size());
193 else summaryTableFPGAPrototracks +=
std::format(
"| Pixels | ---- | ---- | inf |\n");
195 if (not m_stripClustersPerPrototrack.empty()) {
196 summaryTableFPGAPrototracks +=
std::format(
"| Strips | {:>4} | {:>4} | {:>10.2f} |\n",
197 *std::min_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
198 *std::max_element(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end()),
199 std::accumulate(m_stripClustersPerPrototrack.begin(), m_stripClustersPerPrototrack.end(), 0.0) / m_stripClustersPerPrototrack.size());
201 else summaryTableFPGAPrototracks +=
std::format(
"| Strips | ---- | ---- | inf |\n");
203 summaryTableFPGAPrototracks +=
"|-----------------------------------|";
207 ATH_MSG_INFO(m_ActsInspectionTool->getPrintoutStatistics(m_actsTrackStats));
208 return StatusCode::SUCCESS;
211 template <
class XAOD_CLUSTER>
214 if (m_printoutForEveryEvent) printxAODClusters(clusterContainer);
217 template <
class XAOD_CLUSTER>
220 std::string mainTable =
"\n"
221 "|=========================================================================================|\n"
222 "| # | Global coordinates | Hash ID | Identifier |\n"
223 "| | x | y | z | | |\n"
224 "|-----------------------------------------------------------------------------------------|\n";
226 for (
const auto& cluster : *clusterContainer)
229 mainTable +=
std::format(
"| {:>6} | {:>12} | {:>12} | {:>12} | {:>12} | {:>18} |\n",
231 cluster->globalPosition().x(),
232 cluster->globalPosition().y(),
233 cluster->globalPosition().z(),
234 cluster->identifierHash(),
235 cluster->identifier());
237 mainTable +=
"|=========================================================================================|";
238 ATH_MSG_INFO(
"Printout of xAOD clusters coming from " << clusterContainer.key() << mainTable );
244 if (m_printoutForEveryEvent) printxAODSpacePoints(spContainer);
249 std::string mainTable =
"\n"
250 "|============================================================================|\n"
251 "| # | Global coordinates | element ID list |\n"
252 "| | x | y | z | |\n"
253 "|----------------------------------------------------------------------------|\n";
255 for (
const auto sp : *spContainer)
258 mainTable +=
std::format(
"| {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
260 sp->globalPosition().x(),
261 sp->globalPosition().y(),
262 sp->globalPosition().z(),
263 sp->elementIdList()[0],
264 sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
266 mainTable +=
"|=========================================================================================|";
267 ATH_MSG_INFO(
"Printout of xAOD space points coming from " << spContainer.key() << mainTable );
273 if (m_printoutForEveryEvent) printFPGASeeds(spContainer);
278 std::string mainTable =
"\n"
279 "|=====================================================================================|\n"
280 "| # | seed | Global coordinates | element ID list |\n"
281 "| | i | x | y | z | |\n"
282 "|-------------------------------------------------------------------------------------|\n";
284 for (
const auto thisTrack : *seedContainer)
286 auto spList = thisTrack->sp();
288 for(
int i = 0;
i < 3;
i++)
290 auto sp = spList.at(
i);
291 mainTable +=
std::format(
"| {:>6} | {:>6} | {:>12} | {:>12} | {:>12} | {:>9}, {:>9} |\n",
294 sp->globalPosition().x(),
295 sp->globalPosition().y(),
296 sp->globalPosition().z(),
297 sp->elementIdList()[0],
298 sp->elementIdList().size() == 2 ? sp->elementIdList()[1] : 0);
302 mainTable +=
"|=========================================================================================|";
303 ATH_MSG_INFO(
"Printout of ACTS seeds coming from " << seedContainer.key() << mainTable );
309 if (m_printoutForEveryEvent) printFPGASeedsParam(spContainer);
314 std::string mainTable =
"\n"
315 "|=============================================================================================|\n"
316 "| # | QopT | Theta | Phi | d0 | z0 |\n"
317 "|---------------------------------------------------------------------------------------------|\n";
319 for (
const auto paramSet : *seedContainer)
323 mainTable +=
std::format(
"| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
331 mainTable +=
"|=========================================================================================|";
332 ATH_MSG_INFO(
"Printout of ACTS seeds Param coming from " << seedContainer.key() << mainTable );
341 if (m_printoutForEveryEvent) printFPGARoads(FPGARoads);
346 std::string mainTable =
"\n"
347 "|--------------------------------------------------------------------------------------------------|\n"
348 "| # | SubRegion | xBin | yBin | X | Y | RoadID | Sector |\n"
349 "|--------------------------------------------------------------------------------------------------|\n";
351 unsigned int roadCounter = 0, hitCounter = 0;
355 mainTable +=
std::format(
"| {:>6} | {:>11} | {:>8} | {:>8} | {:>12} | {:>12} | {:>10} | {:>8} |\n",
365 "| __________________________________________________________________________________________|\n"
366 "| | layer | ## | type | Global coordinates | isReal |\n"
367 "| | | | | x | y | z | |\n"
368 "| |.........................................................................................|\n";
369 for (
unsigned int i = 0;
i < road.getNLayers(); ++
i)
372 const std::vector<std::shared_ptr<const FPGATrackSimHit>>&
hits = road.getHits(
i);
373 for (
auto const& hit :
hits)
381 mainTable +=
std::format(
"| | {:>9} | {:>6} | {:>8} | {:>13} | {:>13} | {:>13} | {:>7} |\n",
382 (hit->isMapped() ? hit->getLayer() : 9999),
384 (hit->isPixel() ?
"Pixel" : hit->isStrip() ?
"Strip" :
"FAILED"),
390 ATH_MSG_ERROR(
"Exception while processing FPGATrackSimHit: " <<
e.what());
395 mainTable +=
"|--------------------------------------------------------------------------------------------------|\n";
397 ATH_MSG_INFO(
"List of FPGA roads for " << FPGARoads.key() << mainTable);
403 for (
auto const&
track : *FPGATracks)
405 const std::vector <FPGATrackSimHit>&
hits =
track.getFPGATrackSimHits();
406 uint32_t pixelHits = 0, stripHits = 0;
409 if (hit.isPixel()) ++pixelHits;
410 if (hit.isStrip()) ++stripHits;
412 m_pixelClustersPerFPGATrack.push_back(pixelHits);
413 m_stripClustersPerFPGATrack.push_back(stripHits);
415 if (m_printoutForEveryEvent) printFPGATracks(FPGATracks);
420 std::string maintable =
"\n|--------------------------------------------------------------------------------------------------|\n";
421 unsigned int trackCounter = 0;
422 for (
auto const&
track : *FPGATracks)
425 maintable +=
"| # | Eta | Phi | D0 | Z0 | QOverPt | chi2/ndf |\n"
426 "|--------------------------------------------------------------------------------------------------|\n";
430 maintable +=
std::format(
"| {:>6} | {:>12.8f} | {:>12.8f} | {:>12.8f} | {:>12.5f} | {:>12.9f} | {:>12.8f} |\n",
437 track.getChi2ndof());
441 ATH_MSG_ERROR(
"Exception while processing FPGATrackSimTrack: " <<
e.what());
445 maintable +=
"|__________________________________________________________________________________________________|\n"
446 "| | ## | type | layer | Global coordinates | isReal | HashID |\n"
447 "| | | | | x | y | z | | |\n"
448 "| |.........................................................................................|\n";
449 const std::vector <FPGATrackSimHit>&
hits =
track.getFPGATrackSimHits();
450 unsigned int hitCounter = 0;
451 for (
auto const& hit :
hits)
455 maintable +=
std::format(
"| | {:>6} | {:>8} | {:>5} | {:>9.3f} | {:>9.3f} | {:>9.3f} | {:>6} | {:>14} |\n",
457 (hit.isPixel() ?
"Pixel" : hit.isStrip() ?
"Strip" :
"FAILED"),
463 hit.getIdentifierHash());
465 ATH_MSG_ERROR(
"Exception while processing FPGATrackSimHits: " <<
e.what());
468 maintable +=
"|--------------------------------------------------------------------------------------------------|\n";
470 ATH_MSG_INFO(
"List of FPGA tracks for " << FPGATracks.key() << maintable);
475 unsigned int nPixelMeasurements, nStripMeasurements;
476 for (
auto const& prototrack : *FPGAPrototracks)
478 nPixelMeasurements = 0, nStripMeasurements = 0;
479 const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
486 m_pixelClustersPerPrototrack.push_back(nPixelMeasurements);
487 m_stripClustersPerPrototrack.push_back(nStripMeasurements);
490 if (m_printoutForEveryEvent) printFPGAPrototracks(FPGAPrototracks);
495 std::string mainTable =
"\n";
496 if(not (*FPGAPrototracks).empty()) mainTable +=
"|---------------------------------------------------------------------------------------------|\n";
498 unsigned int prototrackCounter = 0;
499 for (
auto const& prototrack : *FPGAPrototracks)
502 const Acts::BoundTrackParameters& initialParameters = *prototrack.parameters;
503 const Acts::BoundVector&
parameters = initialParameters.parameters();
505 "| # | QopT | Theta | Phi | d0 | z0 |\n"
506 "|---------------------------------------------------------------------------------------------|\n";
507 mainTable +=
std::format(
"| {:>6} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} | {:>14.10f} |\n",
515 const std::vector<ActsTrk::ATLASUncalibSourceLink>* measurements = &prototrack.measurements;
516 unsigned int measurementCounter = 0;
517 if (measurements->size())
520 "| _____________________________________________________________________________________|\n"
521 "| | | type | Global coordinates | HashID | Identifier |\n"
522 "| | ## | | x | y | z | | |\n"
523 "| | |...........................................................................|\n";
528 ++measurementCounter;
532 mainTable +=
std::format(
"| | {:>6} | Pixel | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
542 mainTable +=
std::format(
"| | {:>6} | Strip | {:>8.3f} | {:>8.3f} | {:>8.3f} | {:>7} | {:>19} |\n",
551 mainTable +=
"|---------------------------------------------------------------------------------------------|\n";
553 ATH_MSG_INFO(
"Printing out prototracks coming from " << FPGAPrototracks.key() << mainTable);