ATLAS Offline Software
TrigInDetR3TrackSeedingTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
7 
13 
15 
17 
19 
20 #include "GNNR3_TrackingFilter.h"
21 
22 //for GPU offloading
23 
24 // #include "TrigAccelEvent/TrigITkAccelEDM.h"
25 // #include "TrigAccelEvent/TrigInDetR3AccelCodes.h"
26 
28  const std::string& n,
29  const IInterface* p ) : SeedingToolBase(t,n,p)
30 {
31 
32 }
33 
35 
37 
38  ATH_CHECK(m_regsel_pix.retrieve());
39  ATH_CHECK(m_regsel_sct.retrieve());
40 
42 
43 #if 0
44  if(m_useGPU) {//for GPU offloading
45  ATH_CHECK(m_accelSvc.retrieve());
46  ATH_CHECK(m_accelSvc->isReady());
47  }
48 #endif
49 
51  ATH_MSG_FATAL("Both usePixelSpacePoints and useSctSpacePoints set to False. At least one needs to be True");
52  return StatusCode::FAILURE;
53  }
54 
55  if (!m_useSctSpacePoints) ATH_MSG_INFO("Only using Pixel spacepoints => Pixel seeds only");
56 
57  if (!m_usePixelSpacePoints) ATH_MSG_INFO("Only using SCT spacepoints => Strip seeds only");
58 
59  if (m_usePixelSpacePoints && m_useSctSpacePoints) ATH_MSG_INFO("Using SCT and Pixel spacepoints");
60 
62 
64 
65  ATH_MSG_INFO("TrigInDetR3TrackSeedingTool initialized with " << m_useGPU);
66 
67  return StatusCode::SUCCESS;
68 }
69 
72 }
73 
74 
75 TrigInDetTrackSeedingResult TrigInDetR3TrackSeedingTool::findSeeds(const IRoiDescriptor& internalRoI, std::vector<TrigInDetTracklet>& output, const EventContext& ctx) const {
76 
78 
79  output.clear();
80 
82  const Amg::Vector3D &vertex = beamSpotHandle->beamPos();
83  float shift_x = vertex.x() - beamSpotHandle->beamTilt(0)*vertex.z();
84  float shift_y = vertex.y() - beamSpotHandle->beamTilt(1)*vertex.z();
85 
86  std::unique_ptr<GNNR3_DataStorage> storage = std::make_unique<GNNR3_DataStorage>(*m_geo);
87 
88  int nPixels = 0;
89  int nStrips = 0;
90 
91  const SpacePointContainer* sctSpacePointsContainer = nullptr;
92  const SpacePointContainer* pixelSpacePointsContainer = nullptr;
93 
94  std::map<short, std::vector<IdentifierHash> > detIdMap;//relates global detector layer ID to constituent detector elements
95 
96  if (m_useSctSpacePoints) {
97 
99 
100  if(!sctHandle.isValid()) {
101  ATH_MSG_WARNING("Invalid Strip Spacepoints handle: "<<sctHandle);
102  return seedStats;
103 
104  }
105 
106  sctSpacePointsContainer = sctHandle.ptr();
107 
108  std::vector<IdentifierHash> listOfSctIds;
109  m_regsel_sct->lookup(ctx)->HashIDList( internalRoI, listOfSctIds );
110 
111  const std::vector<short>* h2l = m_layerNumberTool->sctLayers();
112 
113  for(const auto& hashId : listOfSctIds) {
114 
115  short layerIndex = h2l->at(static_cast<int>(hashId));
116 
117  auto it = detIdMap.find(layerIndex);
118  if(it != detIdMap.end()) (*it).second.push_back(hashId);
119  else {
120  std::vector<IdentifierHash> v = {hashId};
121  detIdMap.insert(std::make_pair(layerIndex,v));
122  }
123  }
124  }
125 
126  if (m_usePixelSpacePoints) {
127 
129 
130  if(!pixHandle.isValid()) {
131  ATH_MSG_WARNING("Invalid Pixel Spacepoints handle: "<<pixHandle);
132  return seedStats;
133  }
134 
135  pixelSpacePointsContainer = pixHandle.ptr();
136 
137  std::vector<IdentifierHash> listOfPixIds;
138 
139  m_regsel_pix->lookup(ctx)->HashIDList( internalRoI, listOfPixIds );
140 
141  const std::vector<short>* h2l = m_layerNumberTool->pixelLayers();
142 
143  for(const auto& hashId : listOfPixIds) {
144 
145  short layerIndex = h2l->at(static_cast<int>(hashId));
146 
147  auto it = detIdMap.find(layerIndex);
148  if(it != detIdMap.end()) (*it).second.push_back(hashId);
149  else {
150  std::vector<IdentifierHash> v = {hashId};
151  detIdMap.insert(std::make_pair(layerIndex,v));
152  }
153  }
154  }
155 
156  if(!m_useGPU) {
157 
158  std::unique_ptr<GNNR3_DataStorage> storage = std::make_unique<GNNR3_DataStorage>(*m_geo);
159 
160  std::vector<const Trk::SpacePoint*> vSP;
161 
162  vSP.reserve(m_nMaxEdges);
163 
164  std::vector<std::vector<GNNR3_Node> > trigSpStorage[2];
165 
166  trigSpStorage[1].resize(m_layerNumberTool->sctLayers()->size());
167 
168  trigSpStorage[0].resize(m_layerNumberTool->pixelLayers()->size());
169 
170  for(const auto& lColl : detIdMap) {
171 
172  short layerIndex = lColl.first;
173 
174  int layerKey = m_geo->getTrigFTF_GNNR3_LayerByIndex(layerIndex)->m_layer.m_subdet;
175 
176  bool isPixel = layerKey > 20000;
177 
178  auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
179 
180  int contIdx= isPixel ? 0 : 1;
181 
182  int nNewNodes = 0;
183 
184  for(const auto& idx : lColl.second) {
185 
186  std::vector<GNNR3_Node>& tmpColl = trigSpStorage[contIdx].at(static_cast<int>(idx));
187 
188  auto input_coll = pCont->indexFindPtr(idx);
189 
190  if(input_coll == nullptr) continue;
191 
192  createGraphNodes(input_coll, tmpColl, vSP, layerIndex, shift_x, shift_y);//TO-DO: if(m_useBeamTilt) SP full transform functor
193 
194  nNewNodes += (isPixel) ? storage->loadPixelGraphNodes(layerIndex, tmpColl, m_useML) : storage->loadStripGraphNodes(layerIndex, tmpColl);
195  }
196 
197  if(isPixel) nPixels += nNewNodes;
198  else nStrips += nNewNodes;
199  }
200 
201  seedStats.m_nPixelSPs = nPixels;
202  seedStats.m_nStripSPs = nStrips;
203 
204  storage->sortByPhi();
205  storage->initializeNodes(m_useML);
206  storage->generatePhiIndexing(1.5*m_phiSliceWidth);
207 
208  std::vector<GNNR3_Edge> edgeStorage;
209 
210  std::pair<int, int> graphStats = buildTheGraph(internalRoI, storage, edgeStorage);
211 
212  ATH_MSG_DEBUG("Created graph with "<<graphStats.first<<" edges and "<<graphStats.second<< " edge links");
213 
214  seedStats.m_nGraphEdges = graphStats.first;
215  seedStats.m_nEdgeLinks = graphStats.second;
216 
217  if(graphStats.second == 0) return seedStats;
218 
219  int maxLevel = runCCA(graphStats.first, edgeStorage);
220 
221  ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
222 
223  int minLevel = 3;//a triplet + 1 confirmation
224 
225  if(m_LRTmode) {
226  minLevel = 2;//a triplet
227  }
228 
229  if(maxLevel < minLevel) return seedStats;
230 
231  std::vector<GNNR3_Edge*> vSeeds;
232 
233  vSeeds.reserve(graphStats.first/2);
234 
235  for(int edgeIndex=0;edgeIndex<graphStats.first;edgeIndex++) {
236  GNNR3_Edge* pS = &(edgeStorage.at(edgeIndex));
237 
238  if(pS->m_level < minLevel) continue;
239 
240  vSeeds.push_back(pS);
241  }
242 
243  if(vSeeds.empty()) return seedStats;
244 
245  std::sort(vSeeds.begin(), vSeeds.end(), GNNR3_Edge::CompareLevel());
246 
247  //backtracking
248 
249  TrigFTF_GNNR3_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
250 
251  output.reserve(vSeeds.size());
252 
253  for(auto pS : vSeeds) {
254 
255  if(pS->m_level == -1) continue;
256 
257  TrigFTF_GNNR3_EdgeState rs(false);
258 
259  tFilter.followTrack(pS, rs);
260 
261  if(!rs.m_initialized) {
262  continue;
263  }
264 
265  if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
266 
267  std::vector<const GNNR3_Node*> vN;
268 
269  for(std::vector<GNNR3_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
270 
271  (*sIt)->m_level = -1;//mark as collected
272 
273  if(sIt == rs.m_vs.rbegin()) {
274  vN.push_back((*sIt)->m_n1);
275  }
276  vN.push_back((*sIt)->m_n2);
277  }
278 
279  if(vN.size()<3) continue;
280 
281  unsigned int lastIdx = output.size();
282  output.emplace_back(rs.m_J);
283 
284  for(const auto& n : vN) {
285  output[lastIdx].addSpacePoint(vSP[n->m_idx]);
286  }
287  }
288 
289  ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
290  }
291 #if 0
292  else {//GPU-accelerated graph building
293 
294 
295  //1. data export
296 
297  std::vector<const Trk::SpacePoint*> vSP;
298  std::vector<short> vL;
299 
300  vSP.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
301  vL.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
302 
303  std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER> dataBuffer = std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER>(new TrigAccel::DATA_EXPORT_BUFFER(5000));
304 
305  size_t dataTypeSize = sizeof(TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA);
306  const size_t bufferOffset = 256;
307  size_t totalSize = bufferOffset+dataTypeSize;//make room for the header
308  if(!dataBuffer->fit(totalSize)) dataBuffer->reallocate(totalSize);
309 
310  TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA* pJobData = reinterpret_cast<TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA*>(dataBuffer->m_buffer + bufferOffset);
311 
312  unsigned int spIdx = 0;
313  int sp_offset = 0;
314  int nLayers = 0;
315  int MaxEtaBin = 0;
316  int nEtaBins = 0;
317 
318  for(const auto& lColl : detIdMap) {
319 
320  short layerIndex = lColl.first;
321 
322  const TrigFTF_GNNR3_Layer* pL = m_geo->getTrigFTF_GNNR3_LayerByIndex(layerIndex);
323 
324  int layerKey = pL->m_layer.m_subdet;
325 
326  bool isPixel = layerKey > 20000;
327  bool isBarrel = (pL->m_layer.m_type == 0);
328 
329  auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
330 
331  pJobData->m_layerIdx[nLayers] = layerIndex;
332 
333  pJobData->m_layerInfo[4*nLayers ] = spIdx;//layerInfo.x
334  pJobData->m_layerInfo[4*nLayers + 2] = pL->num_bins();//layerInfo.z
335  pJobData->m_layerInfo[4*nLayers + 3] = pL->m_bins[0];//layerInfo.w
336 
337  pJobData->m_layerGeo[2*nLayers ] = pL->m_minEta;//layerGeo.x
338  pJobData->m_layerGeo[2*nLayers + 1] = pL->m_etaBin;//layerGeo.y
339 
340  nEtaBins += pL->m_bins.size();
341 
342  for(auto b : pL->m_bins) {
343  if(b > MaxEtaBin) MaxEtaBin = b;
344  }
345 
346  for(const auto& idx : lColl.second) {
347 
348  auto input_coll = pCont->indexFindPtr(idx);
349 
350  if(input_coll == nullptr) continue;
351 
352  for(const auto sp : *input_coll) {
353 
354  float cw = -1.0;
355 
356  const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
357  if(pCL != nullptr) {
358  cw = pCL->width().widthPhiRZ().y();
359  if(!isBarrel && m_useML) {
360  if(cw > 0.2) continue;
361  cw = -1.0;//set it to -1 so that it can be skipped later in the ML code on GPU
362  }
363  }
364 
365  vSP.emplace_back(sp);
366  vL.emplace_back(layerIndex);
367 
368  const auto& p = sp->globalPosition();
369 
370  float params[4] = {(float)(p.x() - shift_x), float(p.y() - shift_y), (float)(p.z()), cw};
371 
372  memcpy(&pJobData->m_params[sp_offset], &params[0], sizeof(params));
373 
374  sp_offset += 4;
375  spIdx++;
376  if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
377  }
378  if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
379  }
380 
381  pJobData->m_layerInfo[4*nLayers + 1] = spIdx;//layerInfo.y
382 
383  if (isPixel) nPixels += spIdx - pJobData->m_layerInfo[4*nLayers];
384  else nStrips += spIdx - pJobData->m_layerInfo[4*nLayers];
385 
386  nLayers++;
387  }
388 
389  pJobData->m_nSpacepoints = spIdx;
390  pJobData->m_nLayers = nLayers;
391  pJobData->m_nEtaBins = nEtaBins;
392  pJobData->m_maxEtaBin = MaxEtaBin;
393  pJobData->m_nMaxEdges = m_nMaxEdges;
394 
395  //load bin pairs
396 
397  int pairIdx = 0;
398 
399  for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
400 
401  int bin1_idx = bg.first;
402 
403  for(const auto& bin2_idx : bg.second) {
404  pJobData->m_bin_pairs[2*pairIdx ] = bin1_idx;
405  pJobData->m_bin_pairs[2*pairIdx+1] = bin2_idx;
406  pairIdx++;
407  }
408  }
409 
410  pJobData->m_nBinPairs = pairIdx;
411 
412  //add algorithm parameters
413 
414  const float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
415 
416  float tripletPtMin = 0.8*m_minPt;//correction due to limited pT resolution
417 
418  float maxCurv = ptCoeff/tripletPtMin;
419 
420  const float min_deltaPhi = 0.001;
421  const float dphi_coeff = 0.68*maxCurv;
422  const float cut_dphi_max = m_LRTmode ? 0.07 : 0.012;
423  const float cut_dcurv_max = m_LRTmode ? 0.015 : 0.001;
424  const float cut_tau_ratio_max = m_LRTmode ? 0.015 : 0.007;
425  const float min_z0 = m_LRTmode ? -600.0 : internalRoI.zedMinus();
426  const float max_z0 = m_LRTmode ? 600.0 : internalRoI.zedPlus();
427 
428  const float maxOuterRadius = m_LRTmode ? 1050.0 : 550.0;
429  const float minDeltaRadius = 2.0;
430 
431  const float cut_zMinU = min_z0 + maxOuterRadius*internalRoI.dzdrMinus();
432  const float cut_zMaxU = max_z0 + maxOuterRadius*internalRoI.dzdrPlus();
433 
434  const float maxKappa_high_eta = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.8)*maxCurv;
435  const float maxKappa_low_eta = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.6)*maxCurv;
436 
437  pJobData->m_algo_params[0] = min_deltaPhi;
438  pJobData->m_algo_params[1] = dphi_coeff;
439  pJobData->m_algo_params[2] = minDeltaRadius;
440  pJobData->m_algo_params[3] = min_z0;
441  pJobData->m_algo_params[4] = max_z0;
442  pJobData->m_algo_params[5] = maxOuterRadius;
443  pJobData->m_algo_params[6] = cut_zMinU;
444  pJobData->m_algo_params[7] = cut_zMaxU;
445  pJobData->m_algo_params[8] = maxKappa_low_eta;
446  pJobData->m_algo_params[9] = maxKappa_high_eta;
447  pJobData->m_algo_params[10]= cut_dphi_max;
448  pJobData->m_algo_params[11]= cut_dcurv_max;
449  pJobData->m_algo_params[12]= cut_tau_ratio_max;
450 
451  int minLevel = 3;//a triplet + 1 confirmation
452 
453  if(m_LRTmode) {
454  minLevel = 2;//a triplet
455  }
456 
457  pJobData->m_minLevel = minLevel;
458 
460 
461  seedStats.m_nPixelSPs = nPixels;
462  seedStats.m_nStripSPs = nStrips;
463 
464  ATH_MSG_DEBUG("Loaded "<<nPixels<< " Pixel Spacepoints and "<<nStrips<< " Strip SpacePoints");
465 
466  std::shared_ptr<TrigAccel::OffloadBuffer> pBuff = std::make_shared<TrigAccel::OffloadBuffer>(dataBuffer.get());
467 
468  std::unique_ptr<TrigAccel::Work> pWork = std::unique_ptr<TrigAccel::Work>(m_accelSvc->createWork(TrigAccel::InDetJobControlCode::RUN_GBTS, pBuff));
469 
470  if(!pWork) {
471  ATH_MSG_WARNING("Failed to create a work item for task "<<TrigAccel::InDetJobControlCode::RUN_GBTS);
472  return seedStats;
473  }
474 
475  ATH_MSG_DEBUG("Work item created for task "<<TrigAccel::InDetJobControlCode::RUN_GBTS);
476 
477  bool workSuccess = pWork->run();
478  if(!workSuccess) {
479  ATH_MSG_WARNING("Work item failed to complete");
480  return seedStats;
481  }
482 
483  std::shared_ptr<TrigAccel::OffloadBuffer> pOutput = pWork->getOutput();
484 
486  TrigAccel::ITk::COMPRESSED_GRAPH* pGraph = &pGraphAndSeeds->m_CompressedGraph;
487  TrigAccel::ITk::OUTPUT_SEEDS* pSeeds = &pGraphAndSeeds->m_OutputSeeds;
488 
490  //converting tracklet into GBTS-CPU format
491  for(unsigned int seed=0; seed<pSeeds->m_nSeeds; seed++) {
492 
493  unsigned int lastIdx = output.size();
494  output.emplace_back(pSeeds->m_seedsArray[seed].m_Q);
495  for(int node=0; node<pSeeds->m_seedsArray[seed].m_size; node++) {
496  output[lastIdx].addSpacePoint(vSP[pSeeds->m_seedsArray[seed].m_nodes[node]]);
497  }
498  }
499  }
500  else {
501 
502  unsigned int nEdges = pGraph->m_nEdges;
503  unsigned int nMaxNei = pGraph->m_nMaxNeighbours;
504 
505  //populating the edgeStorage
506 
507  std::vector<GNNR3_Node> nodes;
508 
509  nodes.reserve(vSP.size());
510 
511  for(unsigned int idx = 0;idx < vSP.size(); idx++) {
512 
513  nodes.emplace_back(vL[idx]);
514 
515  const auto& pos = vSP[idx]->globalPosition();
516  float xs = pos.x() - shift_x;
517  float ys = pos.y() - shift_y;
518  float zs = pos.z();
519 
520  nodes[idx].m_x = xs;
521  nodes[idx].m_y = ys;
522  nodes[idx].m_z = zs;
523  nodes[idx].m_r = std::sqrt(xs*xs + ys*ys);
524 
525  nodes[idx].m_idx = idx;
526 
527  }
528 
529  std::vector<GNNR3_Edge> edgeStorage;
530 
531  std::pair<int, int> graphStats(0,0);
532 
533  edgeStorage.resize(nEdges);
534 
535  unsigned int edgeSize = nMaxNei + 1 + 2;//neigbours, num_neighbours, 2 nodes
536 
537  for(unsigned int idx=0;idx<nEdges;idx++) {
538  unsigned int pos = idx*edgeSize;
539 
540  int node1Idx = pGraph->m_graphArray[pos + TrigAccel::ITk::node1];
541  int node2Idx = pGraph->m_graphArray[pos + TrigAccel::ITk::node2];
542  int nNei = pGraph->m_graphArray[pos + TrigAccel::ITk::nNei];
543 
544  if(nNei > N_SEG_CONNS) nNei = N_SEG_CONNS;
545 
546  edgeStorage[idx].m_n1 = &nodes[node1Idx];
547  edgeStorage[idx].m_n2 = &nodes[node2Idx];
548  edgeStorage[idx].m_level = 1;
549  edgeStorage[idx].m_nNei = nNei;
550  for(int k=0;k<nNei;k++) {
551  edgeStorage[idx].m_vNei[k] = pGraph->m_graphArray[pos + TrigAccel::ITk::nei_idx_start + k];
552  }
553  }
554 
555  graphStats.first = nEdges;
556  graphStats.second = pGraph->m_nLinks;
557 
558  //run the rest of the GBTS workflow
559 
560  int maxLevel = runCCA(graphStats.first, edgeStorage);
561 
562  ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
563 
564  if(maxLevel < minLevel) return seedStats;
565 
566  std::vector<GNNR3_Edge*> vSeeds;
567 
568  vSeeds.reserve(graphStats.first/2);
569 
570  for(int edgeIndex=0;edgeIndex<graphStats.first;edgeIndex++) {
571  GNNR3_Edge* pS = &(edgeStorage.at(edgeIndex));
572 
573  if(pS->m_level < minLevel) continue;
574 
575  vSeeds.push_back(pS);
576  }
577 
578  if(vSeeds.empty()) return seedStats;
579 
580  std::sort(vSeeds.begin(), vSeeds.end(), GNNR3_Edge::CompareLevel());
581 
582  //backtracking
583 
584  TrigFTF_GNNR3_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
585 
586  output.reserve(vSeeds.size());
587 
588  for(auto pS : vSeeds) {
589 
590  if(pS->m_level == -1) continue;
591 
592  TrigFTF_GNNR3_EdgeState rs(false);
593 
594  tFilter.followTrack(pS, rs);
595 
596  if(!rs.m_initialized) {
597  continue;
598  }
599 
600  if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
601 
602  std::vector<const GNNR3_Node*> vN;
603 
604  for(std::vector<GNNR3_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
605 
606  (*sIt)->m_level = -1;//mark as collected
607 
608  if(sIt == rs.m_vs.rbegin()) {
609  vN.push_back((*sIt)->m_n1);
610  }
611  vN.push_back((*sIt)->m_n2);
612  }
613 
614  if(vN.size()<3) continue;
615 
616  unsigned int lastIdx = output.size();
617  output.emplace_back(rs.m_J);
618 
619  for(const auto& n : vN) {
620  output[lastIdx].addSpacePoint(vSP[n->m_idx]);
621  }
622  }
623  }
624 
625  ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
626  }
627 
628 #endif
629 
630  return seedStats;
631 
632 }
633 
634 void TrigInDetR3TrackSeedingTool::createGraphNodes(const SpacePointCollection* spColl, std::vector<GNNR3_Node>& tmpColl, std::vector<const Trk::SpacePoint*>& vSP, unsigned short layer, float shift_x, float shift_y) const {
635 
636  tmpColl.resize(spColl->size(), GNNR3_Node(layer));//all nodes belong to the same layer
637 
638  int idx = 0;
639  int init_size = vSP.size();
640  for(const auto sp : *spColl) {
641  const auto& pos = sp->globalPosition();
642  vSP.emplace_back(sp);
643  float xs = pos.x() - shift_x;
644  float ys = pos.y() - shift_y;
645  float zs = pos.z();
646  tmpColl[idx].m_x = xs;
647  tmpColl[idx].m_y = ys;
648  tmpColl[idx].m_z = zs;
649  tmpColl[idx].m_r = std::sqrt(xs*xs + ys*ys);
650  tmpColl[idx].m_phi = std::atan2(ys,xs);
651  tmpColl[idx].m_idx = init_size + idx;
652 
653  const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
654  if(pCL != nullptr){
655  tmpColl[idx].m_pcw = pCL->width().z();
656  }
657 
658  idx++;
659  }
660 }
661 
TrigFTF_GNNR3_TrackingFilter::followTrack
void followTrack(TrigFTF_GNNR3_Edge *, TrigFTF_GNNR3_EdgeState &)
Definition: GNNR3_TrackingFilter.cxx:82
PixelID.h
This is an Identifier helper class for the Pixel subdetector. This class is a factory for creating co...
SeedingToolBase::m_layerGeometry
std::vector< TrigInDetSiLayer > m_layerGeometry
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:72
TrigAccel::ITk::GraphAndSeedsOutput::m_OutputSeeds
OUTPUT_SEEDS m_OutputSeeds
Definition: TrigITkAccelEDM.h:182
TrigInDetTrackSeedingResult::m_nStripSPs
int m_nStripSPs
Definition: TrigInDetTrackSeedingResult.h:12
TrigAccel::ITk::CompressedGraph::m_nEdges
unsigned int m_nEdges
Definition: TrigITkAccelEDM.h:157
IRegSelTool.h
TrigAccel::DataExportBuffer
Definition: DataExportBuffer.h:14
TrigAccel::ITk::GraphMakingInputData
Definition: TrigITkAccelEDM.h:126
TrigAccel::DataExportBuffer::fit
bool fit(size_t s)
Definition: DataExportBuffer.h:26
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SCT_ID.h
This is an Identifier helper class for the SCT subdetector. This class is a factory for creating comp...
SeedingToolBase::initialize
virtual StatusCode initialize()
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:19
SeedingToolBase
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:26
TrigFTF_GNNR3_Layer::m_layer
const TrigInDetSiLayer & m_layer
Definition: GNNR3_Geometry.h:30
StandaloneBunchgroupHandler.bg
bg
Definition: StandaloneBunchgroupHandler.py:241
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TCS::KFMET::nEtaBins
constexpr unsigned nEtaBins
Definition: KalmanMETCorrectionConstants.h:18
TrigAccel::DataExportBuffer::reallocate
void reallocate(size_t s)
Definition: DataExportBuffer.h:30
PixelCluster.h
TrigAccel::ITk::GraphMakingInputData::m_layerIdx
int m_layerIdx[GBTS_MAX_SILICON_LAYERS]
Definition: TrigITkAccelEDM.h:133
TrigAccel::Work::run
virtual bool run()=0
SG::ReadHandle< SpacePointContainer >
TrigAccel::ITk::OutputSeeds::m_nSeeds
unsigned int m_nSeeds
Definition: TrigITkAccelEDM.h:173
SeedingToolBase::buildTheGraph
std::pair< int, int > buildTheGraph(const IRoiDescriptor &, const std::unique_ptr< GNN_DataStorage > &, std::vector< GNN_Edge > &) const
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:71
InDet::SiWidth::widthPhiRZ
const Amg::Vector2D & widthPhiRZ() const
Definition: SiWidth.h:121
TrigFTF_GNNR3_EdgeState::m_initialized
bool m_initialized
Definition: GNNR3_TrackingFilter.h:38
TrigFTF_GNNR3_Edge
Definition: GNNR3_DataStorage.h:106
SeedingToolBase::m_nMaxEdges
IntegerProperty m_nMaxEdges
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:60
TrigAccel::Work::getOutput
virtual std::shared_ptr< OffloadBuffer > getOutput()=0
skel.it
it
Definition: skel.GENtoEVGEN.py:407
TrigFTF_GNNR3_TrackingFilter
Definition: GNNR3_TrackingFilter.h:44
TrigFTF_GNNR3_DataStorage::loadStripGraphNodes
int loadStripGraphNodes(short, const std::vector< TrigFTF_GNNR3_Node > &)
Definition: GNNR3_DataStorage.cxx:142
TrigFTF_GNNR3_Layer::m_etaBin
float m_etaBin
Definition: GNNR3_Geometry.h:37
TrigFTF_GNNR3_Edge::m_level
signed char m_level
Definition: GNNR3_DataStorage.h:128
TrigInDetR3TrackSeedingTool::m_regsel_sct
ToolHandle< IRegSelTool > m_regsel_sct
Definition: TrigInDetR3TrackSeedingTool.h:68
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
TrigFTF_GNNR3_EdgeState
Definition: GNNR3_TrackingFilter.h:11
IRoiDescriptor::dzdrMinus
virtual double dzdrMinus() const =0
return the gradients
TrigInDetR3TrackSeedingTool::createGraphNodes
void createGraphNodes(const SpacePointCollection *, std::vector< GNNR3_Node > &, std::vector< const Trk::SpacePoint * > &, unsigned short, float, float) const
Definition: TrigInDetR3TrackSeedingTool.cxx:634
TrigInDetR3TrackSeedingTool.h
TrigFTF_GNNR3_Node
Definition: GNNR3_DataStorage.h:18
TrigAccel::RUN_GBTS
@ RUN_GBTS
Definition: TrigInDetAccelCodes.h:31
SpacePointContainer.h
TrigInDetR3TrackSeedingTool::TrigInDetR3TrackSeedingTool
TrigInDetR3TrackSeedingTool(const std::string &, const std::string &, const IInterface *)
Definition: TrigInDetR3TrackSeedingTool.cxx:27
IRoiDescriptor::dzdrPlus
virtual double dzdrPlus() const =0
TrigFTF_GNNR3_Layer
Definition: GNNR3_Geometry.h:16
TrigAccel::ITk::GraphAndSeedsOutput
Definition: TrigITkAccelEDM.h:179
N_SEG_CONNS
#define N_SEG_CONNS
Definition: GNN_DataStorage.h:14
TrigFTF_GNNR3_DataStorage::loadPixelGraphNodes
int loadPixelGraphNodes(short, const std::vector< TrigFTF_GNNR3_Node > &, bool)
Definition: GNNR3_DataStorage.cxx:104
AtlasDetectorID.h
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
SeedingToolBase::m_useGPUseedExtraction
BooleanProperty m_useGPUseedExtraction
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:64
TrigAccel::ITk::GraphAndSeedsOutput::m_CompressedGraph
COMPRESSED_GRAPH m_CompressedGraph
Definition: TrigITkAccelEDM.h:181
SpacePointCollection.h
TrigInDetR3TrackSeedingTool::m_usePixelSpacePoints
BooleanProperty m_usePixelSpacePoints
Definition: TrigInDetR3TrackSeedingTool.h:58
TrigFTF_GNNR3_Layer::m_minEta
float m_minEta
Definition: GNNR3_Geometry.h:37
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
SeedingToolBase::m_LRTmode
BooleanProperty m_LRTmode
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:51
TrigAccel::ITk::GraphMakingInputData::m_nEtaBins
unsigned int m_nEtaBins
Definition: TrigITkAccelEDM.h:129
TrigFTF_GNNR3_DataStorage::initializeNodes
void initializeNodes(bool)
Definition: GNNR3_DataStorage.cxx:182
TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA
struct TrigAccel::ITk::GraphMakingInputData GRAPH_MAKING_INPUT_DATA
TrigFTF_GNNR3_EdgeState::m_J
float m_J
Definition: GNNR3_TrackingFilter.h:31
TrigAccel::ITk::OutputSeeds::m_seedsArray
std::unique_ptr< Tracklet[]> m_seedsArray
Definition: TrigITkAccelEDM.h:175
SeedingToolBase::m_minPt
FloatProperty m_minPt
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:58
beamspotman.n
n
Definition: beamspotman.py:729
TrigFTF_GNNR3_DataStorage::generatePhiIndexing
void generatePhiIndexing(float)
Definition: GNNR3_DataStorage.cxx:226
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
SpacePoint.h
IRoiDescriptor
Describes the API of the Region of Ineterest geometry.
Definition: IRoiDescriptor.h:23
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
TrigAccel::ITk::GraphMakingInputData::m_params
float m_params[4 *GBTS_MAX_NUMBER_SPACEPOINTS]
Definition: TrigITkAccelEDM.h:131
TrigAccel::ITk::GraphMakingInputData::m_nSpacepoints
unsigned int m_nSpacepoints
Definition: TrigITkAccelEDM.h:129
SeedingToolBase::finalize
virtual StatusCode finalize()
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:66
TrigAccel::ITk::GraphMakingInputData::m_minLevel
int m_minLevel
Definition: TrigITkAccelEDM.h:149
TrigAccel::ITk::CompressedGraph::m_nLinks
unsigned int m_nLinks
Definition: TrigITkAccelEDM.h:160
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigInDetR3TrackSeedingTool::m_pixelSpacePointsContainerKey
SG::ReadHandleKey< SpacePointContainer > m_pixelSpacePointsContainerKey
Definition: TrigInDetR3TrackSeedingTool.h:63
TrigFTF_GNNR3_Edge::CompareLevel
Definition: GNNR3_DataStorage.h:109
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
TrigAccel::ITk::GraphMakingInputData::m_maxEtaBin
unsigned int m_maxEtaBin
Definition: TrigITkAccelEDM.h:129
TrigAccel::ITk::GraphMakingInputData::m_bin_pairs
int m_bin_pairs[2 *GBTS_MAX_ETA_BIN_PAIR]
Definition: TrigITkAccelEDM.h:145
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TrigFTF_GNNR3_Layer::m_bins
std::vector< int > m_bins
Definition: GNNR3_Geometry.h:31
TrigInDetSiLayer::m_type
int m_type
Definition: TrigInDetSiLayer.h:11
merge.output
output
Definition: merge.py:16
SeedingToolBase::m_layerNumberTool
ToolHandle< ITrigL2LayerNumberTool > m_layerNumberTool
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:43
MuonGM::nStrips
int nStrips(const MuonGM::TgcReadoutElement &readoutEle, int layer)
Definition: MuonDetDescr/MuonGeoModelTest/src/GeoModelTgcTest.cxx:46
TrigAccel::ITk::GraphMakingInputData::m_layerInfo
int m_layerInfo[4 *GBTS_MAX_SILICON_LAYERS]
Definition: TrigITkAccelEDM.h:137
TrigAccel::ITk::GraphMakingInputData::m_nMaxEdges
unsigned int m_nMaxEdges
Definition: TrigITkAccelEDM.h:129
TrigInDetR3TrackSeedingTool::finalize
virtual StatusCode finalize() override
Definition: TrigInDetR3TrackSeedingTool.cxx:70
TrigInDetR3TrackSeedingTool::initialize
virtual StatusCode initialize() override
Definition: TrigInDetR3TrackSeedingTool.cxx:34
SeedingToolBase::m_geo
std::unique_ptr< const TrigFTF_GNN_Geometry > m_geo
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:73
PathResolver.h
TrigInDetR3TrackSeedingTool::findSeeds
virtual TrigInDetTrackSeedingResult findSeeds(const IRoiDescriptor &, std::vector< TrigInDetTracklet > &, const EventContext &) const override final
Definition: TrigInDetR3TrackSeedingTool.cxx:75
TrigInDetTrackSeedingResult::m_nPixelSPs
int m_nPixelSPs
Definition: TrigInDetTrackSeedingResult.h:10
TrigInDetR3TrackSeedingTool::m_useGPU
BooleanProperty m_useGPU
Definition: TrigInDetR3TrackSeedingTool.h:72
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
TrigAccel::ITk::GraphMakingInputData::m_layerGeo
float m_layerGeo[2 *GBTS_MAX_SILICON_LAYERS]
Definition: TrigITkAccelEDM.h:141
SeedingToolBase::m_phiSliceWidth
float m_phiSliceWidth
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:69
TrigInDetTrackSeedingResult
Definition: TrigInDetTrackSeedingResult.h:8
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TrigAccel::ITk::GraphMakingInputData::m_nBinPairs
unsigned int m_nBinPairs
Definition: TrigITkAccelEDM.h:129
TrigInDetTrackSeedingResult::m_nGraphEdges
int m_nGraphEdges
Definition: TrigInDetTrackSeedingResult.h:12
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
TrigFTF_GNNR3_DataStorage::sortByPhi
void sortByPhi()
Definition: GNNR3_DataStorage.cxx:177
TrigAccel::ITk::CompressedGraph::m_graphArray
std::unique_ptr< int[]> m_graphArray
Definition: TrigITkAccelEDM.h:161
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
TrigAccel::DataExportBuffer::m_buffer
char * m_buffer
Definition: DataExportBuffer.h:57
SG::ReadHandle::ptr
const_pointer_type ptr()
Dereference the pointer.
InDet::PixelCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:49
python.PyAthena.v
v
Definition: PyAthena.py:154
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
TrigAccel::ITk::GraphMakingInputData::m_useGPUseedExtraction
bool m_useGPUseedExtraction
Definition: TrigITkAccelEDM.h:151
InDet::SiCluster::width
const InDet::SiWidth & width() const
return width class reference
TrigAccel::OffloadBuffer::m_rawBuffer
unsigned char * m_rawBuffer
Definition: OffloadBuffer.h:39
TrigAccel::ITk::GraphMakingInputData::m_algo_params
float m_algo_params[32]
Definition: TrigITkAccelEDM.h:147
TrigFTF_GNNR3_EdgeState::m_vs
std::vector< TrigFTF_GNNR3_Edge * > m_vs
Definition: GNNR3_TrackingFilter.h:33
IRoiDescriptor::zedPlus
virtual double zedPlus() const =0
the zed and eta values at the most forward and most rear ends of the RoI
TrigInDetR3TrackSeedingTool::m_useSctSpacePoints
BooleanProperty m_useSctSpacePoints
Definition: TrigInDetR3TrackSeedingTool.h:59
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TrigAccel::ITk::CompressedGraph
Definition: TrigITkAccelEDM.h:155
SpacePointCollection
Definition: SpacePointCollection.h:40
TrigInDetR3TrackSeedingTool::m_sctSpacePointsContainerKey
SG::ReadHandleKey< SpacePointContainer > m_sctSpacePointsContainerKey
Definition: TrigInDetR3TrackSeedingTool.h:62
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
TrigFTF_GNNR3_Layer::num_bins
int num_bins() const
Definition: GNNR3_Geometry.h:26
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
TrigAccel::ITk::OutputSeeds
Definition: TrigITkAccelEDM.h:171
IRoiDescriptor::zedMinus
virtual double zedMinus() const =0
SeedingToolBase::m_useML
BooleanProperty m_useML
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:52
TrigAccel::ITk::GraphMakingInputData::m_nLayers
unsigned int m_nLayers
Definition: TrigITkAccelEDM.h:129
python.copyTCTOutput.totalSize
totalSize
Definition: copyTCTOutput.py:92
SpacePointContainer
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePointContainer.h:29
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
TrigAccel::ITk::CompressedGraph::m_nMaxNeighbours
unsigned int m_nMaxNeighbours
Definition: TrigITkAccelEDM.h:159
GNNR3_TrackingFilter.h
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
SeedingToolBase::runCCA
int runCCA(int, std::vector< GNN_Edge > &) const
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:318
InDet::SiWidth::z
double z() const
Definition: SiWidth.h:131
TrigInDetR3TrackSeedingTool::m_regsel_pix
ToolHandle< IRegSelTool > m_regsel_pix
region selector tools
Definition: TrigInDetR3TrackSeedingTool.h:67
node
Definition: node.h:21
TrigInDetR3TrackSeedingTool::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrigInDetR3TrackSeedingTool.h:56
TrigInDetSiLayer::m_subdet
int m_subdet
Definition: TrigInDetSiLayer.h:10
fitman.k
k
Definition: fitman.py:528
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
TrigInDetTrackSeedingResult::m_nEdgeLinks
int m_nEdgeLinks
Definition: TrigInDetTrackSeedingResult.h:12