ATLAS Offline Software
FPGATrackSimHoughRootOutputTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
9 
10 
12 FPGATrackSimHoughRootOutputTool::FPGATrackSimHoughRootOutputTool(const std::string& algname, const std::string& name, const IInterface *ifc) :
13  AthAlgTool(algname, name, ifc)
14 {
15 }
16 
17 
18 
19 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
21 {
22  ATH_CHECK(m_FPGATrackSimMapping.retrieve());
23  ATH_CHECK(m_tHistSvc.retrieve());
24  ATH_CHECK(m_EvtSel.retrieve());
25 
26  if(m_algorithm == "Normal") m_algo=ORAlgo::Normal;
27  else if(m_algorithm == "Invert") m_algo=ORAlgo::InvertGrouping;
28 
30  return StatusCode::SUCCESS;
31 }
32 
33 
34 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
36 {
37  std::string tree_str = "FPGATrackSimHoughRootOutput_reg" + m_region.value();
38  m_tree = new TTree(tree_str.c_str(), tree_str.c_str());
39 
40  m_tree->Branch("x",&m_x);
41  m_tree->Branch("y",&m_y);
42  m_tree->Branch("z",&m_z);
43  m_tree->Branch("volumeID",&m_volumeID);
44  m_tree->Branch("custom_layerID",&m_custom_layerID);
45 
46  m_tree->Branch("layerID",&m_layerID);
47  m_tree->Branch("etaID",&m_etaID);
48 
49  m_tree->Branch("associated_truth_d0",&m_associated_truth_d0);
50  m_tree->Branch("associated_truth_z0",&m_associated_truth_z0);
51  m_tree->Branch("associated_truth_pt",&m_associated_truth_pt);
52  m_tree->Branch("associated_truth_q",&m_associated_truth_q);
53  m_tree->Branch("associated_truth_eta",&m_associated_truth_eta);
54  m_tree->Branch("associated_truth_phi",&m_associated_truth_phi);
55 
56  m_tree->Branch("gphi",&m_gphi);
57  m_tree->Branch("zIdeal",&m_zIdeal);
58  m_tree->Branch("gphiIdeal",&m_gphiIdeal);
59  m_tree->Branch("phi",&m_phi);
60  m_tree->Branch("invpt",&m_invpt);
61  m_tree->Branch("tracknumber",&m_tracknumber);
62  m_tree->Branch("roadnumber",&m_roadnumber);
63  m_tree->Branch("barcode",&m_barcode);
64  m_tree->Branch("barcodefrac",&m_barcodefrac);
65  m_tree->Branch("eventindex",&m_eventindex);
66  m_tree->Branch("isRealHit",&m_realHit);
67  m_tree->Branch("isPixel",&m_isPixel);
68  m_tree->Branch("layer",&m_layer);
69  m_tree->Branch("isBarrel",&m_isBarrel);
70  m_tree->Branch("etawidth",&m_etawidth);
71  m_tree->Branch("phiwidth",&m_phiwidth);
72  m_tree->Branch("etamodule",&m_etamodule);
73  m_tree->Branch("phimodule",&m_phimodule);
74  m_tree->Branch("ID",&m_ID);
75  m_tree->Branch("diskLayer",&m_diskLayer);
76 
77  m_tree->Branch("candidate_barcodefrac",&m_candidate_barcodefrac);
78  m_tree->Branch("candidate_barcode",&m_candidate_barcode);
79  m_tree->Branch("candidate_eventindex",&m_candidate_eventindex);
80  m_tree->Branch("treeindex",&m_treeindex);
81  m_tree->Branch("subregion",&m_subregion);
82  m_tree->Branch("fakelabel",&m_fakelabel);
83  m_tree->Branch("passesOR",&m_passesOR);
84  m_tree->Branch("roadChi2",&m_roadChi2);
85  m_tree->Branch("nMissingHits",&m_nMissingHits);
86  m_tree->Branch("NTracksORMinusRoads",&m_NTracksORMinusRoads);
87 
88  m_treeindex = 0;
89 
90  std::string truthtree_str = "FPGATrackSimTruthTree_reg" + m_region.value();
91  m_truthtree = new TTree(truthtree_str.c_str(), truthtree_str.c_str());
92 
93  m_truthtree->Branch("truth_d0",&m_truth_d0);
94  m_truthtree->Branch("truth_z0",&m_truth_z0);
95  m_truthtree->Branch("truth_pt",&m_truth_pt);
96  m_truthtree->Branch("truth_eta",&m_truth_eta);
97  m_truthtree->Branch("truth_phi",&m_truth_phi);
98  m_truthtree->Branch("truth_q",&m_truth_q);
99  m_truthtree->Branch("truth_pdg",&m_truth_pdg);
100  m_truthtree->Branch("truth_barcode",&m_truth_barcode);
101  m_truthtree->Branch("truth_eventindex",&m_truth_eventindex);
102  m_truthtree->Branch("truth_track_hit_x",&m_track_hit_x);
103  m_truthtree->Branch("truth_track_hit_y",&m_track_hit_y);
104  m_truthtree->Branch("truth_track_hit_z",&m_track_hit_z);
105  m_truthtree->Branch("truth_track_hit_R",&m_track_hit_R);
106  m_truthtree->Branch("truth_track_hit_phi",&m_track_hit_phi);
107  m_truthtree->Branch("truth_track_hit_layer_disk",&m_track_hit_layer_disk);
108  m_truthtree->Branch("has_strip_nonspacepoint",&m_has_strip_nonspacepoint);
109  m_truthtree->Branch("truth_track_hit_isPixel", &m_track_hit_isPixel);
110  m_truthtree->Branch("truth_track_hit_isStrip", &m_track_hit_isStrip);
111  m_truthtree->Branch("truth_track_hit_isClustered", &m_track_hit_isClustered);
112  m_truthtree->Branch("truth_track_hit_isSpacepoint", &m_track_hit_isSpacepoint);
113  m_truthtree->Branch("truth_track_hit_barcode", &m_track_hit_barcode);
114  m_truthtree->Branch("truth_track_hit_barcodefrac", &m_track_hit_barcodefrac);
115  m_truthtree->Branch("truth_track_hit_zIdeal", &m_track_hit_zIdeal);
116  m_truthtree->Branch("truth_track_hit_gphiIdeal", &m_track_hit_gphiIdeal);
117  m_truthtree->Branch("truth_track_hit_fineID", &m_track_hit_fineID);
118  m_truthtree->Branch("truth_track_hit_volumeID", &m_track_hit_volumeID);
119  m_truthtree->Branch("truth_track_hit_isMapped", &m_track_hit_isMapped);
120 
121  std::string offltree_str = "FPGATrackSimOfflineTree_reg" + m_region.value();
122  m_offlinetree = new TTree(offltree_str.c_str(), offltree_str.c_str());
123 
124  m_offlinetree->Branch("offline_d0",&m_offline_d0);
125  m_offlinetree->Branch("offline_z0",&m_offline_z0);
126  m_offlinetree->Branch("offline_pt",&m_offline_pt);
127  m_offlinetree->Branch("offline_eta",&m_offline_eta);
128  m_offlinetree->Branch("offline_phi",&m_offline_phi);
129  m_offlinetree->Branch("offline_q",&m_offline_q);
130  m_offlinetree->Branch("offline_barcode",&m_offline_barcode);
131  m_offlinetree->Branch("offline_barcodefrac",&m_offline_barcodefrac);
132  m_offlinetree->Branch("offline_n_holes",&m_offline_n_holes);
133  m_offlinetree->Branch("offline_n_inertmaterial",&m_offline_n_inertmaterial);
134  m_offlinetree->Branch("offline_n_measurement",&m_offline_n_measurement);
135  m_offlinetree->Branch("offline_n_brempoint",&m_offline_n_brempoint);
136  m_offlinetree->Branch("offline_n_scatterer",&m_offline_n_scatterer);
137  m_offlinetree->Branch("offline_n_perigee",&m_offline_n_perigee);
138  m_offlinetree->Branch("offline_n_outlier",&m_offline_n_outlier);
139  m_offlinetree->Branch("offline_n_other",&m_offline_n_other);
140 
141  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_tree->GetName()), m_tree));
142  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_truthtree->GetName()), m_truthtree));
143  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_offlinetree->GetName()), m_offlinetree));
144 
145  return StatusCode::SUCCESS;
146 }
147 
148 
149 StatusCode FPGATrackSimHoughRootOutputTool::fillTree(const std::vector<FPGATrackSimTrack> &track_cands, const std::vector<FPGATrackSimTruthTrack> &truthTracks, const std::vector<FPGATrackSimOfflineTrack> &offlineTracks, const std::vector<std::shared_ptr<const FPGATrackSimHit>> &hits_2nd, const bool writeOutNonSPStripHits, const bool roadsAreSecondStage)
150 {
151  ATH_MSG_DEBUG("Running HoughOutputTool!!");
152 
153  m_tracknumber = 0;
154  ResetVectors();
155 
156  if (roadsAreSecondStage) m_SUBREGIONMAP = m_FPGATrackSimMapping->SubRegionMap_2nd();
157  else m_SUBREGIONMAP = m_FPGATrackSimMapping->SubRegionMap();
158 
159 
160  std::vector<float> tmp_hits_x;
161  std::vector<float> tmp_hits_y;
162  std::vector<float> tmp_hits_z;
163  std::vector<float> tmp_hits_R;
164  std::vector<float> tmp_hits_phi;
165  std::vector<int> tmp_hits_layer_disk;
166  std::vector<bool> tmp_hits_mapped;
167  std::vector<bool> tmp_hits_isPixel;
168  std::vector<bool> tmp_hits_isStrip;
169  std::vector<bool> tmp_hits_isClustered;
170  std::vector<bool> tmp_hits_isSpacepoint;
171  std::vector<float> tmp_hits_barcodefrac;
172  std::vector<int> tmp_hits_barcode;
173  std::vector<float> tmp_hits_zIdeal;
174  std::vector<float> tmp_hits_gphiIdeal;
175  std::vector<long> tmp_hits_fineID;
176  std::vector<int> tmp_hits_volumeID;
177 
178  std::vector<float> tmp_hits_x_sorted;
179  std::vector<float> tmp_hits_y_sorted;
180  std::vector<float> tmp_hits_z_sorted;
181  std::vector<float> tmp_hits_R_sorted;
182  std::vector<float> tmp_hits_phi_sorted;
183  std::vector<int> tmp_hits_layer_disk_sorted;
184  std::vector<bool> tmp_hits_isPixel_sorted;
185  std::vector<bool> tmp_hits_isStrip_sorted;
186  std::vector<bool> tmp_hits_isClustered_sorted;
187  std::vector<bool> tmp_hits_isSpacepoint_sorted;
188  std::vector<float> tmp_hits_barcodefrac_sorted;
189  std::vector<int> tmp_hits_barcode_sorted;
190  std::vector<float> tmp_hits_zIdeal_sorted;
191  std::vector<float> tmp_hits_gphiIdeal_sorted;
192  std::vector<long> tmp_hits_fineID_sorted;
193  std::vector<int> tmp_hits_volumeID_sorted;
194 
195  std::vector<bool> tmp_hits_mapped_sorted;
196  bool has_strip_nonspacepoint;
197 
198 
199  // fill the truth tree, simply once per event! to know which entry here to loop at for a given road or hit
200  // combination below, use treeindex from below to find the entry here
201  for (const auto & track : truthTracks) {
202  if (!m_EvtSel->passCuts(track)) continue;
203  if (track.getStatus() != 1) continue;
204 
205 
206  tmp_hits_x.clear();
207  tmp_hits_y.clear();
208  tmp_hits_z.clear();
209  tmp_hits_R.clear();
210  tmp_hits_phi.clear();
211  tmp_hits_layer_disk.clear();
212  tmp_hits_mapped.clear();
213  tmp_hits_isPixel.clear();
214  tmp_hits_isStrip.clear();
215  tmp_hits_isClustered.clear();
216  tmp_hits_isSpacepoint.clear();
217  tmp_hits_barcodefrac.clear();
218  tmp_hits_barcode.clear();
219  tmp_hits_zIdeal.clear();
220  tmp_hits_gphiIdeal.clear();
221  tmp_hits_fineID.clear();
222 
223  tmp_hits_x_sorted.clear();
224  tmp_hits_y_sorted.clear();
225  tmp_hits_z_sorted.clear();
226  tmp_hits_R_sorted.clear();
227  tmp_hits_phi_sorted.clear();
228  tmp_hits_layer_disk_sorted.clear();
229  tmp_hits_mapped_sorted.clear();
230  tmp_hits_isPixel_sorted.clear();
231  tmp_hits_isStrip_sorted.clear();
232  tmp_hits_isClustered_sorted.clear();
233  tmp_hits_isSpacepoint_sorted.clear();
234  tmp_hits_barcodefrac_sorted.clear();
235  tmp_hits_barcode_sorted.clear();
236  tmp_hits_zIdeal_sorted.clear();
237  tmp_hits_gphiIdeal_sorted.clear();
238  tmp_hits_fineID_sorted.clear();
239  tmp_hits_volumeID.clear();
240 
241  has_strip_nonspacepoint = false;
242 
243  double target_r;
244  std::vector<float> idealized_coords;
247 
248  // Collect truth tracks' 2nd stage hits
249  for (auto hit : hits_2nd) {
250  // Only write out hits belonging to the truth track
251  if (hit->getBarcode() == track.getBarcode()) {
252 
253  if (hit->isPixel() == 0 && hit->getHitType() != HitType::spacepoint) {has_strip_nonspacepoint = true;}
254 
255  FPGATrackSimMultiTruth truth = hit->getTruth();
257 
258  const bool ok = truth.best(tbarcode, tfrac);
259  if (tfrac < 1.0) { continue; }
260  if( ok ) {
261  tmp_hits_barcode.push_back((int)(tbarcode.second));
262  tmp_hits_barcodefrac.push_back(tfrac);
263  }
264  else {
265  tmp_hits_barcode.push_back(-1);
266  tmp_hits_barcodefrac.push_back(-1);
267  }
268 
269  tmp_hits_x.push_back(hit->getX());
270  tmp_hits_y.push_back(hit->getY());
271  tmp_hits_z.push_back(hit->getZ());
272  tmp_hits_R.push_back(hit->getR());
273  tmp_hits_phi.push_back(hit->getGPhi());
274  tmp_hits_layer_disk.push_back(hit->getLayerDisk(true));
275  tmp_hits_volumeID.push_back(getVolumeID(*hit));
276  tmp_hits_mapped.push_back(hit->isMapped());
277  tmp_hits_isPixel.push_back(hit->isPixel());
278  tmp_hits_isStrip.push_back(hit->isStrip());
279  tmp_hits_isClustered.push_back(hit->isClustered());
280 
281  tmp_hits_fineID.push_back(getFineID(*hit));
282 
283  target_r = m_SUBREGIONMAP->getAvgRadius(0, hit->getLayerDisk());
284  idealized_coords = computeIdealCoords(*hit, hit->getGPhi(), track.getQOverPt(), target_r, true, TrackCorrType::None);
285  tmp_hits_zIdeal.push_back(idealized_coords[0]);
286  tmp_hits_gphiIdeal.push_back(idealized_coords[1]);
287 
288  if (hit->getHitType() == HitType::spacepoint) {
289  tmp_hits_isSpacepoint.push_back(true);
290  }
291  else {
292  tmp_hits_isSpacepoint.push_back(false);
293  }
294  }
295  }
296 
297 
298  m_has_strip_nonspacepoint.push_back(has_strip_nonspacepoint);
299 
300  if ( (! writeOutNonSPStripHits & has_strip_nonspacepoint)) {
301  ATH_MSG_DEBUG("Truth Track is not written to HoughRootOutput file, because it contains a non-SP strip hit!");
302  continue;
303  }
304 
305  std::vector<int> sorting_index(tmp_hits_R.size(), 0);
306  for (unsigned int i = 0 ; i != sorting_index.size() ; i++) {
307  sorting_index[i] = i;
308  }
309  sort(sorting_index.begin(), sorting_index.end(),
310  [&](const int& a, const int& b) {
311  return (tmp_hits_R[a] < tmp_hits_R[b]);
312  }
313  );
314 
315  for (unsigned int i = 0 ; i != sorting_index.size() ; i++) {
316  tmp_hits_x_sorted.push_back(tmp_hits_x[sorting_index[i]]);
317  tmp_hits_y_sorted.push_back(tmp_hits_y[sorting_index[i]]);
318  tmp_hits_z_sorted.push_back(tmp_hits_z[sorting_index[i]]);
319  tmp_hits_R_sorted.push_back(tmp_hits_R[sorting_index[i]]);
320  tmp_hits_phi_sorted.push_back(tmp_hits_phi[sorting_index[i]]);
321  tmp_hits_layer_disk_sorted.push_back(tmp_hits_layer_disk[sorting_index[i]]);
322  tmp_hits_isPixel_sorted.push_back(tmp_hits_isPixel[sorting_index[i]]);
323  tmp_hits_isStrip_sorted.push_back(tmp_hits_isStrip[sorting_index[i]]);
324  tmp_hits_isClustered_sorted.push_back(tmp_hits_isClustered[sorting_index[i]]);
325  tmp_hits_isSpacepoint_sorted.push_back(tmp_hits_isSpacepoint[sorting_index[i]]);
326  tmp_hits_barcode_sorted.push_back(tmp_hits_barcode[sorting_index[i]]);
327  tmp_hits_barcodefrac_sorted.push_back(tmp_hits_barcodefrac[sorting_index[i]]);
328  tmp_hits_zIdeal_sorted.push_back(tmp_hits_zIdeal[sorting_index[i]]);
329  tmp_hits_gphiIdeal_sorted.push_back(tmp_hits_gphiIdeal[sorting_index[i]]);
330  tmp_hits_fineID_sorted.push_back(tmp_hits_fineID[sorting_index[i]]);
331  tmp_hits_volumeID_sorted.push_back(tmp_hits_volumeID[sorting_index[i]]);
332  tmp_hits_mapped_sorted.push_back(tmp_hits_mapped[sorting_index[i]]);
333 
334  };
335 
336  m_track_hit_x.push_back(tmp_hits_x_sorted);
337  m_track_hit_y.push_back(tmp_hits_y_sorted);
338  m_track_hit_z.push_back(tmp_hits_z_sorted);
339  m_track_hit_R.push_back(tmp_hits_R_sorted);
340  m_track_hit_phi.push_back(tmp_hits_phi_sorted);
341  m_track_hit_layer_disk.push_back(tmp_hits_layer_disk_sorted);
342  m_track_hit_isPixel.push_back(tmp_hits_isPixel_sorted);
343  m_track_hit_isStrip.push_back(tmp_hits_isStrip);
344  m_track_hit_isClustered.push_back(tmp_hits_isClustered_sorted);
345  m_track_hit_isSpacepoint.push_back(tmp_hits_isSpacepoint_sorted);
346  m_track_hit_barcode.push_back(tmp_hits_barcode_sorted);
347  m_track_hit_barcodefrac.push_back(tmp_hits_barcodefrac_sorted);
348  m_track_hit_zIdeal.push_back(tmp_hits_zIdeal_sorted);
349  m_track_hit_gphiIdeal.push_back(tmp_hits_gphiIdeal_sorted);
350  m_track_hit_fineID.push_back(tmp_hits_fineID_sorted);
351  m_track_hit_volumeID.push_back(tmp_hits_volumeID_sorted);
352  m_track_hit_isMapped.push_back(tmp_hits_mapped_sorted);
353 
354  m_truth_d0.push_back(track.getD0());
355  m_truth_z0.push_back(track.getZ0());
356  m_truth_pt.push_back(track.getPt());
357  m_truth_eta.push_back(track.getEta());
358  m_truth_phi.push_back(track.getPhi());
359  m_truth_barcode.push_back(track.getBarcode());
360  m_truth_eventindex.push_back(track.getEventIndex());
361  m_truth_q.push_back(track.getQ());
362  m_truth_pdg.push_back(track.getPDGCode());
363  }
364  // Fill only if at least one truth track to save to avoid empty events
365  if (m_truth_eventindex.size() != 0) {
366  m_truthtree->Fill();
367  }
368  ResetVectors();
369 
370 
371  // now do the same for offline tree, once per event
372  for (const auto & track : offlineTracks) {
373  if (!m_EvtSel->passCuts(track)) continue;
374 
375  m_offline_d0.push_back(track.getD0());
376  m_offline_z0.push_back(track.getZ0());
377  m_offline_pt.push_back(abs(1./track.getQOverPt()));
378  m_offline_eta.push_back(track.getEta());
379  m_offline_phi.push_back(track.getPhi());
380  m_offline_barcode.push_back(track.getBarcode());
381  m_offline_barcodefrac.push_back(track.getBarcodeFrac());
382 
383  m_offline_q.push_back(track.getQOverPt() > 0 ? 1 : -1);
384  int nhole(0), nmeasurement(0), ninert(0), nbrem(0), nscatter(0), nperigee(0), noutlier(0), nother(0);
385  for (const auto& hit : track.getOfflineHits()) {
386  if (hit.getHitType() == OfflineHitType::Measurement) nmeasurement++;
387  else if (hit.getHitType() == OfflineHitType::InertMaterial) ninert++;
388  else if (hit.getHitType() == OfflineHitType::BremPoint) nbrem++;
389  else if (hit.getHitType() == OfflineHitType::Scatterer) nscatter++;
390  else if (hit.getHitType() == OfflineHitType::Perigee) nperigee++;
391  else if (hit.getHitType() == OfflineHitType::Outlier) noutlier++;
392  else if (hit.getHitType() == OfflineHitType::Hole) nhole++;
393  else nother++;
394  }
395  m_offline_n_holes.push_back(nhole);
396  m_offline_n_measurement.push_back(nmeasurement);
397  m_offline_n_inertmaterial.push_back(ninert);
398  m_offline_n_brempoint.push_back(nbrem);
399  m_offline_n_scatterer.push_back(nscatter);
400  m_offline_n_perigee.push_back(nperigee);
401  m_offline_n_outlier.push_back(noutlier);
402  m_offline_n_other.push_back(nother);
403  }
404  m_offlinetree->Fill();
405  ResetVectors();
406 
407  // for calculating the truth for the entire combination, not just an individual hit
408  std::vector<FPGATrackSimMultiTruth> mtv;
409 
410  double target_r;
411 
412  for (size_t iroad = 0; iroad < track_cands.size(); iroad++) {
413  m_roadnumber = iroad;
414  FPGATrackSimTrack road = track_cands[iroad];
415 
416  if (roadsAreSecondStage) {
417  mtv.reserve( m_FPGATrackSimMapping->PlaneMap_2nd(road.getSubRegion())->getNLogiLayers());
418  }
419  else {
420  mtv.reserve( m_FPGATrackSimMapping->PlaneMap_1st(road.getSubRegion())->getNLogiLayers());
421  }
422 
423  m_roadChi2.push_back(track_cands[iroad].getChi2ndof());
424 
425  m_nMissingHits.push_back(track_cands[iroad].getNMissing());
426 
427  m_passesOR.push_back(road.passedOR());
428 
429  m_phi = road.getHoughX();
430  m_invpt = road.getHoughY();
431  m_subregion = road.getRegion();
432  std::vector<FPGATrackSimHit> hits = road.getFPGATrackSimHits();
433 
434 
435  // Add the hits from each combination to the tree
436  for (FPGATrackSimHit hit : hits) {
437 
438  m_realHit.push_back(hit.isReal());
439  FPGATrackSimMultiTruth truth = hit.getTruth();
440 
442  mtv.push_back( truth );
443 
446  const bool ok = truth.best(tbarcode,tfrac);
447  if( ok ) {
448  m_eventindex.push_back((int)(tbarcode.first));
449  m_barcode.push_back((int)(tbarcode.second));
450  m_barcodefrac.push_back(tfrac);
451  }
452  else {
453  m_eventindex.push_back(-1);
454  m_barcode.push_back(-1);
455  m_barcodefrac.push_back(-1);
456  }
457 
458  target_r = m_SUBREGIONMAP->getAvgRadius(0, hit.getLayer());
459  std::shared_ptr<const FPGATrackSimHit> hit_ptr = std::make_shared<const FPGATrackSimHit>(hit);
460  std::vector<float> idealized_coords = computeIdealCoords(hit, m_invpt, hit.getGPhi(), target_r, true, TrackCorrType::None);
461 
462  m_x.push_back(hit.getX());
463  m_y.push_back(hit.getY());
464  m_z.push_back(hit.getZ());
465  m_volumeID.push_back(getVolumeID(*hit_ptr));
466  m_custom_layerID.push_back(getFineID(*hit_ptr));
467  m_layerID.push_back(hit.getLayerDisk(true));
468  m_etaID.push_back(hit.getEtaModule(true));
469 
470  m_gphi.push_back(hit.getGPhi());
471  m_zIdeal.push_back(idealized_coords[0]);
472  m_gphiIdeal.push_back(idealized_coords[1]);
473  m_isPixel.push_back(hit.isPixel() ? 1 : 0);
474  m_layer.push_back(hit.getLayer());
475  m_isBarrel.push_back(hit.isBarrel() ? 1 : 0);
476  m_etawidth.push_back(hit.getEtaWidth());
477  m_phiwidth.push_back(hit.getPhiWidth());
478  m_etamodule.push_back(hit.getEtaModule(true));
479  m_phimodule.push_back(hit.getPhiModule());
480  m_ID.push_back(hit.getIdentifierHash());
481  m_diskLayer.push_back(hit.getLayerDisk(true));
482  }
483 
484  // done looping over hits, now we do the truth calculation for this track candidate
485  // first compute the best geant match, the barcode with the largest number of contributing hits
486  // frac is then the fraction of the total number of hits on the candidate attributed to the barcode.
488  // retrieve the best barcode and frac and store it
491  const bool ok = mt.best(tbarcode,tfrac);
492  if( ok ) {
493  m_candidate_eventindex = (int)(tbarcode.first);
494  m_candidate_barcode = (int)(tbarcode.second);
495  m_candidate_barcodefrac = tfrac;
496  if ( tfrac <= 0.5 ) m_fakelabel = 1;
497  else if ( tfrac == 1.0 ) m_fakelabel = 0;
498  }
499  else {
501  m_candidate_barcode = -1;
503  m_fakelabel = 2;
504  }
505 
506  for (const auto & track : truthTracks) {
507  if (!m_EvtSel->passCuts(track)) continue;
508  if (track.getStatus() != 1) continue;
509 
510  m_associated_truth_d0 = track.getD0();
511  m_associated_truth_z0 = track.getZ0();
512  m_associated_truth_pt = track.getPt();
513  m_associated_truth_q = track.getQ();
514  m_associated_truth_eta = track.getEta();
515  m_associated_truth_phi = track.getPhi();
516  break;
517  }
518 
519  m_tree->Fill();
520 
521  mtv.clear();
522  ResetVectors();
523  m_tracknumber++;
524  }
525  m_treeindex++;
526  return StatusCode::SUCCESS;
527 }
528 
529 
530 
531 StatusCode FPGATrackSimHoughRootOutputTool::fillTree(const std::vector<std::shared_ptr<const FPGATrackSimRoad>> &roads, const std::vector<FPGATrackSimTruthTrack> &truthTracks, const std::vector<FPGATrackSimOfflineTrack> &offlineTracks, const std::vector<std::shared_ptr<const FPGATrackSimHit>> &hits_2nd, const bool writeOutNonSPStripHits, const float minChi2, const int maxOverlappingHits, const bool roadsAreSecondStage)
532 {
533  ATH_MSG_DEBUG("Running HoughOutputTool!!");
534 
535 
536  // Create a list of track candidates by taking all possible combinations of hits in road.
537  std::vector<FPGATrackSimTrack> track_cands;
538 
539  for (size_t iroad = 0; iroad < roads.size(); iroad++) {
540  m_roadnumber = iroad;
541  std::shared_ptr<const FPGATrackSimRoad> road = roads[iroad];
542  std::vector<FPGATrackSimTrack> track_cand;
543  if (road == nullptr) continue; // Not Hough roads
544 
545  auto pmap = m_FPGATrackSimMapping->PlaneMap_1st(road->getSubRegion());
546 
547  if (roadsAreSecondStage) {
548  pmap = m_FPGATrackSimMapping->PlaneMap_2nd(road->getSubRegion());
549  }
550 
551  std::vector<std::vector<int>> combs = ::getComboIndices(road->getNHits_layer());
552  m_phi = road->getX();
553  m_invpt = road->getY();
554 
555  // Build track candidate for OR tool
556  int nMissing;
557  bool missPixel;
558  bool missStrip;
559  layer_bitmask_t missing_mask;
560  layer_bitmask_t norecovery_mask; // mask to prevent majority in planes with multiple hits
561  getMissingInfo(*road, nMissing, missPixel, missStrip, missing_mask, norecovery_mask, m_FPGATrackSimMapping, m_idealCoordFitType);
562  // Create a template track with common parameters filled already for initializing below
563  FPGATrackSimTrack temp;
564 
565  if (roadsAreSecondStage) {
567  }
568  else {
570  }
571  temp.setSecondSectorID(road->getSector());
572  temp.setNLayers(pmap->getNLogiLayers());
573  temp.setBankID(-1); // TODO
574  temp.setPatternID(road->getPID());
575  temp.setHitMap(missing_mask);
576  temp.setNMissing(nMissing);
577  temp.setHoughX(road->getX());
578  temp.setHoughY(road->getY());
579  temp.setQOverPt(road->getY());
581  temp.setDoDeltaGPhis(true);
582  temp.setPassedOR(1);
583 
584  makeTrackCandidates(*road, temp, track_cand, m_FPGATrackSimMapping);
585  for (auto const &tr : track_cand) {
586  track_cands.push_back(tr);
587  }
588  }
589 
590  ATH_CHECK(runOverlapRemoval(track_cands, minChi2, maxOverlappingHits, m_algo, m_monTool));
591  unsigned long passed = 0;
592  for (auto const &cand : track_cands) {
593  if (cand.passedOR()) {
594  passed++;
595  }
596  }
597 
598  m_NTracksORMinusRoads = passed - roads.size();
599 
600  return fillTree(track_cands, truthTracks, offlineTracks, hits_2nd, writeOutNonSPStripHits, roadsAreSecondStage);
601 }
602 
604  m_x.clear();
605  m_y.clear();
606  m_z.clear();
607  m_volumeID.clear();
608  m_custom_layerID.clear();
609 
610  m_layerID.clear();
611  m_etaID.clear();
612 
613  m_barcode.clear();
614  m_barcodefrac.clear();
615  m_eventindex.clear();
616  m_realHit.clear();
617  m_isPixel.clear();
618  m_layer.clear();
619  m_isBarrel.clear();
620  m_etawidth.clear();
621  m_phiwidth.clear();
622  m_etamodule.clear();
623  m_phimodule.clear();
624  m_ID.clear();
625  m_diskLayer.clear();
626  m_passesOR.clear();
627  m_roadChi2.clear();
628  m_nMissingHits.clear();
629  m_truth_d0.clear();
630  m_truth_z0.clear();
631  m_truth_pt.clear();
632  m_truth_eta.clear();
633  m_truth_phi.clear();
634  m_truth_q.clear();
635  m_truth_barcode.clear();
636  m_truth_eventindex.clear();
637  m_truth_pdg.clear();
638  m_track_hit_volumeID.clear();
639  m_offline_n_holes.clear();
640  m_offline_n_measurement.clear();
642  m_offline_n_brempoint.clear();
643  m_offline_n_scatterer.clear();
644  m_offline_n_perigee.clear();
645  m_offline_n_outlier.clear();
646  m_offline_n_other.clear();
647  m_offline_d0.clear();
648  m_offline_z0.clear();
649  m_offline_pt.clear();
650  m_offline_eta.clear();
651  m_offline_phi.clear();
652  m_offline_q.clear();
653  m_offline_barcode.clear();
654  m_offline_barcodefrac.clear();
655  m_track_hit_x.clear();
656  m_track_hit_y.clear();
657  m_track_hit_z.clear();
658  m_track_hit_R.clear();
659  m_track_hit_phi.clear();
660  m_track_hit_layer_disk.clear();
661  m_track_hit_isPixel.clear();
662  m_track_hit_isStrip.clear();
663  m_track_hit_isClustered.clear();
664  m_track_hit_isSpacepoint.clear();
665  m_track_hit_barcode.clear();
666  m_track_hit_barcodefrac.clear();
667  m_track_hit_zIdeal.clear();
668  m_track_hit_gphiIdeal.clear();
669  m_track_hit_fineID.clear();
670  m_track_hit_isMapped.clear();
671 
672  m_gphi.clear();
673  m_zIdeal.clear();
674  m_gphiIdeal.clear();
676 }
FPGATrackSimTrack::setHitMap
void setHitMap(unsigned int v)
Definition: FPGATrackSimTrack.h:101
OfflineHitType::Hole
@ Hole
FPGATrackSimHoughRootOutputTool::m_roadChi2
std::vector< float > m_roadChi2
Definition: FPGATrackSimHoughRootOutputTool.h:99
FPGATrackSimHoughRootOutputTool::m_track_hit_isClustered
std::vector< std::vector< bool > > m_track_hit_isClustered
Definition: FPGATrackSimHoughRootOutputTool.h:157
FPGATrackSimHoughRootOutputTool::m_barcodefrac
std::vector< float > m_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:86
FPGATrackSimHoughRootOutputTool::m_track_hit_isMapped
std::vector< std::vector< bool > > m_track_hit_isMapped
Definition: FPGATrackSimHoughRootOutputTool.h:159
FPGATrackSimHoughRootOutputTool::m_track_hit_y
std::vector< std::vector< float > > m_track_hit_y
Definition: FPGATrackSimHoughRootOutputTool.h:149
FPGATrackSimHoughRootOutputTool::m_truth_phi
std::vector< float > m_truth_phi
Definition: FPGATrackSimHoughRootOutputTool.h:142
FPGATrackSimHoughRootOutputTool::m_offline_z0
std::vector< float > m_offline_z0
Definition: FPGATrackSimHoughRootOutputTool.h:179
getMenu.algname
algname
Definition: getMenu.py:54
FPGATrackSimHoughRootOutputTool::m_track_hit_gphiIdeal
std::vector< std::vector< float > > m_track_hit_gphiIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:163
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSimTrack::setBankID
void setBankID(int v)
Definition: FPGATrackSimTrack.h:84
FPGATrackSimHoughRootOutputTool::m_track_hit_barcode
std::vector< std::vector< int > > m_track_hit_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:160
FPGATrackSimHoughRootOutputTool::m_associated_truth_d0
float m_associated_truth_d0
Definition: FPGATrackSimHoughRootOutputTool.h:117
FPGATrackSimHoughRootOutputTool::m_isBarrel
std::vector< unsigned int > m_isBarrel
Definition: FPGATrackSimHoughRootOutputTool.h:91
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
FPGATrackSimHoughRootOutputTool::m_layer
std::vector< unsigned int > m_layer
Definition: FPGATrackSimHoughRootOutputTool.h:90
FPGATrackSimRoad::getSubRegion
int getSubRegion() const
Definition: FPGATrackSimRoad.h:86
FPGATrackSimHoughRootOutputTool::m_track_hit_phi
std::vector< std::vector< float > > m_track_hit_phi
Definition: FPGATrackSimHoughRootOutputTool.h:153
OfflineHitType::InertMaterial
@ InertMaterial
FPGATrackSimTrack
Definition: FPGATrackSimTrack.h:18
FPGATrackSimHoughRootOutputTool::initialize
virtual StatusCode initialize() override
Definition: FPGATrackSimHoughRootOutputTool.cxx:20
FPGATrackSimHoughRootOutputTool::m_offline_phi
std::vector< float > m_offline_phi
Definition: FPGATrackSimHoughRootOutputTool.h:182
FPGATrackSimTrack::setPatternID
void setPatternID(int v)
Definition: FPGATrackSimTrack.h:85
OfflineHitType::BremPoint
@ BremPoint
FPGATrackSimMultiTruth::Weight
float Weight
Definition: FPGATrackSimMultiTruth.h:50
OfflineHitType::Measurement
@ Measurement
FPGATrackSimHoughRootOutputTool::m_track_hit_zIdeal
std::vector< std::vector< float > > m_track_hit_zIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:162
FPGATrackSimHoughRootOutputTool::m_realHit
std::vector< bool > m_realHit
Definition: FPGATrackSimHoughRootOutputTool.h:102
FPGATrackSimHoughRootOutputTool::m_x
std::vector< float > m_x
Definition: FPGATrackSimHoughRootOutputTool.h:76
FPGATrackSimHoughRootOutputTool::m_offlinetree
TTree * m_offlinetree
Definition: FPGATrackSimHoughRootOutputTool.h:168
FPGATrackSimTrack::setNMissing
void setNMissing(int v)
Definition: FPGATrackSimTrack.h:99
ORAlgo::Normal
@ Normal
FPGATrackSimHoughRootOutputTool::m_offline_n_brempoint
std::vector< int > m_offline_n_brempoint
Definition: FPGATrackSimHoughRootOutputTool.h:172
FPGATrackSimTrack::setPassedOR
void setPassedOR(unsigned int)
Definition: FPGATrackSimTrack.cxx:259
FPGATrackSimTrack::getRegion
int getRegion() const
Definition: FPGATrackSimTrack.h:48
FPGATrackSimHoughRootOutputTool::m_gphiIdeal
std::vector< float > m_gphiIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:85
FPGATrackSimHoughRootOutputTool::m_diskLayer
std::vector< unsigned int > m_diskLayer
Definition: FPGATrackSimHoughRootOutputTool.h:97
FPGATrackSimHoughRootOutputTool::m_etawidth
std::vector< unsigned int > m_etawidth
Definition: FPGATrackSimHoughRootOutputTool.h:92
HitType::spacepoint
@ spacepoint
FPGATrackSimHoughRootOutputTool::m_treeindex
int m_treeindex
Definition: FPGATrackSimHoughRootOutputTool.h:130
FPGATrackSimHoughRootOutputTool::m_track_hit_R
std::vector< std::vector< float > > m_track_hit_R
Definition: FPGATrackSimHoughRootOutputTool.h:151
FPGATrackSimHoughRootOutputTool::m_track_hit_layer_disk
std::vector< std::vector< int > > m_track_hit_layer_disk
Definition: FPGATrackSimHoughRootOutputTool.h:154
FPGATrackSimTrack::getSubRegion
int getSubRegion() const
Definition: FPGATrackSimTrack.h:47
FPGATrackSimTrack::passedOR
unsigned int passedOR() const
Definition: FPGATrackSimTrack.h:139
FPGATrackSimTrack::getHoughY
float getHoughY() const
Definition: FPGATrackSimTrack.h:35
FPGATrackSimHoughRootOutputTool::m_has_strip_nonspacepoint
std::vector< bool > m_has_strip_nonspacepoint
Definition: FPGATrackSimHoughRootOutputTool.h:147
FPGATrackSimRoad::getNHits_layer
std::vector< size_t > getNHits_layer() const
Definition: FPGATrackSimRoad.cxx:27
FPGATrackSimHoughRootOutputTool::m_isPixel
std::vector< unsigned int > m_isPixel
Definition: FPGATrackSimHoughRootOutputTool.h:89
FPGATrackSimRoad::getX
float getX() const
Definition: FPGATrackSimRoad.h:89
FPGATrackSimHoughRootOutputTool::m_phi
float m_phi
Definition: FPGATrackSimHoughRootOutputTool.h:107
FPGATrackSimMultiTruth::best
bool best(FPGATrackSimMultiTruth::Barcode &code, FPGATrackSimMultiTruth::Weight &weight) const
Definition: FPGATrackSimMultiTruth.h:86
FPGATrackSimConstants.h
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
FPGATrackSimTrack::setSecondSectorID
void setSecondSectorID(int v)
Definition: FPGATrackSimTrack.h:87
FPGATrackSimHoughRootOutputTool::m_passesOR
std::vector< unsigned int > m_passesOR
Definition: FPGATrackSimHoughRootOutputTool.h:98
FPGATrackSimTrack::getFPGATrackSimHits
const std::vector< FPGATrackSimHit > & getFPGATrackSimHits() const
Definition: FPGATrackSimTrack.h:63
computeIdealCoords
std::vector< float > computeIdealCoords(const FPGATrackSimHit &hit, const double hough_x, const double hough_y, const double target_r, const bool doDeltaGPhis, const TrackCorrType trackCorrType)
Definition: FPGATrackSimFunctions.cxx:116
FPGATrackSimHoughRootOutputTool::m_offline_n_outlier
std::vector< int > m_offline_n_outlier
Definition: FPGATrackSimHoughRootOutputTool.h:175
FPGATrackSimHoughRootOutputTool::m_idealCoordFitType
TrackCorrType m_idealCoordFitType
Definition: FPGATrackSimHoughRootOutputTool.h:104
OfflineHitType::Perigee
@ Perigee
FPGATrackSimHoughRootOutputTool::m_subregion
unsigned int m_subregion
Definition: FPGATrackSimHoughRootOutputTool.h:109
FPGATrackSimHoughRootOutputTool::m_phiwidth
std::vector< unsigned int > m_phiwidth
Definition: FPGATrackSimHoughRootOutputTool.h:93
FPGATrackSimHoughRootOutputTool::m_track_hit_fineID
std::vector< std::vector< long > > m_track_hit_fineID
Definition: FPGATrackSimHoughRootOutputTool.h:164
lumiFormat.i
int i
Definition: lumiFormat.py:85
FPGATrackSimHoughRootOutputTool::m_region
Gaudi::Property< std::string > m_region
Definition: FPGATrackSimHoughRootOutputTool.h:66
FPGATrackSimHoughRootOutputTool::m_truth_z0
std::vector< float > m_truth_z0
Definition: FPGATrackSimHoughRootOutputTool.h:139
FPGATrackSimHoughRootOutputTool::m_offline_d0
std::vector< float > m_offline_d0
Definition: FPGATrackSimHoughRootOutputTool.h:178
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
FPGATrackSimHoughRootOutputTool::m_offline_eta
std::vector< float > m_offline_eta
Definition: FPGATrackSimHoughRootOutputTool.h:181
getFineID
long getFineID(const FPGATrackSimHit &hit)
Definition: FPGATrackSimHoughFunctions.cxx:624
TrackStage::FIRST
@ FIRST
FPGATrackSimTrack::setDoDeltaGPhis
void setDoDeltaGPhis(bool v)
Definition: FPGATrackSimTrack.h:83
FPGATrackSimMultiTruth::Barcode
std::pair< unsigned long, unsigned long > Barcode
Definition: FPGATrackSimMultiTruth.h:49
FPGATrackSimHoughRootOutputTool::m_z
std::vector< float > m_z
Definition: FPGATrackSimHoughRootOutputTool.h:78
FPGATrackSimHoughRootOutputTool::m_offline_n_measurement
std::vector< int > m_offline_n_measurement
Definition: FPGATrackSimHoughRootOutputTool.h:170
FPGATrackSimHoughRootOutputTool::m_candidate_eventindex
float m_candidate_eventindex
Definition: FPGATrackSimHoughRootOutputTool.h:115
FPGATrackSimHoughRootOutputTool::m_candidate_barcodefrac
float m_candidate_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:113
FPGATrackSimHoughRootOutputTool::m_track_hit_z
std::vector< std::vector< float > > m_track_hit_z
Definition: FPGATrackSimHoughRootOutputTool.h:150
FPGATrackSimHoughRootOutputTool::m_invpt
float m_invpt
Definition: FPGATrackSimHoughRootOutputTool.h:108
FPGATrackSimHoughRootOutputTool::m_SUBREGIONMAP
const FPGATrackSimRegionMap * m_SUBREGIONMAP
Definition: FPGATrackSimHoughRootOutputTool.h:70
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimHoughRootOutputTool::m_truth_eventindex
std::vector< int > m_truth_eventindex
Definition: FPGATrackSimHoughRootOutputTool.h:146
TrackStage::SECOND
@ SECOND
FPGATrackSimHoughRootOutputTool::m_truthtree
TTree * m_truthtree
Definition: FPGATrackSimHoughRootOutputTool.h:136
FPGATrackSimHoughRootOutputTool::m_offline_q
std::vector< int > m_offline_q
Definition: FPGATrackSimHoughRootOutputTool.h:183
FPGATrackSimHoughRootOutputTool::m_associated_truth_q
float m_associated_truth_q
Definition: FPGATrackSimHoughRootOutputTool.h:120
FPGATrackSimHoughRootOutputTool::ResetVectors
void ResetVectors()
Definition: FPGATrackSimHoughRootOutputTool.cxx:603
FPGATrackSimTrack::setTrackCorrType
void setTrackCorrType(TrackCorrType v)
Definition: FPGATrackSimTrack.h:81
FPGATrackSimHoughRootOutputTool::m_truth_d0
std::vector< float > m_truth_d0
Definition: FPGATrackSimHoughRootOutputTool.h:138
FPGATrackSimHoughRootOutputTool::m_gphi
std::vector< float > m_gphi
Definition: FPGATrackSimHoughRootOutputTool.h:83
getComboIndices
std::vector< std::vector< int > > getComboIndices(std::vector< size_t > const &sizes)
Given a vector of sizes (of arrays), generates a vector of all combinations of indices to index one e...
Definition: FPGATrackSimFunctions.cxx:21
FPGATrackSimHoughRootOutputTool::m_etamodule
std::vector< unsigned int > m_etamodule
Definition: FPGATrackSimHoughRootOutputTool.h:94
FPGATrackSimHoughRootOutputTool::m_truth_pdg
std::vector< float > m_truth_pdg
Definition: FPGATrackSimHoughRootOutputTool.h:143
FPGATrackSimHoughRootOutputTool::m_offline_n_perigee
std::vector< int > m_offline_n_perigee
Definition: FPGATrackSimHoughRootOutputTool.h:174
FPGATrackSimTrack::setTrackStage
void setTrackStage(TrackStage v)
Definition: FPGATrackSimTrack.h:82
FPGATrackSimHoughRootOutputTool.h
Output roads into a ROOT file.
FPGATrackSimMultiTruth
Definition: FPGATrackSimMultiTruth.h:46
FPGATrackSimHoughRootOutputTool::m_FPGATrackSimMapping
ServiceHandle< IFPGATrackSimMappingSvc > m_FPGATrackSimMapping
Definition: FPGATrackSimHoughRootOutputTool.h:63
FPGATrackSimMultiTruth::AddAccumulator
Definition: FPGATrackSimMultiTruth.h:57
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
FPGATrackSimHoughRootOutputTool::m_nMissingHits
std::vector< float > m_nMissingHits
Definition: FPGATrackSimHoughRootOutputTool.h:100
FPGATrackSimHoughRootOutputTool::m_volumeID
std::vector< int > m_volumeID
Definition: FPGATrackSimHoughRootOutputTool.h:79
TrackCorrType::None
@ None
FPGATrackSimFunctions.h
FPGATrackSimHoughRootOutputTool::m_track_hit_isSpacepoint
std::vector< std::vector< bool > > m_track_hit_isSpacepoint
Definition: FPGATrackSimHoughRootOutputTool.h:158
FPGATrackSimTrack::setHoughY
void setHoughY(float v)
Definition: FPGATrackSimTrack.h:91
FPGATrackSimHoughRootOutputTool::m_truth_eta
std::vector< float > m_truth_eta
Definition: FPGATrackSimHoughRootOutputTool.h:141
FPGATrackSimTrack::setQOverPt
void setQOverPt(float v)
Definition: FPGATrackSimTrack.h:92
FPGATrackSimHoughRootOutputTool::fillTree
StatusCode fillTree(const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, const std::vector< FPGATrackSimTruthTrack > &truthTracks, const std::vector< FPGATrackSimOfflineTrack > &offlineTracks, const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits_2nd, const bool writeOutNonSPStripHits, const float minChi2, const int maxOverlappingHits, const bool roadsAreSecondStage)
Definition: FPGATrackSimHoughRootOutputTool.cxx:531
FPGATrackSimHoughRootOutputTool::m_truth_q
std::vector< int > m_truth_q
Definition: FPGATrackSimHoughRootOutputTool.h:144
FPGATrackSimHoughRootOutputTool::m_offline_n_inertmaterial
std::vector< int > m_offline_n_inertmaterial
Definition: FPGATrackSimHoughRootOutputTool.h:171
FPGATrackSimRoad::getY
float getY() const
Definition: FPGATrackSimRoad.h:90
FPGATrackSimHoughRootOutputTool::m_algo
ORAlgo m_algo
Definition: FPGATrackSimHoughRootOutputTool.h:68
FPGATrackSimHoughRootOutputTool::m_tHistSvc
ServiceHandle< ITHistSvc > m_tHistSvc
Definition: FPGATrackSimHoughRootOutputTool.h:64
FPGATrackSimHoughRootOutputTool::m_EvtSel
ServiceHandle< IFPGATrackSimEventSelectionSvc > m_EvtSel
Definition: FPGATrackSimHoughRootOutputTool.h:62
FPGATrackSimHoughRootOutputTool::m_roadnumber
int m_roadnumber
Definition: FPGATrackSimHoughRootOutputTool.h:133
ORAlgo::InvertGrouping
@ InvertGrouping
FPGATrackSimHoughRootOutputTool::m_barcode
std::vector< unsigned long > m_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:87
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:60
FPGATrackSimHoughRootOutputTool::FPGATrackSimHoughRootOutputTool
FPGATrackSimHoughRootOutputTool(const std::string &, const std::string &, const IInterface *)
Definition: FPGATrackSimHoughRootOutputTool.cxx:12
FPGATrackSimHoughRootOutputTool::m_track_hit_x
std::vector< std::vector< float > > m_track_hit_x
Definition: FPGATrackSimHoughRootOutputTool.h:148
getVolumeID
long getVolumeID(const FPGATrackSimHit &hit)
Definition: FPGATrackSimHoughFunctions.cxx:532
a
TList * a
Definition: liststreamerinfos.cxx:10
FPGATrackSimHoughRootOutputTool::m_algorithm
Gaudi::Property< std::string > m_algorithm
Definition: FPGATrackSimHoughRootOutputTool.h:65
runOverlapRemoval
StatusCode runOverlapRemoval(std::vector< FPGATrackSimTrack > &tracks, const float minChi2, const int NumOfHitPerGrouping, ORAlgo orAlgo, ToolHandle< GenericMonitoringTool > &monTool, bool compareAllHits=false)
Definition: FPGATrackSimHoughFunctions.cxx:15
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
FPGATrackSimHoughRootOutputTool::m_associated_truth_z0
float m_associated_truth_z0
Definition: FPGATrackSimHoughRootOutputTool.h:118
FPGATrackSimHoughRootOutputTool::m_offline_barcode
std::vector< int > m_offline_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:184
IFPGATrackSimEventSelectionSvc.h
makeTrackCandidates
void makeTrackCandidates(const FPGATrackSimRoad &road, const FPGATrackSimTrack &temp, std::vector< FPGATrackSimTrack > &track_cands, const ServiceHandle< IFPGATrackSimMappingSvc > &FPGATrackSimMapping)
Creates a list of track candidates by taking all possible combination of hits in road.
Definition: FPGATrackSimHoughFunctions.cxx:463
FPGATrackSimHoughRootOutputTool::m_offline_n_scatterer
std::vector< int > m_offline_n_scatterer
Definition: FPGATrackSimHoughRootOutputTool.h:173
FPGATrackSimHoughRootOutputTool::m_layerID
std::vector< int > m_layerID
Definition: FPGATrackSimHoughRootOutputTool.h:81
FPGATrackSimHoughRootOutputTool::m_fakelabel
unsigned int m_fakelabel
Definition: FPGATrackSimHoughRootOutputTool.h:116
layer_bitmask_t
uint32_t layer_bitmask_t
Definition: FPGATrackSimTypes.h:22
FPGATrackSimHoughRootOutputTool::m_eventindex
std::vector< int > m_eventindex
Definition: FPGATrackSimHoughRootOutputTool.h:88
FPGATrackSimHoughRootOutputTool::m_candidate_barcode
float m_candidate_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:114
FPGATrackSimHoughRootOutputTool::m_associated_truth_pt
float m_associated_truth_pt
Definition: FPGATrackSimHoughRootOutputTool.h:119
FPGATrackSimHoughRootOutputTool::m_offline_n_other
std::vector< int > m_offline_n_other
Definition: FPGATrackSimHoughRootOutputTool.h:176
FPGATrackSimHoughRootOutputTool::m_offline_n_holes
std::vector< int > m_offline_n_holes
Definition: FPGATrackSimHoughRootOutputTool.h:169
FPGATrackSimHoughRootOutputTool::m_associated_truth_eta
float m_associated_truth_eta
Definition: FPGATrackSimHoughRootOutputTool.h:121
FPGATrackSimHoughRootOutputTool::m_offline_pt
std::vector< float > m_offline_pt
Definition: FPGATrackSimHoughRootOutputTool.h:180
FPGATrackSimHoughRootOutputTool::m_tracknumber
int m_tracknumber
Definition: FPGATrackSimHoughRootOutputTool.h:127
FPGATrackSimHoughRootOutputTool::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: FPGATrackSimHoughRootOutputTool.h:73
FPGATrackSimHoughRootOutputTool::m_track_hit_barcodefrac
std::vector< std::vector< float > > m_track_hit_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:161
FPGATrackSimRoad::getSector
sector_t getSector() const
Definition: FPGATrackSimRoad.h:94
FPGATrackSimHoughRootOutputTool::m_NTracksORMinusRoads
long m_NTracksORMinusRoads
Definition: FPGATrackSimHoughRootOutputTool.h:110
FPGATrackSimRoad::getPID
pid_t getPID() const
Definition: FPGATrackSimRoad.h:93
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
FPGATrackSimHoughRootOutputTool::m_etaID
std::vector< int > m_etaID
Definition: FPGATrackSimHoughRootOutputTool.h:82
FPGATrackSimHoughRootOutputTool::m_offline_barcodefrac
std::vector< float > m_offline_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:185
FPGATrackSimHoughRootOutputTool::m_phimodule
std::vector< unsigned int > m_phimodule
Definition: FPGATrackSimHoughRootOutputTool.h:95
OfflineHitType::Scatterer
@ Scatterer
AthAlgTool
Definition: AthAlgTool.h:26
FPGATrackSimTrack::setNLayers
void setNLayers(int)
set the number of layers in the track.
Definition: FPGATrackSimTrack.cxx:107
FPGATrackSimHoughRootOutputTool::m_IdealCoordFitType
TrackCorrType m_IdealCoordFitType
Definition: FPGATrackSimHoughRootOutputTool.h:71
FPGATrackSimHoughRootOutputTool::m_ID
std::vector< unsigned int > m_ID
Definition: FPGATrackSimHoughRootOutputTool.h:96
FPGATrackSimHoughRootOutputTool::m_track_hit_isStrip
std::vector< std::vector< bool > > m_track_hit_isStrip
Definition: FPGATrackSimHoughRootOutputTool.h:156
FPGATrackSimHoughRootOutputTool::m_truth_barcode
std::vector< int > m_truth_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:145
FPGATrackSimTrack::getHoughX
float getHoughX() const
Definition: FPGATrackSimTrack.h:34
OfflineHitType::Outlier
@ Outlier
FPGATrackSimHoughRootOutputTool::m_track_hit_isPixel
std::vector< std::vector< bool > > m_track_hit_isPixel
Definition: FPGATrackSimHoughRootOutputTool.h:155
FPGATrackSimHoughRootOutputTool::m_y
std::vector< float > m_y
Definition: FPGATrackSimHoughRootOutputTool.h:77
FPGATrackSimHoughRootOutputTool::m_tree
TTree * m_tree
Definition: FPGATrackSimHoughRootOutputTool.h:75
getMissingInfo
void getMissingInfo(const FPGATrackSimRoad &road, int &nMissing, bool &missPixel, bool &missStrip, layer_bitmask_t &missing_mask, layer_bitmask_t &norecovery_mask, const ServiceHandle< IFPGATrackSimMappingSvc > &FPGATrackSimMapping, const TrackCorrType idealCoordFitType)
Definition: FPGATrackSimHoughFunctions.cxx:401
FPGATrackSimHoughRootOutputTool::m_truth_pt
std::vector< float > m_truth_pt
Definition: FPGATrackSimHoughRootOutputTool.h:140
FPGATrackSimHoughRootOutputTool::m_custom_layerID
std::vector< int > m_custom_layerID
Definition: FPGATrackSimHoughRootOutputTool.h:80
FPGATrackSimHoughRootOutputTool::m_associated_truth_phi
float m_associated_truth_phi
Definition: FPGATrackSimHoughRootOutputTool.h:122
FPGATrackSimTrack::setHoughX
void setHoughX(float v)
Definition: FPGATrackSimTrack.h:90
FPGATrackSimHoughRootOutputTool::m_track_hit_volumeID
std::vector< std::vector< int > > m_track_hit_volumeID
Definition: FPGATrackSimHoughRootOutputTool.h:165
FPGATrackSimRegionMap::getAvgRadius
double getAvgRadius(unsigned region, unsigned layer) const
Definition: FPGATrackSimRegionMap.cxx:375
FPGATrackSimHoughRootOutputTool::bookTree
StatusCode bookTree()
Definition: FPGATrackSimHoughRootOutputTool.cxx:35
FPGATrackSimMultiTruth::assign_equal_normalization
void assign_equal_normalization()
Definition: FPGATrackSimMultiTruth.cxx:69
FPGATrackSimHoughRootOutputTool::m_zIdeal
std::vector< float > m_zIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:84