73 {
74
75 TrigInDetTrackSeedingResult seedStats;
76
78
79 SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle {
m_beamSpotKey, ctx };
81 float shift_x =
vertex.x() - beamSpotHandle->beamTilt(0)*
vertex.z();
82 float shift_y =
vertex.y() - beamSpotHandle->beamTilt(1)*
vertex.z();
83
84
85 int nPixels = 0;
87
90
91 std::map<short, std::vector<IdentifierHash> > detIdMap;
92
94
96
97 if(!sctHandle.isValid()) {
99 return seedStats;
100
101 }
102
103 sctSpacePointsContainer = sctHandle.ptr();
104
105 std::vector<IdentifierHash> listOfSctIds;
106 m_regsel_sct->lookup(ctx)->HashIDList( internalRoI, listOfSctIds );
107
109
110 for(const auto& hashId : listOfSctIds) {
111
112 short layerIndex = h2l->at(static_cast<int>(hashId));
113
114 auto it = detIdMap.find(layerIndex);
115 if(it != detIdMap.end()) (*it).second.push_back(hashId);
116 else {
117 std::vector<IdentifierHash>
v = {hashId};
118 detIdMap.insert(std::make_pair(layerIndex,v));
119 }
120 }
121 }
122
124
126
127 if(!pixHandle.isValid()) {
129 return seedStats;
130 }
131
132 pixelSpacePointsContainer = pixHandle.ptr();
133
134 std::vector<IdentifierHash> listOfPixIds;
135
136 m_regsel_pix->lookup(ctx)->HashIDList( internalRoI, listOfPixIds );
137
139
140 for(const auto& hashId : listOfPixIds) {
141
142 short layerIndex = h2l->at(static_cast<int>(hashId));
143
144 auto it = detIdMap.find(layerIndex);
145 if(it != detIdMap.end()) (*it).second.push_back(hashId);
146 else {
147 std::vector<IdentifierHash>
v = {hashId};
148 detIdMap.insert(std::make_pair(layerIndex,v));
149 }
150 }
151 }
152
154
155 std::unique_ptr<GNN_DataStorage> storage = std::make_unique<GNN_DataStorage>(*
m_geo,
m_mlLUT);
156
157 std::vector<const Trk::SpacePoint*> vSP;
158
160
161 std::vector<std::vector<GNN_Node> > trigSpStorage[2];
162
164
166
167 for(const auto& lColl : detIdMap) {
168
169 short layerIndex = lColl.first;
170
171 int layerKey =
m_geo->getTrigFTF_GNN_LayerByIndex(layerIndex)->m_layer.m_subdet;
172
173 bool isPixel = layerKey > 20000;
174
175 auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
176
177 int contIdx= isPixel ? 0 : 1;
178
179 int nNewNodes = 0;
180
181 for(const auto& idx : lColl.second) {
182
183 std::vector<GNN_Node>& tmpColl = trigSpStorage[contIdx].at(static_cast<int>(idx));
184
185 auto input_coll = pCont->indexFindPtr(idx);
186
187 if(input_coll == nullptr) continue;
188
190
191 nNewNodes += (isPixel) ? storage->loadPixelGraphNodes(layerIndex, tmpColl,
m_useML) : storage->loadStripGraphNodes(layerIndex, tmpColl);
192 }
193
194 if(isPixel) nPixels += nNewNodes;
196 }
197
200
201 storage->sortByPhi();
202 storage->initializeNodes(
m_useML);
204
205 std::vector<GNN_Edge> edgeStorage;
206
207 std::pair<int, int> graphStats =
buildTheGraph(internalRoI, storage, edgeStorage);
208
209 ATH_MSG_DEBUG(
"Created graph with "<<graphStats.first<<
" edges and "<<graphStats.second<<
" edge links");
210
213
214 if (graphStats.second == 0) return seedStats;
215
216 int maxLevel =
runCCA(graphStats.first, edgeStorage);
217
218 ATH_MSG_DEBUG(
"Reached Level "<<maxLevel<<
" after GNN iterations");
219
220 std::vector<std::pair<float, std::vector<unsigned int> > > vSeedCandidates;
221
223
224 if (vSeedCandidates.empty()) return seedStats;
225
226 for(const auto& seed : vSeedCandidates) {
227
228 unsigned int lastIdx =
output.size();
230
231 for(
const auto& sp_idx :
seed.second) {
232 output[lastIdx].addSpacePoint(vSP[sp_idx]);
233 }
234 }
235
237 }
238 else {
239
240
241 std::vector<const Trk::SpacePoint*> vSP;
242 std::vector<short> vL;
243
246
247 std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER> dataBuffer = std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER>(
new TrigAccel::DATA_EXPORT_BUFFER(5000));
248
250 const size_t bufferOffset = 256;
251 size_t totalSize = bufferOffset+dataTypeSize;
253
255
256 unsigned int spIdx = 0;
257 int sp_offset = 0;
258 int nLayers = 0;
259 int MaxEtaBin = 0;
261
262 for(const auto& lColl : detIdMap) {
263
264 short layerIndex = lColl.first;
265
266 const TrigFTF_GNN_Layer* pL =
m_geo->getTrigFTF_GNN_LayerByIndex(layerIndex);
267
269
270 bool isPixel = layerKey > 20000;
272
273 auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
274
276
280
283
285
286 for(
auto b : pL->
m_bins) {
287 if(b > MaxEtaBin) MaxEtaBin =
b;
288 }
289
290 for(const auto& idx : lColl.second) {
291
292 auto input_coll = pCont->indexFindPtr(idx);
293
294 if(input_coll == nullptr) continue;
295
296 for(
const auto sp : *input_coll) {
297
298 float cw = -1.0;
299
300 const InDet::PixelCluster* pCL =
dynamic_cast<const InDet::PixelCluster*
>(
sp->clusterList().first);
301 if(pCL != nullptr) {
304 if(cw > 0.2) continue;
305 cw = -1.0;
306 }
307 }
308
309 vSP.emplace_back(
sp);
310 vL.emplace_back(layerIndex);
311
312 const auto&
p =
sp->globalPosition();
313
315
316 memcpy(&pJobData->
m_params[sp_offset], ¶ms[0],
sizeof(params));
317
318 sp_offset += 4;
319 spIdx++;
321 }
323 }
324
326
327 if (isPixel) nPixels += spIdx - pJobData->
m_layerInfo[4*nLayers];
329
330 nLayers++;
331 }
332
333 if(spIdx == 0) return seedStats;
334
339 pJobData->
m_nMaxEdges =
static_cast<unsigned int>(7*spIdx);
340
341
342
343 int pairIdx = 0;
344
345 for(
const auto& bg :
m_geo->bin_groups()) {
346
347 int bin1_idx =
bg.first;
348
349 for(
const auto& bin2_idx :
bg.second) {
352 pairIdx++;
353 }
354 }
355
357
358
359
360 const float ptCoeff = 0.29997*1.9972/2.0;
361
362 float tripletPtMin = 0.8*
m_minPt;
363
364 float maxCurv = ptCoeff/tripletPtMin;
365
366 const float pt_scale = 900/
m_minPt;
367
368 const float min_deltaPhi_low_dr = 0.002*pt_scale;
369 const float dphi_coeff_low_dr = 4.33e-4*pt_scale;
370 const float min_deltaPhi = 0.015*pt_scale;
371 const float dphi_coeff = 2.2e-4*pt_scale;
372
373 const float cut_dphi_max =
m_LRTmode ? 0.07 : 0.012;
374 const float cut_dcurv_max =
m_LRTmode ? 0.015 : 0.001;
375 const float cut_tau_ratio_max =
m_LRTmode ? 0.015f : 0.01;
378
379 const float maxOuterRadius =
m_LRTmode ? 1050.0 : 550.0;
380 const float minDeltaRadius = 2.0;
381
382 const float cut_zMinU = min_z0 + maxOuterRadius*internalRoI.
dzdrMinus();
383 const float cut_zMaxU = max_z0 + maxOuterRadius*internalRoI.
dzdrPlus();
384
385 const float maxKappa =
m_LRTmode ? 1.0*maxCurv : 0.9*maxCurv;
386
401
402 int minLevel = 3;
403
405 minLevel = 2;
406 }
407
409
411
414
415 ATH_MSG_DEBUG(
"Loaded "<<nPixels<<
" Pixel Spacepoints and "<<nStrips<<
" Strip SpacePoints");
416
417 std::shared_ptr<TrigAccel::OffloadBuffer> pBuff = std::make_shared<TrigAccel::OffloadBuffer>(dataBuffer.get());
418
420
421 if(!pWork) {
423 return seedStats;
424 }
425
426 bool workSuccess = pWork->run();
427 if(!workSuccess) {
429 return seedStats;
430 }
431
432 std::shared_ptr<TrigAccel::OffloadBuffer> pOutput = pWork->getOutput();
433
437
439 if(pSeeds->
m_nSeeds == 0)
return seedStats;
440
442
443 unsigned int lastIdx =
output.size();
447 }
448 }
449 }
450 else {
451
452 unsigned int nEdges = pGraph->
m_nEdges;
454
455
456
457 std::vector<GNN_Node> nodes;
458 nodes.reserve(vSP.size());
459
460 for(
unsigned int idx = 0;
idx < vSP.size();
idx++) {
461 nodes.emplace_back(static_cast<unsigned short>(vL[idx]));
462 auto &node = nodes.back();
463
464 const auto&
pos = vSP[
idx]->globalPosition();
465 float xs =
pos.x() - shift_x;
466 float ys =
pos.y() - shift_y;
467
468 node.m_x = xs;
469 node.m_y = ys;
471 node.m_r = std::sqrt(xs*xs + ys*ys);
473
474 }
475
476 std::vector<GNN_Edge> edgeStorage;
477
478 std::pair<int, int> graphStats(0,0);
479
480 edgeStorage.resize(nEdges);
481
482 unsigned int edgeSize = nMaxNei + 1 + 2;
483
484 for(
unsigned int idx=0;
idx<nEdges;
idx++) {
485 unsigned int pos =
idx*edgeSize;
486
490
492
493 edgeStorage[
idx].m_n1 = &nodes[node1Idx];
494
495 edgeStorage[
idx].m_n2 = &nodes[node2Idx];
496 edgeStorage[
idx].m_level = 1;
497 edgeStorage[
idx].m_nNei = nNei;
498 for(
int k=0;
k<nNei;
k++) {
500 }
501 }
502
503 graphStats.first = nEdges;
504 graphStats.second = pGraph->
m_nLinks;
505
506
507
508 int maxLevel =
runCCA(graphStats.first, edgeStorage);
509
510 ATH_MSG_DEBUG(
"Reached Level "<<maxLevel<<
" after GNN iterations");
511
512 if(maxLevel < minLevel) return seedStats;
513
514 std::vector<GNN_Edge*> vSeeds;
515
516 vSeeds.reserve(graphStats.first/2);
517
518 for(int edgeIndex=0;edgeIndex<graphStats.first;edgeIndex++) {
519 GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
520
521 if(pS->m_level < minLevel) continue;
522
523 vSeeds.push_back(pS);
524 }
525
526 if(vSeeds.empty()) return seedStats;
527
529
530
531
532
533
535
536 output.reserve(vSeeds.size());
537
538 for(auto pS : vSeeds) {
539
540 if(pS->m_level == -1) continue;
541
542 TrigFTF_GNN_EdgeState
rs(
false);
543
544 tFilter.followTrack(pS,
rs);
545
546 if(!
rs.m_initialized) {
547 continue;
548 }
549
550 if(
static_cast<int>(
rs.m_vs.size()) < minLevel)
continue;
551
552 std::vector<const GNN_Node*> vN;
553
554 for(std::vector<GNN_Edge*>::reverse_iterator sIt=
rs.m_vs.rbegin();sIt!=
rs.m_vs.rend();++sIt) {
555
556 (*sIt)->m_level = -1;
557
558 if(sIt ==
rs.m_vs.rbegin()) {
559 vN.push_back((*sIt)->m_n1);
560 }
561 vN.push_back((*sIt)->m_n2);
562 }
563
564 if(vN.size()<3) continue;
565
566 unsigned int lastIdx =
output.size();
568
569 for(const auto& n : vN) {
570 output[lastIdx].addSpacePoint(vSP[
n->m_idx]);
571 }
572 }
573 }
575 }
576 return seedStats;
577}
#define ATH_MSG_DEBUG(x,...)
static unsigned int totalSize(const MultiDimArray< T, N > &ht)
const Amg::Vector2D & widthPhiRZ() const
const TrigInDetSiLayer & m_layer
std::vector< int > m_bins
Eigen::Matrix< double, 3, 1 > Vector3D
int nStrips(const MuonGM::TgcReadoutElement &readoutEle, int layer)
constexpr unsigned nEtaBins
struct TrigAccel::ITk::GraphMakingInputData GRAPH_MAKING_INPUT_DATA
static constexpr unsigned int GBTS_MAX_NUMBER_SPACEPOINTS
static constexpr unsigned char nNei
static constexpr unsigned char node1
static constexpr unsigned char node2
struct TrigAccel::ITk::OutputSeeds OUTPUT_SEEDS
struct TrigAccel::ITk::GraphAndSeedsOutput GRAPH_AND_SEEDS_OUTPUT
static constexpr unsigned char nei_idx_start
struct TrigAccel::ITk::CompressedGraph COMPRESSED_GRAPH
struct TrigAccel::DataExportBuffer DATA_EXPORT_BUFFER
SpacePointContainer_v1 SpacePointContainer
Define the version of the space point container.
std::unique_ptr< int[]> m_graphArray
unsigned int m_nMaxNeighbours
OUTPUT_SEEDS m_OutputSeeds
COMPRESSED_GRAPH m_CompressedGraph
std::unique_ptr< Tracklet[]> m_seedsArray
1.17.0