ATLAS Offline Software
FPGATrackSimNNTrackTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3  */
14 #include "FPGATrackSimAlgorithms/FPGATrackSimNNTrackTool.h"
15 #include "FPGATrackSimMaps/FPGATrackSimNNMap.h"
16 #include "FPGATrackSimMaps/IFPGATrackSimMappingSvc.h"
17 #include "FPGATrackSimObjects/FPGATrackSimFunctions.h"
18 #include "FPGATrackSimObjects/FPGATrackSimMultiTruth.h"
19 
21 FPGATrackSimNNTrackTool::FPGATrackSimNNTrackTool(const std::string &algname, const std::string &name, const IInterface *ifc) : FPGATrackSimTrackingToolBase(algname, name, ifc), OnnxRuntimeBase() {}
22 
23 
24 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
25 StatusCode FPGATrackSimNNTrackTool::initialize() {
26  ATH_CHECK(m_FPGATrackSimMapping.retrieve());
27  ATH_CHECK(m_tHistSvc.retrieve());
28  if (m_useSpacePoints) ATH_CHECK(m_spRoadFilterTool.retrieve(EnableTool{m_spRoadFilterTool}));
29 
30  if (m_FPGATrackSimMapping->getFakeNNMapString() != "") {
31  m_fakeNN_1st.initialize(m_FPGATrackSimMapping->getFakeNNMapString());
32  }
33  else {
34  ATH_MSG_ERROR("Path to 1st stage NN-based fake track removal ONNX file is empty! If you want to run this pipeline, you need to provide an input file.");
35  return StatusCode::FAILURE;
36  }
37 
38  if (m_FPGATrackSimMapping->getParamNNMapString() != "") {
39  m_paramNN_1st.initialize(m_FPGATrackSimMapping->getParamNNMapString());
40  }
41  else {
42  ATH_MSG_INFO("Path 1st stage to NN-based track parameter estimation ONNX file is empty! Estimation is not run...");
43  m_useParamNN_1st = false;
44  }
45 
46  if (m_FPGATrackSimMapping->getFakeNNMap2ndString() != "") {
47  m_fakeNN_2nd.initialize(m_FPGATrackSimMapping->getFakeNNMap2ndString());
48  }
49  else {
50  ATH_MSG_ERROR("Path to 2nd stage NN-based fake track 1st stage removal ONNX file is empty! If you want to run this pipeline, you need to provide an input file.");
51  return StatusCode::FAILURE;
52  }
53 
54  if (m_FPGATrackSimMapping->getParamNNMap2ndString() != "") {
55  m_paramNN_2nd.initialize(m_FPGATrackSimMapping->getParamNNMap2ndString());
56  }
57  else {
58  ATH_MSG_INFO("Path to 2nd stage NN-based track parameter estimation 2nd ONNX file is empty! Estimation is not run...");
59  m_useParamNN_2nd = false;
60  }
61 
62  return StatusCode::SUCCESS;
63 }
64 
65 
66 StatusCode FPGATrackSimNNTrackTool::setTrackParameters(std::vector<FPGATrackSimTrack> &tracks, bool isFirst, const FPGATrackSimTrackPars& min, const FPGATrackSimTrackPars& max) {
67 
68  ATH_MSG_DEBUG("Running NN-based track parameter estimation!");
69  std::vector<float> paramNNoutputs;
70  if (!m_useParamNN_1st && isFirst) return StatusCode::SUCCESS;
71  if (!m_useParamNN_2nd && !isFirst) return StatusCode::SUCCESS;
72 
73  for (auto &track : tracks) {
74  if (!track.passedOR()) continue;
75  std::vector<float> inputTensorValues;
76  const std::vector <FPGATrackSimHit>& hits = track.getFPGATrackSimHits();
77  bool gotSecondSP = false;
78  float tmp_xf;
79  float tmp_yf;
80  float tmp_zf;
81  float tmp_rf;
82  float tmp_phif;
83 
84  for (const auto& hit : hits) {
85  if (!hit.isReal()) continue;
86 
87  // Need to rotate hits
88  float xf = hit.getX();
89  float yf = hit.getY();
90  float zf = hit.getZ();
91  float rf = std::sqrt(xf*xf+yf*yf);
92  float phif = hit.getGPhi();
93 
94  // Get average of values for strip hit pairs
95  // TODO: this needs to be fixed in the future, for this to work for other cases
96  if (hit.isStrip()) {
97  if (hit.getHitType() != HitType::spacepoint) { // this is a strip but not a SP!
98  if (m_useCartesian) {
99  float xf_scaled = (xf) / (getXScale());
100  float yf_scaled = (yf) / (getYScale());
101  float zf_scaled = (zf) / (getZScale());
102 
103  // Get average of two hits for strip hits
104  inputTensorValues.push_back(xf_scaled);
105  inputTensorValues.push_back(yf_scaled);
106  inputTensorValues.push_back(zf_scaled);
107 
108  }
109  else {
110  float rf_scaled = (rf) / (getRScale());
111  float phif_scaled = (phif) / (getPhiScale());
112  float zf_scaled = (zf) / (getZScale());
113  // Get average of two hits for strip hits
114  inputTensorValues.push_back(rf_scaled);
115  inputTensorValues.push_back(phif_scaled);
116  inputTensorValues.push_back(zf_scaled);
117  }
118  }
119  else if (!gotSecondSP) {
120  tmp_xf = xf;
121  tmp_yf = yf;
122  tmp_zf = zf;
123  tmp_rf = rf;
124  tmp_phif = phif;
125  gotSecondSP = true;
126  }
127  else {
128  gotSecondSP = false;
129 
130  if (m_useCartesian) {
131  float xf_scaled = (xf + tmp_xf) / (2.*getXScale());
132  float yf_scaled = (yf + tmp_yf) / (2.*getYScale());
133  float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
134 
135  // Get average of two hits for strip hits
136  inputTensorValues.push_back(xf_scaled);
137  inputTensorValues.push_back(yf_scaled);
138  inputTensorValues.push_back(zf_scaled);
139 
140  }
141  else {
142  float rf_scaled = (rf+tmp_rf) / (2.*getRScale());
143  float phif_scaled = (phif+tmp_phif) / (2.*getPhiScale());
144  float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
145  // Get average of two hits for strip hits
146  inputTensorValues.push_back(rf_scaled);
147  inputTensorValues.push_back(phif_scaled);
148  inputTensorValues.push_back(zf_scaled);
149  }
150  }
151  }
152  else {
153  if (m_useCartesian) {
154  float xf_scaled = (xf) / (getXScale());
155  float yf_scaled = (yf) / (getYScale());
156  float zf_scaled = (zf) / (getZScale());
157  inputTensorValues.push_back(xf_scaled);
158  inputTensorValues.push_back(yf_scaled);
159  inputTensorValues.push_back(zf_scaled);
160  }
161  else {
162  float rf_scaled = (rf) / (getRScale());
163  float phif_scaled = (phif) / (getPhiScale());
164  float zf_scaled = (zf) / (getZScale());
165  // Get average of two hits for strip hits
166  inputTensorValues.push_back(rf_scaled);
167  inputTensorValues.push_back(phif_scaled);
168  inputTensorValues.push_back(zf_scaled);
169  }
170  }
171  }
172 
173  if (isFirst){
174  if (inputTensorValues.size() < 15) {
175  inputTensorValues.resize(15, 0.0f); // Resize to 15 and fill with 0.0f
176  }
177 
178  if (m_doGNNTracking) {
179  inputTensorValues.resize(39);
180  }
181  }
182  else {
183  if (inputTensorValues.size() < 39) {
184  inputTensorValues.resize(39, 0.0f); // Resize to 39 and fill with 0.0f
185  }
186  else if (inputTensorValues.size() > 39) {
187  inputTensorValues.resize(39); // Resize to 39 and keep the first e9 elements
188  }
189  }
190 
191  if (m_doGNNTracking) {
192  inputTensorValues.resize(m_nInputsGNN * 3);
193  }
194 
195 
196  if (isFirst) paramNNoutputs = m_paramNN_1st.runONNXInference(inputTensorValues);
197  else paramNNoutputs = m_paramNN_2nd.runONNXInference(inputTensorValues);
198 
199  ATH_MSG_DEBUG("Estimated Track Parameters");
200  for (unsigned int i = 0; i < paramNNoutputs.size(); i++) {
201  ATH_MSG_DEBUG(paramNNoutputs[i]);
202  }
203 
204 
205  double qopt = paramNNoutputs[0]*getQoverPtScale();
206  double eta = paramNNoutputs[1]*getEtaScale();
207  double phi = paramNNoutputs[2]*getPhiScale();
208  double d0 = paramNNoutputs[3]*getD0Scale();
209  double z0 = paramNNoutputs[4]*getZ0Scale();
210 
211 
212  if (qopt < min[FPGATrackSimTrackPars::IHIP]) qopt = min[FPGATrackSimTrackPars::IHIP];
213  if (qopt > max[FPGATrackSimTrackPars::IHIP]) qopt = max[FPGATrackSimTrackPars::IHIP];
214  if (eta < min[FPGATrackSimTrackPars::IETA]) eta = min[FPGATrackSimTrackPars::IETA];
215  if (eta > max[FPGATrackSimTrackPars::IETA]) eta = max[FPGATrackSimTrackPars::IETA];
216  if (phi < min[FPGATrackSimTrackPars::IPHI]) phi = min[FPGATrackSimTrackPars::IPHI];
217  if (phi > max[FPGATrackSimTrackPars::IPHI]) phi = max[FPGATrackSimTrackPars::IPHI];
218  if (d0 < min[FPGATrackSimTrackPars::ID0]) d0 = min[FPGATrackSimTrackPars::ID0];
219  if (d0 > max[FPGATrackSimTrackPars::ID0]) d0 = max[FPGATrackSimTrackPars::ID0];
220  if (z0 < min[FPGATrackSimTrackPars::IZ0]) z0 = min[FPGATrackSimTrackPars::IZ0];
221  if (z0 > max[FPGATrackSimTrackPars::IZ0]) z0 = max[FPGATrackSimTrackPars::IZ0];
222 
223  track.setQOverPt(qopt);
224  track.setEta(eta);
225  track.setPhi(phi);
226  track.setD0(d0);
227  track.setZ0(z0);
228  }
229  return StatusCode::SUCCESS;
230 }
231 
232 
233 StatusCode FPGATrackSimNNTrackTool::getTracks_1st(std::vector<std::shared_ptr<const FPGATrackSimRoad>> &roads, std::vector<FPGATrackSimTrack> &tracks) {
234 
235  if(m_doGNNTracking) {
236  ATH_CHECK(getTracks_GNN(roads, tracks));
237  return StatusCode::SUCCESS;
238  }
239 
240  ATH_CHECK(setRoadSectors(roads));
241  int n_track = 0;
242 
243  std::vector<std::vector<float> >inputTensorValuesAll;
244 
245  // Loop over roads
246  for (auto const &iroad : roads) {
247 
248  double y = iroad->getY();
249 
250  // Just used to get number of layers considered
251  const FPGATrackSimPlaneMap *planeMap = m_FPGATrackSimMapping->PlaneMap_1st(iroad->getSubRegion());
252 
253  // Get info on layers with missing hits
254  int nMissing = 0;
255  layer_bitmask_t missing_mask = iroad->getNWCLayers();
256  for (unsigned ilayer = 0; ilayer < planeMap->getNLogiLayers(); ilayer++) {
257  if ((missing_mask >> ilayer) & 0x1) {
258  nMissing++;
259  if (planeMap->isPixel(ilayer)) nMissing++;
260  }
261  }
262 
263 
264  // Create a template track with common parameters filled already for
265  // initializing below
266  FPGATrackSimTrack temp;
267  temp.setTrackStage(TrackStage::FIRST);
268  temp.setNLayers(planeMap->getNLogiLayers());
269  temp.setBankID(-1);
270  temp.setPatternID(iroad->getPID());
271  temp.setFirstSectorID(iroad->getSector());
272  temp.setHitMap(missing_mask);
273  temp.setNMissing(nMissing);
274  temp.setQOverPt(y);
275 
276  temp.setSubRegion(iroad->getSubRegion());
277  temp.setHoughX(iroad->getX());
278  temp.setHoughY(iroad->getY());
279  temp.setHoughXBin(iroad->getXBin());
280  temp.setHoughYBin(iroad->getYBin());
281 
283  // Get a list of indices for all possible combinations given a certain
284  // number of layers
285  std::vector<std::vector<int>> combs;
286 
287  combs = getComboIndices(iroad->getNHits_layer());
288 
289  // Loop over possible combinations for this road
290  for (size_t icomb = 0; icomb < combs.size(); icomb++) {
291  std::vector<float> inputTensorValues;
292  std::vector<std::shared_ptr<const FPGATrackSimHit>> hit_list;
293 
294  // list of indices for this particular combination
295  std::vector<int> const &hit_indices = combs[icomb];
296 
297  // Loop over all layers
298  for (unsigned layer = 0; layer < planeMap->getNLogiLayers(); layer++) {
299 
300  // Check to see if this is a valid hit
301  if (hit_indices[layer] >= 0) {
302 
303  std::shared_ptr<const FPGATrackSimHit> hit = iroad->getHits(layer)[hit_indices[layer]];
304  // Add this hit to the road
305  if (hit->isReal()){
306  hit_list.push_back(hit);
307  }
308  }
309  }
310 
311  // Sort the list by radial distance
312  std::sort(hit_list.begin(), hit_list.end(),
313  [](std::shared_ptr<const FPGATrackSimHit> &hit1, std::shared_ptr<const FPGATrackSimHit> &hit2) {
314  double rho1 = std::hypot(hit1->getX(), hit1->getY());
315  double rho2 = std::hypot(hit2->getX(), hit2->getY());
316  return rho1 < rho2;
317  });
318 
319 
320  int index = 1;
321  bool flipZ = false;
322  double rotateAngle = 0;
323  bool gotSecondSP = false;
324  float tmp_xf;
325  float tmp_yf;
326  float tmp_zf;
327  float tmp_rf;
328  float tmp_phif;
329  // Loop over all hits
330  for (const auto &hit : hit_list) {
331  // Need to rotate hits
332  float x0 = hit->getX();
333  float y0 = hit->getY();
334  float z0 = hit->getZ();
335  float r0 = std::sqrt(x0*x0+y0*y0);
336  float phi0 = hit->getGPhi();
337  float xf = x0;
338  float yf = y0;
339  float zf = z0;
340  float rf = r0;
341  float phif = phi0;
342  if (m_useCartesian) {
343  if (index == 1) {
344  if (z0 < 0)
345  flipZ = true;
346  rotateAngle = std::atan(x0 / y0);
347  if (y0 < 0)
348  rotateAngle += M_PI;
349  }
350  xf = x0 * std::cos(rotateAngle) - y0 * std::sin(rotateAngle);
351  yf = x0 * std::sin(rotateAngle) + y0 * std::cos(rotateAngle);
352  zf = z0;
353  if (flipZ) zf = z0 * -1;
354  }
355 
356  // Get average of values for strip hit pairs
357  // TODO: this needs to be fixed in the future, for this to work for other cases
358  if (hit->isStrip()) {
359 
360  if (hit->getHitType() != HitType::spacepoint) { // this is a strip but not a SP!
361  if (m_useCartesian) {
362  float xf_scaled = (xf) / (getXScale());
363  float yf_scaled = (yf) / (getYScale());
364  float zf_scaled = (zf) / (getZScale());
365 
366  // Get average of two hits for strip hits
367  inputTensorValues.push_back(xf_scaled);
368  inputTensorValues.push_back(yf_scaled);
369  inputTensorValues.push_back(zf_scaled);
370 
371  }
372  else {
373  float rf_scaled = (rf) / (getRScale());
374  float phif_scaled = (phif) / (getPhiScale());
375  float zf_scaled = (zf) / (getZScale());
376  // Get average of two hits for strip hits
377  inputTensorValues.push_back(rf_scaled);
378  inputTensorValues.push_back(phif_scaled);
379  inputTensorValues.push_back(zf_scaled);
380  }
381  }
382  else if (!gotSecondSP) {
383  tmp_xf = xf;
384  tmp_yf = yf;
385  tmp_zf = zf;
386  tmp_phif = phif;
387  tmp_rf = rf;
388  gotSecondSP = true;
389  }
390  else {
391  gotSecondSP = false;
392  if (m_useCartesian) {
393  float xf_scaled = (xf + tmp_xf) / (2.*getXScale());
394  float yf_scaled = (yf + tmp_yf) / (2.*getYScale());
395  float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
396 
397  // Get average of two hits for strip hits
398  inputTensorValues.push_back(xf_scaled);
399  inputTensorValues.push_back(yf_scaled);
400  inputTensorValues.push_back(zf_scaled);
401  index++;
402  }
403  else {
404  float rf_scaled = (rf + tmp_rf) / (2.*getRScale());
405  float phif_scaled = (phif + tmp_phif) / (2.*getPhiScale());
406  float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
407  inputTensorValues.push_back(rf_scaled);
408  inputTensorValues.push_back(phif_scaled);
409  inputTensorValues.push_back(zf_scaled);
410  }
411  }
412  }
413  else {
414  if (m_useCartesian) {
415  float xf_scaled = (xf) / (getXScale());
416  float yf_scaled = (yf) / (getYScale());
417  float zf_scaled = (zf) / (getZScale());
418  inputTensorValues.push_back(xf_scaled);
419  inputTensorValues.push_back(yf_scaled);
420  inputTensorValues.push_back(zf_scaled);
421  index++;
422  }
423  else {
424  float rf_scaled = (rf) / (getRScale());
425  float phif_scaled = (phif) / (getPhiScale());
426  float zf_scaled = (zf) / (getZScale());
427  inputTensorValues.push_back(rf_scaled);
428  inputTensorValues.push_back(phif_scaled);
429  inputTensorValues.push_back(zf_scaled);
430  }
431  }
432  }
433 
434  if (inputTensorValues.size() != planeMap->getNLogiLayers()*3) {
435  inputTensorValues.resize(planeMap->getNLogiLayers()*3);
436  }
437  inputTensorValues.resize(15); // Retain only the first 15 values for consistency
438 
439  inputTensorValuesAll.push_back(inputTensorValues);
440  FPGATrackSimTrack track_cand;
441  n_track++;
442  track_cand.setTrackID(n_track);
443  track_cand.setNLayers(planeMap->getNLogiLayers());
444  track_cand.setNMissing(nMissing);
445  for (unsigned ihit = 0; ihit < hit_list.size(); ihit++) {
446  track_cand.setFPGATrackSimHit(ihit, *(hit_list[ihit]));
447  }
448  tracks.push_back(track_cand);
449 
450  ATH_MSG_DEBUG("NN InputTensorValues:");
451  ATH_MSG_DEBUG(inputTensorValues);
452  } // loop over combinations
453  } // loop over roads
454 
456  auto NNoutputs = m_fakeNN_1st.runONNXInference(inputTensorValuesAll);
457 
458  for (unsigned itrack = 0; itrack < NNoutputs.size(); itrack++) {
459 
460  float nn_val = NNoutputs[itrack][0];
461  ATH_MSG_DEBUG("NN output:" << nn_val);
462  double chi2 = (1 - nn_val) * (tracks[itrack].getNCoords() - tracks[itrack].getNMissing() - 5);
463  //std::cout << "1st stage" << chi2 << std::endl;
464  tracks[itrack].setOrigChi2(chi2);
465  tracks[itrack].setChi2(chi2);
466  }
467 
468  // Add truth info
469  for (FPGATrackSimTrack &t : tracks) {
470  compute_truth(t); // match the track to a geant particle using the
471  // channel-level geant info in the hit data.
472  }
473  return StatusCode::SUCCESS;
474 }
475 
476 
477 StatusCode FPGATrackSimNNTrackTool::getTracks_2nd(std::vector<std::shared_ptr<const FPGATrackSimRoad>> &roads, std::vector<FPGATrackSimTrack> &tracks) {
478 
479  ATH_CHECK(setRoadSectors(roads));
480  int n_track = 0;
481  std::vector<std::vector<float> >inputTensorValuesAll;
482 
483  // Loop over roads
484  for (auto const &iroad : roads) {
485 
486  double y = iroad->getY();
487 
488  const FPGATrackSimPlaneMap *planeMap = m_FPGATrackSimMapping->PlaneMap_2nd(iroad->getSubRegion());
489  // Get info on layers with missing hits
490  int nMissing = 0;
491  layer_bitmask_t missing_mask = iroad->getNWCLayers();
492  layer_bitmask_t hit_mask = 0x0;
493  for (unsigned ilayer = 0; ilayer < 13; ilayer++) {
494  if ((missing_mask >> ilayer) & 0x1) {
495  nMissing++;
496  if (planeMap->isPixel(ilayer)) nMissing++;
497  }
498  else {
499  hit_mask |= (0x1 << ilayer);
500  }
501  }
502 
503  // Create a template track with common parameters filled already for
504  // initializing below
505  FPGATrackSimTrack temp;
506  temp.setTrackStage(TrackStage::SECOND);
507  temp.setNLayers(13);
508  temp.setBankID(-1);
509  temp.setPatternID(iroad->getPID());
510  temp.setFirstSectorID(iroad->getSector());
511  temp.setHitMap(hit_mask);
512  temp.setNMissing(nMissing);
513  temp.setQOverPt(y);
514 
515  temp.setSubRegion(iroad->getSubRegion());
516  temp.setHoughX(iroad->getX());
517  temp.setHoughY(iroad->getY());
518  temp.setHoughXBin(iroad->getXBin());
519  temp.setHoughYBin(iroad->getYBin());
521  // Get a list of indices for all possible combinations given a certain
522  // number of layers
523  std::vector<std::vector<int>> combs =
524  getComboIndices(iroad->getNHits_layer());
525 
526  // Loop over possible combinations for this road
527  for (size_t icomb = 0; icomb < combs.size(); icomb++) {
528  std::vector<float> inputTensorValues;
529 
530  // list of indices for this particular combination
531  std::vector<int> const &hit_indices = combs[icomb];
532  std::vector<std::shared_ptr<const FPGATrackSimHit>> hit_list;
533 
534  // Loop over all layers
535  for (unsigned layer = 0; layer < 13; layer++) {
536 
537  // Check to see if this is a valid hit
538  if (hit_indices[layer] >= 0) {
539 
540  std::shared_ptr<const FPGATrackSimHit> hit = iroad->getHits(layer)[hit_indices[layer]];
541  // Add this hit to the road
542  if (hit->isReal()){
543  hit_list.push_back(hit);
544  }
545  }
546  }
547 
548  // Sort the list by radial distance
549  std::sort(hit_list.begin(), hit_list.end(),
550  [](std::shared_ptr<const FPGATrackSimHit> &hit1, std::shared_ptr<const FPGATrackSimHit> &hit2) {
551  double rho1 = std::hypot(hit1->getX(), hit1->getY());
552  double rho2 = std::hypot(hit2->getX(), hit2->getY());
553  return rho1 < rho2;
554  });
555 
556 
557  int index = 1;
558  bool flipZ = false;
559  double rotateAngle = 0;
560  bool gotSecondSP = false;
561  float tmp_xf;
562  float tmp_yf;
563  float tmp_zf;
564  float tmp_rf;
565  float tmp_phif;
566  // Loop over all hits
567  for (const auto &hit : hit_list) {
568 
569  // Need to rotate hits
570  float x0 = hit->getX();
571  float y0 = hit->getY();
572  float z0 = hit->getZ();
573  float r0 = std::sqrt(x0*x0+y0*y0);
574  float phi0 = hit->getGPhi();
575  float xf = x0;
576  float yf = y0;
577  float zf = z0;
578  float rf = r0;
579  float phif = phi0;
580 
581  if (m_useCartesian) {
582  if (index == 1) {
583  if (z0 < 0)
584  flipZ = true;
585  rotateAngle = std::atan(x0 / y0);
586  if (y0 < 0)
587  rotateAngle += M_PI;
588  }
589  xf = x0 * std::cos(rotateAngle) - y0 * std::sin(rotateAngle);
590  yf = x0 * std::sin(rotateAngle) + y0 * std::cos(rotateAngle);
591  zf = z0;
592 
593  if (flipZ) zf = z0 * -1;
594  }
595 
596  // Get average of values for strip hit pairs
597  // TODO: this needs to be fixed in the future, for this to work for other cases
598  if (hit->isStrip()) {
599 
600  if (hit->getHitType() != HitType::spacepoint) { // this is a strip but not a SP!
601  if (m_useCartesian) {
602  float xf_scaled = (xf) / (getXScale());
603  float yf_scaled = (yf) / (getYScale());
604  float zf_scaled = (zf) / (getZScale());
605 
606  // Get average of two hits for strip hits
607  inputTensorValues.push_back(xf_scaled);
608  inputTensorValues.push_back(yf_scaled);
609  inputTensorValues.push_back(zf_scaled);
610  }
611  else {
612  float rf_scaled = (rf) / (getRScale());
613  float phif_scaled = (phif) / (getPhiScale());
614  float zf_scaled = (zf) / (getZScale());
615  // Get average of two hits for strip hits
616  inputTensorValues.push_back(rf_scaled);
617  inputTensorValues.push_back(phif_scaled);
618  inputTensorValues.push_back(zf_scaled);
619  }
620  }
621  else if (!gotSecondSP) {
622  tmp_xf = xf;
623  tmp_yf = yf;
624  tmp_zf = zf;
625  tmp_rf = rf;
626  tmp_phif = phif;
627  gotSecondSP = true;
628  }
629  else {
630  gotSecondSP = false;
631  if (m_useCartesian) {
632  float xf_scaled = (xf + tmp_xf) / (2.*getXScale());
633  float yf_scaled = (yf + tmp_yf) / (2.*getYScale());
634  float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
635 
636  // Get average of two hits for strip hits
637  inputTensorValues.push_back(xf_scaled);
638  inputTensorValues.push_back(yf_scaled);
639  inputTensorValues.push_back(zf_scaled);
640  index++;
641  }
642  else {
643  float rf_scaled = (rf + tmp_rf) / (2.*getRScale());
644  float phif_scaled = (phif + tmp_phif) / (2.*getPhiScale());
645  float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
646  inputTensorValues.push_back(rf_scaled);
647  inputTensorValues.push_back(phif_scaled);
648  inputTensorValues.push_back(zf_scaled);
649  }
650  }
651  }
652  else {
653  if (m_useCartesian) {
654  float xf_scaled = (xf) / (getXScale());
655  float yf_scaled = (yf) / (getYScale());
656  float zf_scaled = (zf) / (getZScale());
657  inputTensorValues.push_back(xf_scaled);
658  inputTensorValues.push_back(yf_scaled);
659  inputTensorValues.push_back(zf_scaled);
660  index++;
661  }
662  else {
663  float rf_scaled = (rf) / (getRScale());
664  float phif_scaled = (phif) / (getPhiScale());
665  float zf_scaled = (zf) / (getZScale());
666  inputTensorValues.push_back(rf_scaled);
667  inputTensorValues.push_back(phif_scaled);
668  inputTensorValues.push_back(zf_scaled);
669  }
670  }
671  }
672 
673 
674  if (inputTensorValues.size() < 39) {
675  inputTensorValues.resize(39, 0.0f); // Resize to 39 and fill with 0.0f
676  }
677  else if (inputTensorValues.size() > 39) {
678  inputTensorValues.resize(39); // Resize to 39 and keep the first 39 elements
679  }
680  inputTensorValuesAll.push_back(inputTensorValues);
681 
682  ATH_MSG_DEBUG("NN InputTensorValues:");
683  ATH_MSG_DEBUG(inputTensorValues);
684 
685  n_track++;
686  FPGATrackSimTrack track_cand;
687  track_cand.setTrackID(n_track);
688  track_cand.setNLayers(13);
689  track_cand.setNMissing(nMissing);
690  for (unsigned ihit = 0; ihit < hit_list.size(); ihit++) {
691  track_cand.setFPGATrackSimHit(ihit, *(hit_list[ihit]));
692  }
693  tracks.push_back(track_cand);
694 
695  } // loop over combinations
696  } // loop over roads
697 
699  auto NNoutputs = m_fakeNN_2nd.runONNXInference(inputTensorValuesAll);
700  for (unsigned itrack = 0; itrack < NNoutputs.size(); itrack++) {
701 
702  float nn_val = NNoutputs[itrack][0];
703  ATH_MSG_DEBUG("NN output:" << nn_val);
704 
705  double chi2 = (1 - nn_val) * (tracks[itrack].getNCoords() - tracks[itrack].getNMissing() - 5);
706 
707  tracks[itrack].setOrigChi2(chi2);
708  tracks[itrack].setChi2(chi2);
709  }
710 
711  // Add truth info
712  for (FPGATrackSimTrack &t : tracks) {
713  compute_truth(t); // match the track to a geant particle using the
714  // channel-level geant info in the hit data.
715  }
716 
717  return StatusCode::SUCCESS;
718 }
719 
720 StatusCode FPGATrackSimNNTrackTool::getTracks_GNN(std::vector<std::shared_ptr<const FPGATrackSimRoad>> &roads, std::vector<FPGATrackSimTrack> &tracks) {
721 
722  ATH_CHECK(setRoadSectors(roads));
723  int n_track = 0;
724 
725  std::vector<std::vector<float> >inputTensorValuesAll;
726 
727  // Loop over roads
728  for (auto const &iroad : roads) {
729  // Just used to get number of layers considered
730  const FPGATrackSimPlaneMap *planeMap = m_FPGATrackSimMapping->PlaneMap_1st(iroad->getSubRegion());
731 
732  double y = iroad->getY();
733 
734  // Get info on layers with missing hits
735  int nMissing = 0;
736  layer_bitmask_t missing_mask = 0;
737  layer_bitmask_t hit_mask = 0x0;
738  for (unsigned ilayer = 0; ilayer < 13; ilayer++) {
739  if ((missing_mask >> ilayer) & 0x1) {
740  nMissing++;
741  if (planeMap->isPixel(ilayer)) nMissing++;
742  }
743  else {
744  hit_mask |= (0x1 << ilayer);
745  }
746  }
747 
748 
749  // Create a template track with common parameters filled already for
750  // initializing below
751  FPGATrackSimTrack temp;
752  temp.setTrackStage(TrackStage::FIRST);
753  temp.setNLayers(planeMap->getNLogiLayers());
754  temp.setBankID(-1);
755  temp.setPatternID(iroad->getPID());
756  temp.setFirstSectorID(iroad->getSector());
757  temp.setHitMap(hit_mask);
758  temp.setNMissing(nMissing);
759  temp.setQOverPt(y);
760 
761  temp.setSubRegion(iroad->getSubRegion());
762  temp.setHoughX(iroad->getX());
763  temp.setHoughY(iroad->getY());
764  temp.setHoughXBin(iroad->getXBin());
765  temp.setHoughYBin(iroad->getYBin());
766 
768  // Get a list of indices for all possible combinations given a certain
769  // number of layers
770  std::vector<std::vector<int>> combs;
771  std::vector<std::shared_ptr<const FPGATrackSimHit>> all_hits;
772 
773  std::vector<std::shared_ptr<const FPGATrackSimHit>> all_pixel_hits;
774  std::vector<std::shared_ptr<const FPGATrackSimHit>> all_strip_hits;
775  size_t pixelCount = 0;
776 
777  for (unsigned layer = 0; layer < iroad->getNLayers(); ++layer) {
778  all_hits.insert(all_hits.end(), iroad->getHits(layer).begin(), iroad->getHits(layer).end());
779  }
780 
781  for (const auto& hit : all_hits) {
782  if(hit->isPixel()) {
783  pixelCount++;
784  }
785  }
786 
787  if (pixelCount < 1) continue; // Cannot use a form a track candidate from a road that does not have a pixel hit
788 
789  std::vector<float> inputTensorValues;
790  std::vector<std::shared_ptr<const FPGATrackSimHit>> hit_list;
791 
792  for (const auto &hit : all_hits) {
793  if (hit->isReal()) {
794  hit_list.push_back(hit);
795  }
796  }
797 
798  if (hit_list.size() < m_minNumberOfRealHitsInATrack) continue;
799 
800  // Sort the list by radial distance
801  std::sort(hit_list.begin(), hit_list.end(),
802  [](std::shared_ptr<const FPGATrackSimHit> &hit1, std::shared_ptr<const FPGATrackSimHit> &hit2) {
803  double rho1 = std::hypot(hit1->getX(), hit1->getY());
804  double rho2 = std::hypot(hit2->getX(), hit2->getY());
805  return rho1 < rho2;
806  });
807 
808 
809  int index = 1;
810  bool flipZ = false;
811  double rotateAngle = 0;
812  bool gotSecondSP = false;
813  float tmp_xf;
814  float tmp_yf;
815  float tmp_zf;
816  float tmp_phif;
817  float tmp_rf;
818 
819  // Loop over all hits
820  for (const auto &hit : hit_list) {
821  // Need to rotate hits
822  float x0 = hit->getX();
823  float y0 = hit->getY();
824  float z0 = hit->getZ();
825  float r0 = std::sqrt(x0*x0+y0*y0);
826  float phi0 = hit->getGPhi();
827  float xf = x0;
828  float yf = y0;
829  float zf = z0;
830  float rf = r0;
831  float phif = phi0;
832 
833  if (m_useCartesian) {
834  if (index == 1) {
835  if (z0 < 0)
836  flipZ = true;
837  rotateAngle = std::atan(x0 / y0);
838  if (y0 < 0)
839  rotateAngle += M_PI;
840  }
841  xf = x0 * std::cos(rotateAngle) - y0 * std::sin(rotateAngle);
842  yf = x0 * std::sin(rotateAngle) + y0 * std::cos(rotateAngle);
843  zf = z0;
844 
845  if (flipZ) zf = z0 * -1;
846  }
847 
848  // Get average of values for strip hit pairs
849  // TODO: this needs to be fixed in the future, for this to work for other cases
850  if (hit->isStrip()) {
851 
852  if (hit->getHitType() != HitType::spacepoint) { // this is a strip but not a SP!
853  if (m_useCartesian) {
854  float xf_scaled = (xf) / (getXScale());
855  float yf_scaled = (yf) / (getYScale());
856  float zf_scaled = (zf) / (getZScale());
857 
858  // Get average of two hits for strip hits
859  inputTensorValues.push_back(xf_scaled);
860  inputTensorValues.push_back(yf_scaled);
861  inputTensorValues.push_back(zf_scaled);
862 
863  }
864  else {
865  float rf_scaled = (rf) / (getRScale());
866  float phif_scaled = (phif) / (getPhiScale());
867  float zf_scaled = (zf) / (getZScale());
868  // Get average of two hits for strip hits
869  inputTensorValues.push_back(rf_scaled);
870  inputTensorValues.push_back(phif_scaled);
871  inputTensorValues.push_back(zf_scaled);
872  }
873  }
874  else if (!gotSecondSP) {
875  tmp_xf = xf;
876  tmp_yf = yf;
877  tmp_zf = zf;
878  tmp_phif = phif;
879  tmp_rf = rf;
880  gotSecondSP = true;
881  }
882  else {
883  gotSecondSP = false;
884  if (m_useCartesian) {
885  float xf_scaled = (xf + tmp_xf) / (2.*getXScale());
886  float yf_scaled = (yf + tmp_yf) / (2.*getYScale());
887  float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
888 
889  // Get average of two hits for strip hits
890  inputTensorValues.push_back(xf_scaled);
891  inputTensorValues.push_back(yf_scaled);
892  inputTensorValues.push_back(zf_scaled);
893  index++;
894  }
895  else {
896  float rf_scaled = (rf + tmp_rf) / (2.*getRScale());
897  float phif_scaled = (phif + tmp_phif) / (2.*getPhiScale());
898  float zf_scaled = (zf + tmp_zf) / (2.*getZScale());
899  inputTensorValues.push_back(rf_scaled);
900  inputTensorValues.push_back(phif_scaled);
901  inputTensorValues.push_back(zf_scaled);
902  }
903  }
904  }
905  else {
906  if (m_useCartesian) {
907  float xf_scaled = (xf) / (getXScale());
908  float yf_scaled = (yf) / (getYScale());
909  float zf_scaled = (zf) / (getZScale());
910  inputTensorValues.push_back(xf_scaled);
911  inputTensorValues.push_back(yf_scaled);
912  inputTensorValues.push_back(zf_scaled);
913  index++;
914  }
915  else {
916  float rf_scaled = (rf) / (getRScale());
917  float phif_scaled = (phif) / (getPhiScale());
918  float zf_scaled = (zf) / (getZScale());
919  inputTensorValues.push_back(rf_scaled);
920  inputTensorValues.push_back(phif_scaled);
921  inputTensorValues.push_back(zf_scaled);
922  }
923  }
924  }
925 
926  // NN Estimator can either be 5 or 9 spacepoints as inputs
927  // Let this be decided by m_nInputsGNN
928 
929  // NN Estimator needs 9 spacepoints -> 27 inputs
930  // If there are more than 9 spacepoints entered, then it accepts the first 9
931  // If there are less than 9 spacepoints, then it enters no values for it (although I actually probably need to just reject these)
932  inputTensorValues.resize(27);
933 
934  inputTensorValuesAll.push_back(inputTensorValues);
935  FPGATrackSimTrack track_cand;
936  track_cand.setTrackID(n_track);
937  track_cand.setNLayers(hit_list.size());
938  for (unsigned ihit = 0; ihit < hit_list.size(); ihit++) {
939  track_cand.setFPGATrackSimHit(ihit, *(hit_list[ihit]));
940  }
941  tracks.push_back(track_cand);
942 
943 
944  ATH_MSG_DEBUG("NN InputTensorValues:");
945  ATH_MSG_DEBUG(inputTensorValues);
946  } // loop over roads
947 
949  auto NNoutputs = m_fakeNN_1st.runONNXInference(inputTensorValuesAll);
950 
951  for (unsigned itrack = 0; itrack < NNoutputs.size(); itrack++) {
952 
953  float nn_val = NNoutputs[itrack][0];
954  ATH_MSG_DEBUG("NN output:" << nn_val);
955  double chi2 = (1 - nn_val) * (tracks[itrack].getNCoords() - tracks[itrack].getNMissing() - 5);
956  tracks[itrack].setOrigChi2(chi2);
957  tracks[itrack].setChi2(chi2);
958  }
959 
960  // Add truth info
961  for (FPGATrackSimTrack &t : tracks) {
962  compute_truth(t); // match the track to a geant particle using the
963  // channel-level geant info in the hit data.
964  }
965 
966  return StatusCode::SUCCESS;
967 }
968 
969 
970 
971 
972 // Borrowed same code from TrackFitter - probably a nicer way to inherit instead
973 void FPGATrackSimNNTrackTool::compute_truth(FPGATrackSimTrack &t) const {
974  std::vector<FPGATrackSimMultiTruth> mtv;
975 
976  unsigned nl = (m_do2ndStage ? 13 : 5);
977  for (unsigned layer = 0; layer < nl; layer++) {
978  if (!(t.getHitMap() & (1 << layer))) continue;
979 
980  // Sanity check that we have enough hits.
981  if (layer < t.getFPGATrackSimHits().size())
982  mtv.push_back(t.getFPGATrackSimHits().at(layer).getTruth());
983 
984  // adjust weight for hits without (and also with) a truth match, so that
985  // each is counted with the same weight.
986  mtv.back().assign_equal_normalization();
987  }
988 
989  FPGATrackSimMultiTruth mt(std::accumulate(mtv.begin(), mtv.end(), FPGATrackSimMultiTruth(),
990  FPGATrackSimMultiTruth::AddAccumulator()));
991  // frac is then the fraction of the total number of hits on the track
992  // attributed to the barcode.
993 
994  FPGATrackSimMultiTruth::Barcode tbarcode;
995  FPGATrackSimMultiTruth::Weight tfrac;
996  const bool ok = mt.best(tbarcode, tfrac);
997  if (ok) {
998  t.setEventIndex(tbarcode.first);
999  t.setBarcode(tbarcode.second);
1000  t.setBarcodeFrac(tfrac);
1001  }
1002 }
FPGATrackSimTrack::setHitMap
void setHitMap(unsigned int v)
Definition: FPGATrackSimTrack.h:101
FPGATrackSimNNTrackTool::m_minNumberOfRealHitsInATrack
Gaudi::Property< unsigned int > m_minNumberOfRealHitsInATrack
Definition: FPGATrackSimNNTrackTool.h:65
OnnxRuntimeBase::runONNXInference
std::vector< float > runONNXInference(std::vector< float > &inputTensorValues) const
Definition: OnnxRuntimeBase.cxx:84
FPGATrackSimTrackPars::IHIP
@ IHIP
Definition: FPGATrackSimTrackPars.h:49
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:215
FPGATrackSimTrackPars::ID0
@ ID0
Definition: FPGATrackSimTrackPars.h:49
getMenu.algname
algname
Definition: getMenu.py:54
FPGATrackSimNNTrackTool::getRScale
static float getRScale()
Definition: FPGATrackSimNNTrackTool.h:62
FPGATrackSimPlaneMap::getNLogiLayers
uint32_t getNLogiLayers() const
Definition: FPGATrackSimPlaneMap.h:75
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSimTrack::setBankID
void setBankID(int v)
Definition: FPGATrackSimTrack.h:84
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FPGATrackSimNNTrackTool::m_useCartesian
Gaudi::Property< bool > m_useCartesian
Definition: FPGATrackSimNNTrackTool.h:68
FPGATrackSimNNMap.h
Map for NN tracking.
FPGATrackSimTrack
Definition: FPGATrackSimTrack.h:18
FPGATrackSimTrackPars
Definition: FPGATrackSimTrackPars.h:22
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
OnnxRuntimeBase::initialize
void initialize(TString)
Definition: OnnxRuntimeBase.cxx:16
FPGATrackSimTrack::setPatternID
void setPatternID(int v)
Definition: FPGATrackSimTrack.h:85
index
Definition: index.py:1
FPGATrackSimMultiTruth::Weight
float Weight
Definition: FPGATrackSimMultiTruth.h:50
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
FPGATrackSimNNTrackTool.h
Utilize NN score to build track candidates.
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
FPGATrackSimTrackPars::IZ0
@ IZ0
Definition: FPGATrackSimTrackPars.h:49
IFPGATrackSimMappingSvc.h
InDetAccessor::phi0
@ phi0
Definition: InDetAccessor.h:33
python.HLT.MinBias.MinBiasMenuSequences.zf
zf
Definition: MinBiasMenuSequences.py:224
FPGATrackSimTrack::setNMissing
void setNMissing(int v)
Definition: FPGATrackSimTrack.h:99
FPGATrackSimHit::isReal
bool isReal() const
Definition: FPGATrackSimHit.cxx:40
FPGATrackSimNNTrackTool::m_doGNNTracking
Gaudi::Property< bool > m_doGNNTracking
Definition: FPGATrackSimNNTrackTool.h:66
M_PI
#define M_PI
Definition: ActiveFraction.h:11
FPGATrackSimTrack::setHoughXBin
void setHoughXBin(unsigned v)
Definition: FPGATrackSimTrack.h:109
FPGATrackSimTrack::setFirstSectorID
void setFirstSectorID(int v)
Definition: FPGATrackSimTrack.h:86
HitType::spacepoint
@ spacepoint
FPGATrackSimNNTrackTool::getXScale
static float getXScale()
Definition: FPGATrackSimNNTrackTool.h:54
FPGATrackSimMultiTruth.h
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
FPGATrackSimTrack::setFPGATrackSimHit
void setFPGATrackSimHit(unsigned i, const FPGATrackSimHit &hit)
Definition: FPGATrackSimTrack.cxx:98
FPGATrackSimMultiTruth::best
bool best(FPGATrackSimMultiTruth::Barcode &code, FPGATrackSimMultiTruth::Weight &weight) const
Definition: FPGATrackSimMultiTruth.h:86
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
FPGATrackSimNNTrackTool::m_tHistSvc
ServiceHandle< ITHistSvc > m_tHistSvc
Definition: FPGATrackSimNNTrackTool.h:73
FPGATrackSimTrackingToolBase
Definition: FPGATrackSimTrackingToolBase.h:21
FPGATrackSimNNTrackTool::m_paramNN_1st
OnnxRuntimeBase m_paramNN_1st
Definition: FPGATrackSimNNTrackTool.h:75
FPGATrackSimPlaneMap::isPixel
bool isPixel(int pl) const
Definition: FPGATrackSimPlaneMap.h:107
FPGATrackSimTrack::setHoughYBin
void setHoughYBin(unsigned v)
Definition: FPGATrackSimTrack.h:110
FPGATrackSimNNTrackTool::getEtaScale
static float getEtaScale()
Definition: FPGATrackSimNNTrackTool.h:58
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
FPGATrackSimTrackingToolBase::setRoadSectors
StatusCode setRoadSectors(std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads)
Definition: FPGATrackSimTrackingToolBase.cxx:11
lumiFormat.i
int i
Definition: lumiFormat.py:85
FPGATrackSimNNTrackTool::getTracks_1st
StatusCode getTracks_1st(std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, std::vector< FPGATrackSimTrack > &tracks)
Definition: FPGATrackSimNNTrackTool.cxx:233
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
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
FPGATrackSimNNTrackTool::setTrackParameters
StatusCode setTrackParameters(std::vector< FPGATrackSimTrack > &tracks, bool isFirst, const FPGATrackSimTrackPars &min, const FPGATrackSimTrackPars &max)
Definition: FPGATrackSimNNTrackTool.cxx:66
TrackStage::FIRST
@ FIRST
FPGATrackSimMultiTruth::Barcode
std::pair< unsigned long, unsigned long > Barcode
Definition: FPGATrackSimMultiTruth.h:49
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:525
TRT::Track::d0
@ d0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:62
TRT_PAI_physicsConstants::r0
const double r0
electron radius{cm}
Definition: TRT_PAI_physicsConstants.h:22
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimNNTrackTool::m_nInputsGNN
Gaudi::Property< int > m_nInputsGNN
Definition: FPGATrackSimNNTrackTool.h:67
TrackStage::SECOND
@ SECOND
hist_file_dump.f
f
Definition: hist_file_dump.py:140
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
FPGATrackSimNNTrackTool::getD0Scale
static float getD0Scale()
Definition: FPGATrackSimNNTrackTool.h:60
FPGATrackSimNNTrackTool::getTracks_2nd
StatusCode getTracks_2nd(std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, std::vector< FPGATrackSimTrack > &tracks)
Definition: FPGATrackSimNNTrackTool.cxx:477
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
FPGATrackSimNNTrackTool::m_FPGATrackSimMapping
ServiceHandle< IFPGATrackSimMappingSvc > m_FPGATrackSimMapping
Definition: FPGATrackSimNNTrackTool.h:72
FPGATrackSimTrackingToolBase::m_useSpacePoints
Gaudi::Property< bool > m_useSpacePoints
Definition: FPGATrackSimTrackingToolBase.h:36
FPGATrackSimPlaneMap
Definition: FPGATrackSimPlaneMap.h:62
FPGATrackSimNNTrackTool::getZScale
static float getZScale()
Definition: FPGATrackSimNNTrackTool.h:56
FPGATrackSimTrack::setTrackStage
void setTrackStage(TrackStage v)
Definition: FPGATrackSimTrack.h:82
FPGATrackSimNNTrackTool::m_fakeNN_2nd
OnnxRuntimeBase m_fakeNN_2nd
Definition: FPGATrackSimNNTrackTool.h:78
FPGATrackSimNNTrackTool::getYScale
static float getYScale()
Definition: FPGATrackSimNNTrackTool.h:55
FPGATrackSimNNTrackTool::FPGATrackSimNNTrackTool
FPGATrackSimNNTrackTool(const std::string &, const std::string &, const IInterface *)
Definition: FPGATrackSimNNTrackTool.cxx:21
FPGATrackSimMultiTruth
Definition: FPGATrackSimMultiTruth.h:46
FPGATrackSimMultiTruth::AddAccumulator
Definition: FPGATrackSimMultiTruth.h:57
OnnxRuntimeBase
Definition: OnnxRuntimeBase.h:13
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
FPGATrackSimFunctions.h
FPGATrackSimNNTrackTool::m_fakeNN_1st
OnnxRuntimeBase m_fakeNN_1st
Definition: FPGATrackSimNNTrackTool.h:77
FPGATrackSimTrack::setHoughY
void setHoughY(float v)
Definition: FPGATrackSimTrack.h:91
FPGATrackSimTrack::setTrackID
void setTrackID(int v)
Definition: FPGATrackSimTrack.h:88
FPGATrackSimTrack::setQOverPt
void setQOverPt(float v)
Definition: FPGATrackSimTrack.h:92
FPGATrackSimNNTrackTool::compute_truth
void compute_truth(FPGATrackSimTrack &newtrk) const
Definition: FPGATrackSimNNTrackTool.cxx:973
FPGATrackSimTrackPars::IPHI
@ IPHI
Definition: FPGATrackSimTrackPars.h:49
FPGATrackSimNNTrackTool::initialize
virtual StatusCode initialize() override
Definition: FPGATrackSimNNTrackTool.cxx:25
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:107
y
#define y
FPGATrackSimNNTrackTool::getZ0Scale
static float getZ0Scale()
Definition: FPGATrackSimNNTrackTool.h:61
FPGATrackSimNNTrackTool::m_paramNN_2nd
OnnxRuntimeBase m_paramNN_2nd
Definition: FPGATrackSimNNTrackTool.h:76
layer_bitmask_t
uint32_t layer_bitmask_t
Definition: FPGATrackSimTypes.h:22
FPGATrackSimTrack::setSubRegion
void setSubRegion(unsigned v)
Definition: FPGATrackSimTrack.h:107
FPGATrackSimNNTrackTool::getPhiScale
static float getPhiScale()
Definition: FPGATrackSimNNTrackTool.h:59
FPGATrackSimNNTrackTool::m_useParamNN_2nd
bool m_useParamNN_2nd
Definition: FPGATrackSimNNTrackTool.h:81
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
FPGATrackSimNNTrackTool::getQoverPtScale
static float getQoverPtScale()
Definition: FPGATrackSimNNTrackTool.h:57
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
FPGATrackSimTrack::setNLayers
void setNLayers(int)
set the number of layers in the track.
Definition: FPGATrackSimTrack.cxx:107
FPGATrackSimNNTrackTool::m_useParamNN_1st
bool m_useParamNN_1st
Definition: FPGATrackSimNNTrackTool.h:80
FPGATrackSimTrackingToolBase::m_do2ndStage
Gaudi::Property< bool > m_do2ndStage
Definition: FPGATrackSimTrackingToolBase.h:40
FPGATrackSimTrackingToolBase::m_spRoadFilterTool
ToolHandle< IFPGATrackSimRoadFilterTool > m_spRoadFilterTool
Definition: FPGATrackSimTrackingToolBase.h:32
FPGATrackSimNNTrackTool::getTracks_GNN
StatusCode getTracks_GNN(std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, std::vector< FPGATrackSimTrack > &tracks)
Definition: FPGATrackSimNNTrackTool.cxx:720
FPGATrackSimTrack::setHoughX
void setHoughX(float v)
Definition: FPGATrackSimTrack.h:90
FPGATrackSimTrackPars::IETA
@ IETA
Definition: FPGATrackSimTrackPars.h:49
Generated on Wed Sep 3 2025 21:10:26 for ATLAS Offline Software by   doxygen 1.8.18