Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
FPGATrackSimLogicalHitsProcessAlg.cxx
Go to the documentation of this file.
1 // Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
2 
4 
13 
17 
19 
22 
24 
25 #include "GaudiKernel/IEventProcessor.h"
26 
27 constexpr bool enableBenchmark =
28 #ifdef BENCHMARK_LOGICALHITSALG
29  true;
30 #else
31  false;
32 #endif
33 
35 // Initialize
36 
37 FPGATrackSimLogicalHitsProcessAlg::FPGATrackSimLogicalHitsProcessAlg (const std::string& name, ISvcLocator* pSvcLocator) :
38  AthAlgorithm(name, pSvcLocator)
39 {
40 }
41 
42 
44 {
45  std::stringstream ss(m_description);
46  std::string line;
47  ATH_MSG_INFO("Tag config:");
48  if (!m_description.empty()) {
49  while (std::getline(ss, line, '\n')) {
50  ATH_MSG_INFO('\t' << line);
51  }
52  }
53  ATH_CHECK(m_roadFinderTool.retrieve());
54  ATH_CHECK(m_LRTRoadFilterTool.retrieve(EnableTool{m_doLRT}));
55  ATH_CHECK(m_LRTRoadFinderTool.retrieve(EnableTool{m_doLRT}));
56  ATH_CHECK(m_houghRootOutputTool.retrieve(EnableTool{m_doHoughRootOutput1st}));
57  ATH_CHECK(m_NNTrackTool.retrieve(EnableTool{m_doNNTrack}));
58  ATH_CHECK(m_roadFilterTool.retrieve(EnableTool{m_filterRoads}));
59  ATH_CHECK(m_roadFilterTool2.retrieve(EnableTool{m_filterRoads2}));
60  if (m_doSpacepoints) ATH_CHECK(m_spRoadFilterTool.retrieve(EnableTool{m_spRoadFilterTool}));
61 
62  ATH_CHECK(m_trackFitterTool_1st.retrieve(EnableTool{m_doTracking}));
64  ATH_CHECK(m_writeOutputTool.retrieve());
65  ATH_CHECK(m_FPGATrackSimMapping.retrieve());
66 
67  ATH_MSG_DEBUG("initialize() Instantiating root objects");
68 
69  // This file should only need to generate one input and output branch.
70  m_slicedHitHeader = m_writeOutputTool->addInputBranch(m_sliceBranch.value(), true);
71  m_logicEventOutputHeader = m_writeOutputTool->addOutputBranch(m_outputBranch.value(), true);
72 
73  // Connect the road union tool accordingly.
74  m_roadFinderTool->setupSlices(m_slicedHitHeader);
75 
76  ATH_MSG_DEBUG("initialize() Setting branch");
77 
78  if (!m_monTool.empty())
79  ATH_CHECK(m_monTool.retrieve());
80 
89 
90  ATH_CHECK( m_chrono.retrieve() );
91  ATH_MSG_DEBUG("initialize() Finished");
92 
93  return StatusCode::SUCCESS;
94 }
95 
96 
98 // MAIN EXECUTE ROUTINE //
100 
102 {
103  const EventContext& ctx = getContext();
104 
105  // Get reference to hits from StoreGate.
107  if (!FPGAHits.isValid()) {
108  if (m_evt == 0) {
109  ATH_MSG_WARNING("Didn't receive " << FPGAHits.key() << " on first event; assuming no input events.");
110  }
111  SmartIF<IEventProcessor> appMgr{service("ApplicationMgr")};
112  if (!appMgr) {
113  ATH_MSG_ERROR("Failed to retrieve ApplicationMgr as IEventProcessor");
114  return StatusCode::FAILURE;
115  }
116  return appMgr->stopRun();
117  }
118 
119  // Set up write handles.
123 
124  ATH_CHECK( FPGAHits_2nd.record (std::make_unique<FPGATrackSimHitCollection>()));
125  ATH_CHECK( FPGARoads_1st.record (std::make_unique<FPGATrackSimRoadCollection>()));
126  ATH_CHECK( FPGAHitsInRoads_1st.record (std::make_unique<FPGATrackSimHitContainer>()));
127 
129  ATH_CHECK(FPGATracks_1stHandle.record (std::make_unique<FPGATrackSimTrackCollection>()));
130 
132  ATH_CHECK( FPGAHitsFiltered_1st.record (std::make_unique<FPGATrackSimHitCollection>()));
133 
134  // Query the event selection service to make sure this event passed cuts.
135  if (!m_evtSel->getSelectedEvent()) {
136  ATH_MSG_DEBUG("Event skipped by: " << m_evtSel->name());
137  return StatusCode::SUCCESS;
138  }
139 
140  // Event passes cuts, count it. technically, DataPrep does this now.
141  m_evt++;
142 
143  if constexpr (enableBenchmark) m_chrono->chronoStart("1st Stage: Split hits to 1st and 2nd stage");
144 
145  std::vector<std::shared_ptr<const FPGATrackSimHit>> phits_1st, phits_2nd;
146  const FPGATrackSimRegionMap* rmap_1st = m_FPGATrackSimMapping->SubRegionMap();
147  phits_1st.reserve(FPGAHits->size());
148  phits_2nd.reserve(FPGAHits->size());
149  for (const FPGATrackSimHit& hit : *(FPGAHits.cptr())) {
150  // If the hit falls within the boundaries of ANY subregion in the first stage, it's 1st stage.
151  if (rmap_1st->getRegions(hit).size() > 0) {
152  phits_1st.emplace_back(&hit, [](const FPGATrackSimHit*){});
153  }
154  else {
155  phits_2nd.emplace_back(&hit, [](const FPGATrackSimHit*){});
156  FPGAHits_2nd->push_back(hit);
157  }
158  }
159  if constexpr (enableBenchmark) m_chrono->chronoStop("1st Stage: Split hits to 1st and 2nd stage");
160 
161  // Get truth tracks from DataPrep as well.
163  if (!FPGATruthTracks.isValid()) {
164  ATH_MSG_ERROR("Could not find FPGA Truth Track Collection with key " << FPGATruthTracks.key());
165  return StatusCode::FAILURE;
166  }
167 
168  // Same for offline tracks.
170  if (!FPGAOfflineTracks.isValid()) {
171  ATH_MSG_ERROR("Could not find FPGA Offline Track Collection with key " << FPGAOfflineTracks.key());
172  return StatusCode::FAILURE;
173  }
174  if constexpr (enableBenchmark) m_chrono->chronoStart("1st Stage: GetRoads");
175  // Get roads
176  std::vector<std::shared_ptr<const FPGATrackSimRoad>> prefilter_roads;
177  std::vector<std::shared_ptr<const FPGATrackSimRoad>> roads_1st =
178  prefilter_roads;
179  ATH_CHECK(m_roadFinderTool->getRoads(phits_1st, roads_1st, *FPGATruthTracks));
180 
181  auto mon_nroads_1st = Monitored::Scalar<unsigned>("nroads_1st", roads_1st.size());
182  for (auto const &road : roads_1st) {
183  unsigned bitmask = road->getHitLayers();
184  for (size_t l = 0; l < m_FPGATrackSimMapping->PlaneMap_1st(0)->getNLogiLayers(); l++) {
185  if (bitmask & (1 << l)) {
186  auto mon_layerIDs_1st = Monitored::Scalar<unsigned>("layerIDs_1st",l);
187  Monitored::Group(m_monTool,mon_layerIDs_1st);
188  }
189  }
190  }
191  Monitored::Group(m_monTool, mon_nroads_1st);
192  if constexpr (enableBenchmark) m_chrono->chronoStop("1st Stage: GetRoads");
193  if constexpr (enableBenchmark) m_chrono->chronoStart("1st Stage: RoadFiltering");
194  // Standard road Filter
195  std::vector<std::shared_ptr<const FPGATrackSimRoad>> postfilter_roads;
196  if (m_filterRoads)
197  {
198  ATH_CHECK(m_roadFilterTool->filterRoads(roads_1st, postfilter_roads));
199  roads_1st = postfilter_roads;
200  }
201  if (m_doOverlapRemoval) ATH_CHECK(m_overlapRemovalTool_1st->runOverlapRemoval(roads_1st));
202  // Road Filter2
203  std::vector<std::shared_ptr<const FPGATrackSimRoad>> postfilter2_roads;
204  if (m_filterRoads2) {
205  ATH_CHECK(m_roadFilterTool2->filterRoads(roads_1st, postfilter2_roads));
206  roads_1st = postfilter2_roads;
207  }
208 
209  auto mon_nroads_1st_postfilter = Monitored::Scalar<unsigned>("nroads_1st_postfilter", roads_1st.size());
210  Monitored::Group(m_monTool, mon_nroads_1st_postfilter);
211  if constexpr (enableBenchmark) m_chrono->chronoStop("1st Stage: RoadFiltering");
212  if constexpr (enableBenchmark) m_chrono->chronoStart("1st Stage: Tracking");
213 
214  // Get tracks
215  std::vector<FPGATrackSimTrack> tracks_1st;
216  if (m_doTracking) {
217  if (m_doNNTrack) {
218  ATH_MSG_DEBUG("Performing NN tracking");
219  ATH_CHECK(m_NNTrackTool->getTracks(roads_1st, tracks_1st));
220  } else {
221  ATH_MSG_DEBUG("Performing Linear tracking");
222  if (m_passLowestChi2TrackOnly) { // Pass only the lowest chi2 track per road
223  // Loop over roads and keep only the best track for each road
224  for (const auto& road : roads_1st) {
225  std::vector<FPGATrackSimTrack> tracksForCurrentRoad;
226 
227  // Collect tracks for this road
228  std::vector<std::shared_ptr<const FPGATrackSimRoad>> roadVec = {road};
229  ATH_CHECK(m_trackFitterTool_1st->getTracks(roadVec, tracksForCurrentRoad));
230 
231  // Find the best track for this road
232  if (!tracksForCurrentRoad.empty()) {
233  auto bestTrackIter = std::min_element(
234  tracksForCurrentRoad.begin(), tracksForCurrentRoad.end(),
235  [](const FPGATrackSimTrack& a, const FPGATrackSimTrack& b) {
236  return a.getChi2ndof() < b.getChi2ndof();
237  });
238 
239  if (bestTrackIter != tracksForCurrentRoad.end() && bestTrackIter->getChi2ndof() < 1.e15) {
240  tracks_1st.push_back(*bestTrackIter);
241 
242  // Monitor chi2 of the best track
243  auto mon_chi2_1st = Monitored::Scalar<float>("chi2_1st_all", bestTrackIter->getChi2ndof());
244  Monitored::Group(m_monTool, mon_chi2_1st);
245  }
246  }
247  }
248  // Monitor the best chi2 (from all tracks across all roads)
249  if (!tracks_1st.empty()) {
250  float bestChi2Overall = std::min_element(
251  tracks_1st.begin(), tracks_1st.end(),
252  [](const FPGATrackSimTrack& a, const FPGATrackSimTrack& b) {
253  return a.getChi2ndof() < b.getChi2ndof();
254  })->getChi2ndof();
255 
256  auto mon_best_chi2_1st = Monitored::Scalar<float>("best_chi2_1st", bestChi2Overall);
257  Monitored::Group(m_monTool, mon_best_chi2_1st);
258  }
259  } else { // Pass all tracks with chi2 < 1e15
260  ATH_CHECK(m_trackFitterTool_1st->getTracks(roads_1st, tracks_1st));
261  float bestchi2 = 1.e15;
262  for (const FPGATrackSimTrack& track : tracks_1st) {
263  float chi2 = track.getChi2ndof();
264  if (chi2 < bestchi2) bestchi2 = chi2;
265  auto mon_chi2_1st = Monitored::Scalar<float>("chi2_1st_all", chi2);
266  Monitored::Group(m_monTool, mon_chi2_1st);
267  }
268  auto mon_best_chi2_1st = Monitored::Scalar<float>("best_chi2_1st", bestchi2);
269  Monitored::Group(m_monTool, mon_best_chi2_1st);
270  }
271  }
272  } else { // No tracking; add dummy tracks for monitoring
273  ATH_MSG_DEBUG("No tracking. Adding dummy tracks...");
274  int ntrackDummy = 0;
275  for (const std::shared_ptr<const FPGATrackSimRoad>& road : roads_1st) {
276  ntrackDummy += road->getNHitCombos();
277  }
278  tracks_1st.resize(ntrackDummy); // Just filled with dummy tracks for monitoring
279  }
280 
281  // Loop over roads and store them in SG (after track finding to also copy the sector information)
282  for (auto const& road : roads_1st) {
283  std::vector<FPGATrackSimHit> road_hits;
284  ATH_MSG_DEBUG("Hough Road X Y: " << road->getX() << " " << road->getY());
285  for (size_t l = 0; l < road->getNLayers(); ++l) {
286  for (const auto& layerH : road->getHits(l)) {
287  road_hits.push_back(*layerH);
288  }
289  }
290  FPGAHitsInRoads_1st->push_back(road_hits);
291  FPGARoads_1st->push_back(*road);
292  }
293  if constexpr (enableBenchmark) m_chrono->chronoStop("1st Stage: Tracking");
294 
295  // Monitor the number of tracks
296  auto mon_ntracks_1st = Monitored::Scalar<unsigned>("ntrack_1st", tracks_1st.size());
297  Monitored::Group(m_monTool, mon_ntracks_1st);
298  if constexpr (enableBenchmark) m_chrono->chronoStart("1st Stage: OverlapRemoval");
299  // Overlap removal
300  if (m_doOverlapRemoval) ATH_CHECK(m_overlapRemovalTool_1st->runOverlapRemoval(tracks_1st));
301  unsigned ntrackOLRChi2 = 0;
302  for (const FPGATrackSimTrack& track : tracks_1st) {
303  if (track.getChi2ndof() < m_trackScoreCut) {
305  if (track.passedOR()) {
306  ntrackOLRChi2++;
308 
309  // For tracks passing overlap removal-- record the chi2 so we can figure out the right cut.
310  float chi2olr = track.getChi2ndof();
311  auto mon_chi2_1st_or = Monitored::Scalar<float>("chi2_1st_afterOLR", chi2olr);
312  Monitored::Group(m_monTool, mon_chi2_1st_or);
313  }
314  }
315  }
316  if constexpr (enableBenchmark) m_chrono->chronoStop("1st Stage: OverlapRemoval");
317  auto mon_ntracks_1st_olr = Monitored::Scalar<unsigned>("ntrack_1st_afterOLR", ntrackOLRChi2);
318  Monitored::Group(m_monTool,mon_ntracks_1st_olr);
319 
320  m_nRoadsTot += roads_1st.size();
321  m_nTracksTot += tracks_1st.size();
322 
323  // Do some simple monitoring of efficiencies. okay, we need truth tracks here.
324  std::vector<FPGATrackSimTruthTrack> truthtracks = *FPGATruthTracks;
325  std::vector<FPGATrackSimOfflineTrack> offlineTracks = *FPGAOfflineTracks;
326  if (truthtracks.size() > 0) {
327  m_evt_truth++;
328  auto passroad = Monitored::Scalar<bool>("eff_road",(roads_1st.size() > 0));
329  auto passtrack = Monitored::Scalar<bool>("eff_track",(tracks_1st.size() > 0));
330  auto truthpT_zoom = Monitored::Scalar<float>("pT_zoom",truthtracks.front().getPt()*0.001);
331  auto truthpT = Monitored::Scalar<float>("pT",truthtracks.front().getPt()*0.001);
332  auto trutheta = Monitored::Scalar<float>("eta",truthtracks.front().getEta());
333  auto truthphi= Monitored::Scalar<float>("phi",truthtracks.front().getPhi());
334  auto truthd0= Monitored::Scalar<float>("d0",truthtracks.front().getD0());
335  auto truthz0= Monitored::Scalar<float>("z0",truthtracks.front().getZ0());
336  if (roads_1st.size() > 0) m_nRoadsFound++;
337  if (roads_1st.size() > m_maxNRoadsFound) m_maxNRoadsFound = roads_1st.size();
338 
339  unsigned npasschi2(0);
340  unsigned npasschi2OLR(0);
341  if (tracks_1st.size() > 0) {
342  m_nTracksFound++;
343  if (tracks_1st.size() > m_maxNTracksTot) m_maxNTracksTot = tracks_1st.size();
344  for (const auto& track : tracks_1st) {
345  if (track.getChi2ndof() < m_trackScoreCut) {
346  npasschi2++;
347  if (track.passedOR()) {
348  npasschi2OLR++;
349  }
350  }
351  }
352  }
353  if (npasschi2 > m_maxNTracksChi2Tot) m_maxNTracksChi2Tot = npasschi2;
354  if (npasschi2OLR > m_maxNTracksChi2OLRTot) m_maxNTracksChi2OLRTot = npasschi2OLR;
355  if (npasschi2 > 0) m_nTracksChi2Found++;
356  if (npasschi2OLR > 0) m_nTracksChi2OLRFound++;
357  auto passtrackchi2 = Monitored::Scalar<bool>("eff_track_chi2",(npasschi2 > 0));
358  Monitored::Group(m_monTool,passroad,passtrack,truthpT_zoom,truthpT,trutheta,truthphi,truthd0,truthz0,passtrackchi2);
359  }
360 
361  for (const FPGATrackSimTrack& track : tracks_1st) FPGATracks_1stHandle->push_back(track);
362 
363  // Now, we may want to do large-radius tracking on the hits not used by the first stage tracking.
364  // This follows overlap removal.
365  std::vector<std::shared_ptr<const FPGATrackSimRoad>> roadsLRT;
366  std::vector<FPGATrackSimTrack> tracksLRT; // currently empty
367  if (m_doLRT) {
368  // Filter out hits that are on successful first-stage tracks
369  std::vector<std::shared_ptr<const FPGATrackSimHit>> remainingHits;
370 
371  if (m_doLRTHitFiltering) {
372  ATH_MSG_DEBUG("Doing hit filtering based on prompt tracks.");
373  ATH_CHECK(m_LRTRoadFilterTool->filterUsedHits(tracks_1st, phits_1st, remainingHits));
374 
375  for (const auto &Hit : remainingHits) FPGAHitsFiltered_1st->push_back(*Hit);
376 
377  } else {
378  ATH_MSG_DEBUG("No hit filtering requested; using all hits for LRT.");
379  remainingHits = phits_1st;
380  }
381 
382  // Get LRT roads with remaining hits
383  ATH_MSG_DEBUG("Finding LRT roads");
384  ATH_CHECK(m_LRTRoadFinderTool->getRoads( remainingHits, roadsLRT ));
385  }
386 
387  auto dataFlowInfo = std::make_unique<FPGATrackSimDataFlowInfo>();
388 
389  // Write the output and reset
390  if (m_writeOutputData) {
391  ATH_CHECK(writeOutputData(roads_1st, tracks_1st, dataFlowInfo.get()));
392  }
393 
394  // This one we can do-- by passing in truth and offline tracks via storegate above.
396  ATH_MSG_DEBUG("Running HoughRootOutputTool in 1st stage.");
397 
398  SmartIF<IEventProcessor> appMgr{service("ApplicationMgr")};
399  if (!appMgr) {
400  ATH_MSG_ERROR("Failed to retrieve ApplicationMgr as IEventProcessor");
401  return StatusCode::FAILURE;
402  }
403  // Concatenate 1st and 2nd stage hits vectors to access both in the OutputTool
404  phits_2nd.insert(phits_2nd.end(), std::make_move_iterator(phits_1st.begin()), std::make_move_iterator(phits_1st.end()));
405  // Create output ROOT file
406  ATH_CHECK(m_houghRootOutputTool->fillTree(roads_1st, truthtracks, offlineTracks, phits_2nd, m_writeOutNonSPStripHits, m_trackScoreCut, m_NumOfHitPerGrouping, false));
407  }
408 
409  // Reset data pointers
412 
413  return StatusCode::SUCCESS;
414 }
415 
416 
418 // INPUT PASSING, READING AND PROCESSING //
420 
421 StatusCode FPGATrackSimLogicalHitsProcessAlg::writeOutputData( const std::vector<std::shared_ptr<const FPGATrackSimRoad>>& roads_1st,
422  std::vector<FPGATrackSimTrack> const& tracks_1st,
423  FPGATrackSimDataFlowInfo const* dataFlowInfo)
424 {
426 
427  ATH_MSG_DEBUG("NFPGATrackSimRoads_1st = " << roads_1st.size() << ", NFPGATrackSimTracks_1st = " << tracks_1st.size());
428 
429  if (!m_writeOutputData) return StatusCode::SUCCESS;
432  if (m_doTracking) {
435  }
436 
437 
440 
441  // It would be nice to rearrange this so both algorithms use one instance of this tool, I think.
442  // Which means that dataprep can't call writeData because that does Fill().
443  ATH_CHECK(m_writeOutputTool->writeData());
444 
445 
446 
447  return StatusCode::SUCCESS;
448 }
449 
450 
452 // Finalize
453 
455 {
456  ATH_MSG_INFO("PRINTING FPGATRACKSIM SIMPLE STATS");
457  ATH_MSG_INFO("========================================================================================");
458  ATH_MSG_INFO("Ran on events = " << m_evt);
459  ATH_MSG_INFO("Inclusive efficiency to find a road = " << m_nRoadsFound/m_evt_truth);
460  ATH_MSG_INFO("Inclusive efficiency to find a track = " << m_nTracksFound/m_evt_truth);
461  ATH_MSG_INFO("Inclusive efficiency to find a track passing chi2 = " << m_nTracksChi2Found/m_evt_truth);
462  ATH_MSG_INFO("Inclusive efficiency to find a track passing chi2 and OLR = " << m_nTracksChi2OLRFound/m_evt_truth);
463 
464 
465  ATH_MSG_INFO("Number of 1st stage roads/event = " << m_nRoadsTot/m_evt);
466  ATH_MSG_INFO("Number of 1st stage track combinations/event = " << m_nTracksTot/m_evt);
467  ATH_MSG_INFO("Number of 1st stage tracks passing chi2/event = " << m_nTracksChi2Tot/m_evt);
468  ATH_MSG_INFO("Number of 1st stage tracks passing chi2 and OLR/event = " << m_nTracksChi2OLRTot/m_evt);
469  ATH_MSG_INFO("========================================================================================");
470 
471  ATH_MSG_INFO("Max number of 1st stage roads in an event = " << m_maxNRoadsFound);
472  ATH_MSG_INFO("Max number of 1st stage track combinations in an event = " << m_maxNTracksTot);
473  ATH_MSG_INFO("Max number of 1st stage tracks passing chi2 in an event = " << m_maxNTracksChi2Tot);
474  ATH_MSG_INFO("Max number of 1st stage tracks passing chi2 and OLR in an event = " << m_maxNTracksChi2OLRTot);
475  ATH_MSG_INFO("========================================================================================");
476 
477  return StatusCode::SUCCESS;
478 }
479 
480 
482 // Helpers
483 
484 void FPGATrackSimLogicalHitsProcessAlg::printHitSubregions(std::vector<FPGATrackSimHit> const & hits)
485 {
486  ATH_MSG_WARNING("Hit regions:");
487  for (const auto& hit : hits)
488  {
489  std::vector<uint32_t> regions = m_FPGATrackSimMapping->SubRegionMap()->getRegions(hit);
490  std::stringstream ss;
491  for (auto r : regions)
492  ss << r << ",";
493  ATH_MSG_WARNING("\t[" << ss.str() << "]");
494  }
495 }
FPGATrackSimLogicalHitsProcessAlg::m_passLowestChi2TrackOnly
Gaudi::Property< bool > m_passLowestChi2TrackOnly
Definition: FPGATrackSimLogicalHitsProcessAlg.h:111
FPGATrackSimLogicalHitsProcessAlg::m_doSpacepoints
Gaudi::Property< bool > m_doSpacepoints
Definition: FPGATrackSimLogicalHitsProcessAlg.h:97
FPGATrackSimLogicalHitsProcessAlg::m_filterRoads
Gaudi::Property< bool > m_filterRoads
Definition: FPGATrackSimLogicalHitsProcessAlg.h:101
beamspotman.r
def r
Definition: beamspotman.py:676
FPGATrackSimLogicalHitsProcessAlg::m_maxNRoadsFound
unsigned long m_maxNRoadsFound
Definition: FPGATrackSimLogicalHitsProcessAlg.h:137
checkFileSG.line
line
Definition: checkFileSG.py:75
FPGATrackSimLogicalHitsProcessAlg::m_writeOutputTool
ToolHandle< FPGATrackSimOutputHeaderTool > m_writeOutputTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:90
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
FPGATrackSimRegionSlices.h
Stores slice definitions for FPGATrackSim regions.
FPGATrackSimLogicalHitsProcessAlg::m_LRTRoadFinderTool
ToolHandle< IFPGATrackSimRoadFinderTool > m_LRTRoadFinderTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:82
FPGATrackSimLogicalHitsProcessAlg::m_doHoughRootOutput1st
Gaudi::Property< bool > m_doHoughRootOutput1st
Definition: FPGATrackSimLogicalHitsProcessAlg.h:103
FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitKey_2nd
SG::WriteHandleKey< FPGATrackSimHitCollection > m_FPGAHitKey_2nd
Definition: FPGATrackSimLogicalHitsProcessAlg.h:153
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSimLogicalHitsProcessAlg::m_description
std::string m_description
Definition: FPGATrackSimLogicalHitsProcessAlg.h:77
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
FPGATrackSimLogicalHitsProcessAlg::m_logicEventOutputHeader
FPGATrackSimLogicalEventOutputHeader * m_logicEventOutputHeader
Definition: FPGATrackSimLogicalHitsProcessAlg.h:119
FPGATrackSimLogicalHitsProcessAlg::m_FPGARoadKey
SG::WriteHandleKey< FPGATrackSimRoadCollection > m_FPGARoadKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:156
FPGATrackSimLogicalHitsProcessAlg::m_slicedHitHeader
FPGATrackSimLogicalEventInputHeader * m_slicedHitHeader
Definition: FPGATrackSimLogicalHitsProcessAlg.h:118
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FPGATrackSimLogicalHitsProcessAlg::m_nTracksTot
long m_nTracksTot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:127
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitInRoadsKey
SG::WriteHandleKey< FPGATrackSimHitContainer > m_FPGAHitInRoadsKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:155
FPGATrackSimTrack
Definition: FPGATrackSimTrack.h:18
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
FPGATrackSimLogicalEventOutputHeader::reserveFPGATrackSimRoads_1st
void reserveFPGATrackSimRoads_1st(size_t size)
Definition: FPGATrackSimLogicalEventOutputHeader.h:24
FPGATrackSimNNTrackTool.h
Utilize NN score to build track candidates.
FPGATrackSimLogicalHitsProcessAlg::m_LRTRoadFilterTool
ToolHandle< FPGATrackSimLLPRoadFilterTool > m_LRTRoadFilterTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:81
FPGATrackSimLogicalHitsProcessAlg::m_doTracking
Gaudi::Property< bool > m_doTracking
Definition: FPGATrackSimLogicalHitsProcessAlg.h:98
FPGATrackSimLogicalHitsProcessAlg::m_writeOutNonSPStripHits
Gaudi::Property< bool > m_writeOutNonSPStripHits
Definition: FPGATrackSimLogicalHitsProcessAlg.h:109
FPGATrackSimLogicalHitsProcessAlg::FPGATrackSimLogicalHitsProcessAlg
FPGATrackSimLogicalHitsProcessAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:37
FPGATrackSimLogicalHitsProcessAlg::m_FPGATruthTrackKey
SG::ReadHandleKey< FPGATrackSimTruthTrackCollection > m_FPGATruthTrackKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:159
FPGATrackSimLogicalHitsProcessAlg::m_evtSel
ServiceHandle< IFPGATrackSimEventSelectionSvc > m_evtSel
Definition: FPGATrackSimLogicalHitsProcessAlg.h:92
FPGATrackSimLogicalEventOutputHeader::reset
void reset()
Definition: FPGATrackSimLogicalEventOutputHeader.cxx:12
FPGATrackSimLogicalHitsProcessAlg::m_writeOutputData
Gaudi::Property< bool > m_writeOutputData
Definition: FPGATrackSimLogicalHitsProcessAlg.h:107
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
FPGATrackSimLogicalHitsProcessAlg::m_maxNTracksChi2OLRTot
unsigned long m_maxNTracksChi2OLRTot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:140
FPGATrackSimReadRawRandomHitsTool.h
FPGATrackSimLogicalHitsProcessAlg::m_overlapRemovalTool_1st
ToolHandle< FPGATrackSimOverlapRemovalTool > m_overlapRemovalTool_1st
Definition: FPGATrackSimLogicalHitsProcessAlg.h:89
FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitFilteredKey
SG::WriteHandleKey< FPGATrackSimHitCollection > m_FPGAHitFilteredKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:154
FPGATrackSimLogicalHitsProcessAlg::m_FPGAOfflineTrackKey
SG::ReadHandleKey< FPGATrackSimOfflineTrackCollection > m_FPGAOfflineTrackKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:160
FPGATrackSimLogicalHitsProcessAlg::m_doNNTrack
Gaudi::Property< bool > m_doNNTrack
Definition: FPGATrackSimLogicalHitsProcessAlg.h:104
FPGATrackSimLogicalHitsProcessAlg::m_FPGATrackKey
SG::WriteHandleKey< FPGATrackSimTrackCollection > m_FPGATrackKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:157
FPGATrackSimLogicalHitsProcessAlg::m_evt_truth
double m_evt_truth
Definition: FPGATrackSimLogicalHitsProcessAlg.h:131
FPGATrackSimLogicalHitsProcessAlg::m_maxNTracksTot
unsigned long m_maxNTracksTot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:138
FPGATrackSimLogicalHitsProcessAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:148
FPGATrackSimLogicalEventOutputHeader::getDataFlowInfo
FPGATrackSimDataFlowInfo const & getDataFlowInfo() const
Definition: FPGATrackSimLogicalEventOutputHeader.h:47
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
FPGATrackSimLogicalHitsProcessAlg::m_evt
double m_evt
Definition: FPGATrackSimLogicalHitsProcessAlg.h:125
FPGATrackSimRegionMap.h
Maps ITK module indices to FPGATrackSim regions.
FPGATrackSimLogicalHitsProcessAlg::m_trackScoreCut
Gaudi::Property< float > m_trackScoreCut
Definition: FPGATrackSimLogicalHitsProcessAlg.h:108
FPGATrackSimLogicalHitsProcessAlg::m_doLRTHitFiltering
Gaudi::Property< bool > m_doLRTHitFiltering
Definition: FPGATrackSimLogicalHitsProcessAlg.h:106
FPGATrackSimLogicalHitsProcessAlg::m_roadFilterTool2
ToolHandle< IFPGATrackSimRoadFilterTool > m_roadFilterTool2
Definition: FPGATrackSimLogicalHitsProcessAlg.h:84
Hit
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloGpu/ISF_FastCaloGpu/Hit.h:16
FPGATrackSimDataFlowInfo
Definition: FPGATrackSimDataFlowInfo.h:18
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
FPGATrackSimLogicalEventOutputHeader::reserveFPGATrackSimTracks_1st
void reserveFPGATrackSimTracks_1st(size_t size)
Definition: FPGATrackSimLogicalEventOutputHeader.h:37
FPGATrackSimLogicalHitsProcessAlg::m_roadFinderTool
ToolHandle< FPGATrackSimRoadUnionTool > m_roadFinderTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:80
FPGATrackSimLogicalEventOutputHeader.h
FPGATrackSimLogicalHitsProcessAlg::execute
virtual StatusCode execute() override
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:101
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
FPGATrackSimLogicalEventOutputHeader::addFPGATrackSimRoads_1st
void addFPGATrackSimRoads_1st(const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads_1st)
Definition: FPGATrackSimLogicalEventOutputHeader.h:25
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
FPGATrackSimDataFlowInfo.h
Structs that store the data flow information per event.
FPGATrackSimRawToLogicalHitsTool.h
FPGATrackSimLogicalHitsProcessAlg::m_doOverlapRemoval
Gaudi::Property< bool > m_doOverlapRemoval
Definition: FPGATrackSimLogicalHitsProcessAlg.h:99
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:525
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimLogicalHitsProcessAlg::writeOutputData
StatusCode writeOutputData(const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads_1st, std::vector< FPGATrackSimTrack > const &tracks_1st, FPGATrackSimDataFlowInfo const *dataFlowInfo)
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:421
FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitKey
SG::ReadHandleKey< FPGATrackSimHitCollection > m_FPGAHitKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:151
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
FPGATrackSimRegionMap::getRegions
std::vector< uint32_t > getRegions(const FPGATrackSimHit &hit) const
Definition: FPGATrackSimRegionMap.cxx:278
FPGATrackSimLogicalHitsProcessAlg::m_sliceBranch
Gaudi::Property< std::string > m_sliceBranch
Definition: FPGATrackSimLogicalHitsProcessAlg.h:114
FPGATrackSimLogicalEventOutputHeader::setDataFlowInfo
void setDataFlowInfo(FPGATrackSimDataFlowInfo const &info)
Definition: FPGATrackSimLogicalEventOutputHeader.h:48
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
FPGATrackSimLogicalEventInputHeader::reset
void reset()
Definition: FPGATrackSimLogicalEventInputHeader.cxx:10
FPGATrackSimLogicalHitsProcessAlg::m_chrono
ServiceHandle< IChronoStatSvc > m_chrono
Definition: FPGATrackSimLogicalHitsProcessAlg.h:94
FPGATrackSimLogicalHitsProcessAlg::m_nTracksFound
long m_nTracksFound
Definition: FPGATrackSimLogicalHitsProcessAlg.h:133
FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2Tot
long m_nTracksChi2Tot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:128
FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2OLRFound
long m_nTracksChi2OLRFound
Definition: FPGATrackSimLogicalHitsProcessAlg.h:135
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
FPGATrackSimLogicalHitsProcessAlg::m_spRoadFilterTool
ToolHandle< IFPGATrackSimRoadFilterTool > m_spRoadFilterTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:85
FPGATrackSimLogicalHitsProcessAlg::m_maxNTracksChi2Tot
unsigned long m_maxNTracksChi2Tot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:139
FPGATrackSimLogicalEventOutputHeader::addFPGATrackSimTracks_1st
void addFPGATrackSimTracks_1st(std::vector< FPGATrackSimTrack > const &tracks_1st)
Definition: FPGATrackSimLogicalEventOutputHeader.h:38
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
FPGATrackSimLogicalHitsProcessAlg::printHitSubregions
void printHitSubregions(std::vector< FPGATrackSimHit > const &hits)
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:484
FPGATrackSimHit.h
: FPGATrackSim-specific class to represent an hit in the detector.
FPGATrackSimOverlapRemovalTool.h
Overlap removal tool for FPGATrackSimTrack.
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
FPGATrackSimLogicalHitsProcessAlg::finalize
virtual StatusCode finalize() override
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:454
FPGATrackSimLogicalHitsProcessAlg.h
FPGATrackSimLogicalHitsProcessAlg::m_trackFitterTool_1st
ToolHandle< FPGATrackSimTrackFitterTool > m_trackFitterTool_1st
Definition: FPGATrackSimLogicalHitsProcessAlg.h:88
FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2Found
long m_nTracksChi2Found
Definition: FPGATrackSimLogicalHitsProcessAlg.h:134
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
FPGATrackSimLogicalHitsProcessAlg::m_nRoadsTot
long m_nRoadsTot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:126
FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2OLRTot
long m_nTracksChi2OLRTot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:129
a
TList * a
Definition: liststreamerinfos.cxx:10
SG::WriteHandle::record
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
FPGATrackSimLogicalHitsProcessAlg::m_roadFilterTool
ToolHandle< IFPGATrackSimRoadFilterTool > m_roadFilterTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:83
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
FPGATrackSimLogicalHitsProcessAlg::m_doLRT
Gaudi::Property< bool > m_doLRT
Definition: FPGATrackSimLogicalHitsProcessAlg.h:105
FPGATrackSimRegionMap
Definition: FPGATrackSimRegionMap.h:62
FPGATrackSimLogicalHitsProcessAlg::m_nRoadsFound
long m_nRoadsFound
Definition: FPGATrackSimLogicalHitsProcessAlg.h:132
FPGATrackSimLogicalHitsProcessAlg::initialize
virtual StatusCode initialize() override
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:43
enableBenchmark
constexpr bool enableBenchmark
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:27
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
FPGATrackSimRoad.h
Defines a class for roads.
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
FPGATrackSimLogicalEventInputHeader.h
FPGATrackSimLogicalHitsProcessAlg::m_filterRoads2
Gaudi::Property< bool > m_filterRoads2
Definition: FPGATrackSimLogicalHitsProcessAlg.h:102
FPGATrackSimLogicalHitsProcessAlg::m_NumOfHitPerGrouping
Gaudi::Property< int > m_NumOfHitPerGrouping
Definition: FPGATrackSimLogicalHitsProcessAlg.h:110
FPGATrackSimLogicalHitsProcessAlg::m_outputBranch
Gaudi::Property< std::string > m_outputBranch
Definition: FPGATrackSimLogicalHitsProcessAlg.h:115
FPGATrackSimLogicalHitsProcessAlg::m_NNTrackTool
ToolHandle< FPGATrackSimNNTrackTool > m_NNTrackTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:86
FPGATrackSimTrackFitterTool.h
FPGATrackSimTrackPars.h
Structs that store the 5 track parameters.
FPGATrackSimLogicalHitsProcessAlg::m_houghRootOutputTool
ToolHandle< FPGATrackSimHoughRootOutputTool > m_houghRootOutputTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:87
FPGATrackSimTrack.h
FPGATrackSimCluster.h
FPGATrackSimLogicalHitsProcessAlg::m_FPGATrackSimMapping
ServiceHandle< IFPGATrackSimMappingSvc > m_FPGATrackSimMapping
Definition: FPGATrackSimLogicalHitsProcessAlg.h:91