ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
TrigInDetR3TrackSeedingTool Class Reference

#include <TrigInDetR3TrackSeedingTool.h>

Inheritance diagram for TrigInDetR3TrackSeedingTool:
Collaboration diagram for TrigInDetR3TrackSeedingTool:

Public Member Functions

 TrigInDetR3TrackSeedingTool (const std::string &, const std::string &, const IInterface *)
virtual ~TrigInDetR3TrackSeedingTool ()
virtual StatusCode initialize () override
virtual StatusCode finalize () override
virtual TrigInDetTrackSeedingResult findSeeds (const IRoiDescriptor &, std::vector< TrigInDetTracklet > &, const EventContext &) const override final
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const
 DeclareInterfaceID (ITrigInDetTrackSeedingTool, 1, 0)

Protected Types

typedef TrigFTF_GNN_Node GNN_Node
typedef TrigFTF_GNN_DataStorage GNN_DataStorage
typedef TrigFTF_GNN_Edge GNN_Edge
typedef TrigFTF_GNNR3_Node GNNR3_Node
typedef TrigFTF_GNNR3_DataStorage GNNR3_DataStorage
typedef TrigFTF_GNNR3_Edge GNNR3_Edge

Protected Member Functions

void createGraphNodes (const SpacePointCollection *, std::vector< GNNR3_Node > &, std::vector< const Trk::SpacePoint * > &, unsigned short, float, float) const
std::pair< int, int > buildTheGraph (const IRoiDescriptor &, const std::unique_ptr< GNN_DataStorage > &, std::vector< GNN_Edge > &) const
std::pair< int, int > buildTheGraph (const IRoiDescriptor &, const std::unique_ptr< GNNR3_DataStorage > &, std::vector< GNNR3_Edge > &) const
int runCCA (int, std::vector< GNN_Edge > &) const
int runCCA (int, std::vector< GNNR3_Edge > &) const
void extractSeedsFromTheGraph (int, int, int, std::vector< GNN_Edge > &, std::vector< std::pair< float, std::vector< unsigned int > > > &) const
bool check_z0_bitmask (const unsigned short &, const float &, const float &, const float &) const
float estimate_curvature (const std::array< const GNN_Node *, 3 > &) const
bool validate_triplet (std::array< const GNN_Node *, 3 > &, const float min_pt, const float tau_ratio, const float tau_ratio_cut) const
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Protected Attributes

SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
BooleanProperty m_usePixelSpacePoints {this, "UsePixelSpacePoints", true}
BooleanProperty m_useSctSpacePoints {this, "UseSctSpacePoints", false}
SG::ReadHandleKey< SpacePointContainer > m_sctSpacePointsContainerKey {this, "SCT_SP_ContainerName", "ITkStripTrigSpacePoints"}
SG::ReadHandleKey< SpacePointContainer > m_pixelSpacePointsContainerKey {this, "PixelSP_ContainerName", "ITkPixelTrigSpacePoints"}
ToolHandle< IRegSelTool > m_regsel_pix { this, "RegSelTool_Pixel", "RegSelTool/RegSelTool_Pixel" }
 region selector tools
ToolHandle< IRegSelTool > m_regsel_sct { this, "RegSelTool_SCT", "RegSelTool/RegSelTool_SCT" }
BooleanProperty m_useGPU {this, "UseGPU", false}
ToolHandle< ITrigL2LayerNumberTool > m_layerNumberTool {this, "layerNumberTool", "TrigL2LayerNumberToolITk"}
const AtlasDetectorID * m_atlasId = nullptr
const SCT_ID * m_sctId = nullptr
const PixelID * m_pixelId = nullptr
BooleanProperty m_filter_phi {this, "DoPhiFiltering", true}
BooleanProperty m_useBeamTilt {this, "UseBeamTilt", false}
BooleanProperty m_LRTmode {this, "LRTMode",false}
BooleanProperty m_useML {this, "useML", true}
UnsignedIntegerProperty m_nMaxPhiSlice {this, "nMaxPhiSlice", 53}
BooleanProperty m_doubletFilterRZ {this, "Doublet_FilterRZ", true}
BooleanProperty m_useEtaBinning {this, "UseEtaBinning", true}
BooleanProperty m_matchBeforeCreate {this, "MatchBeforeCreate", true}
FloatProperty m_minPt {this, "pTmin", 1000.0}
FloatProperty m_etaBinOverride {this, "etaBin", 0.0f, "specify non-zero to override eta bin width from connection file (default 0.2 in createLinkingScheme.py)"}
IntegerProperty m_nMaxEdges {this, "MaxGraphEdges", 2000000}
IntegerProperty m_nBufferEdges {this, "BufferEdges", 200000}
StringProperty m_connectionFile {this, "ConnectionFileName", "binTables_ITK_RUN4.txt"}
StringProperty m_lutFile {this, "MLpredictorLutFileName", "gbts_ml_pixel_barrel_loose.lut"}
BooleanProperty m_useGPUseedExtraction {this, "UseGPUseedExtraction", true}
BooleanProperty m_useOldTunings {this, "UseOldTunings", false}
BooleanProperty m_validateTriplets {this, "ValidateTriplets", true}
BooleanProperty m_useAdaptiveCuts {this, "UseAdaptiveCuts", true}
BooleanProperty m_addTriplets {this, "AddTriplets", false}
FloatProperty m_tau_ratio_cut {this, "tau_ratio_cut", 0.007}
FloatProperty m_tau_ratio_corr {this, "tau_ratio_correction", 0.006}
FloatProperty m_d0_max {this, "d0_max", 3.0}
FloatProperty m_max_eta_add_triplets {this, "add_triplets_eta_cut", 1.5}
FloatProperty m_max_eta_for_seed_split {this, "split_seeds_eta_cut", 0.6}
float m_phiSliceWidth = 0.
std::unique_ptr< GNN_FasTrackConnector > m_connector = nullptr
std::unique_ptr< GNNR3_FasTrackConnector > m_connector = nullptr
std::vector< TrigInDetSiLayer > m_layerGeometry
std::unique_ptr< const TrigFTF_GNN_Geometry > m_geo = nullptr
std::unique_ptr< const TrigFTF_GNNR3_Geometry > m_geo = nullptr
std::vector< std::array< float, 5 > > m_mlLUT

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 38 of file TrigInDetR3TrackSeedingTool.h.

Member Typedef Documentation

◆ GNN_DataStorage

typedef TrigFTF_GNN_DataStorage SeedingToolBase::GNN_DataStorage
protectedinherited

Definition at line 36 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ GNN_Edge

typedef TrigFTF_GNN_Edge SeedingToolBase::GNN_Edge
protectedinherited

Definition at line 37 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ GNN_Node

typedef TrigFTF_GNN_Node SeedingToolBase::GNN_Node
protectedinherited

Definition at line 35 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ GNNR3_DataStorage

typedef TrigFTF_GNNR3_DataStorage SeedingToolBase::GNNR3_DataStorage
protectedinherited

Definition at line 33 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

◆ GNNR3_Edge

typedef TrigFTF_GNNR3_Edge SeedingToolBase::GNNR3_Edge
protectedinherited

Definition at line 34 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

◆ GNNR3_Node

typedef TrigFTF_GNNR3_Node SeedingToolBase::GNNR3_Node
protectedinherited

Definition at line 32 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ TrigInDetR3TrackSeedingTool()

TrigInDetR3TrackSeedingTool::TrigInDetR3TrackSeedingTool ( const std::string & t,
const std::string & n,
const IInterface * p )

Definition at line 27 of file TrigInDetR3TrackSeedingTool.cxx.

29 : SeedingToolBase(t,n,p)
30{
31
32}
SeedingToolBase::SeedingToolBase
SeedingToolBase(const std::string &t, const std::string &n, const IInterface *p)
Definition TrigInDetPattRecoTools/src/SeedingToolBase.h:31

◆ ~TrigInDetR3TrackSeedingTool()

virtual TrigInDetR3TrackSeedingTool::~TrigInDetR3TrackSeedingTool ( )
inlinevirtual

Definition at line 43 of file TrigInDetR3TrackSeedingTool.h.

43{};

Member Function Documentation

◆ buildTheGraph() [1/2]

std::pair< int, int > SeedingToolBase::buildTheGraph ( const IRoiDescriptor & roi,
const std::unique_ptr< GNN_DataStorage > & storage,
std::vector< GNN_Edge > & edgeStorage ) const
protectedinherited

Definition at line 98 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

98 {
99
100
101 struct GBTS_SlidingWindow {
102
103 GBTS_SlidingWindow() : m_first_it(0), m_deltaPhi(0.0), m_has_nodes(false), m_bin(nullptr) {};
104
105 unsigned int m_first_it;// sliding window position
106 float m_deltaPhi; // window half-width;
107 bool m_has_nodes; // active or not
108
109 const TrigFTF_GNN_EtaBin* m_bin;//associated eta bin
110 };
111
112 constexpr float M_2PI = 2.0*M_PI;
113
114 const float cut_dphi_max = m_LRTmode ? 0.07f : 0.012f;
115 const float cut_dcurv_max = m_LRTmode ? 0.015f : 0.001f;
116 const float cut_tau_ratio_max = m_LRTmode ? 0.015f : static_cast<float>(m_tau_ratio_cut);
117 const float min_z0 = m_LRTmode ? -600.0 : roi.zedMinus();
118 const float max_z0 = m_LRTmode ? 600.0 : roi.zedPlus();
119 const float min_deltaPhi = m_LRTmode ? 0.01f : 0.001f;
120 const float tau_ratio_precut = 0.009f;
121
122 const float maxOuterRadius = m_LRTmode ? 1050.0 : 550.0;
123
124 const float cut_zMinU = min_z0 + maxOuterRadius*roi.dzdrMinus();
125 const float cut_zMaxU = max_z0 + maxOuterRadius*roi.dzdrPlus();
126
127 constexpr float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
128
129 float tripletPtMin = 0.8f*m_minPt;//correction due to limited pT resolution
130 const float pt_scale = 900.0f/m_minPt;//to re-scale original tunings done for the 900 MeV pT cut
131
132 float maxCurv = ptCoeff/tripletPtMin;
133
134 float maxKappa_high_eta = m_LRTmode ? 1.0f*maxCurv : std::sqrt(0.8f)*maxCurv;
135 float maxKappa_low_eta = m_LRTmode ? 1.0f*maxCurv : std::sqrt(0.6f)*maxCurv;
136
137 if(!m_useOldTunings && !m_LRTmode) {//new settings for curvature cuts
138 maxKappa_high_eta = 4.75e-4f*pt_scale;
139 maxKappa_low_eta = 3.75e-4f*pt_scale;
140 }
141
142 const float dphi_coeff = m_LRTmode ? 1.0f*maxCurv : 0.68f*maxCurv;
143
144 const float minDeltaRadius = 2.0;
145
146 float deltaPhi0 = 0.5f*m_phiSliceWidth;//the default sliding window along phi
147
148 unsigned int nConnections = 0;
149
150 edgeStorage.reserve(m_nMaxEdges);
151
152 int nEdges = 0;
153
154 float z0_histo_coeff = 16/(max_z0 - min_z0 + 1e-6);//assuming 16-bit z0 bitmask
155
156 for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
157
158 TrigFTF_GNN_EtaBin& B1 = storage->getEtaBin(bg.first);
159
160 if(B1.empty()) continue;
161
162 float rb1 = B1.getMinBinRadius();
163
164 const unsigned int lk1 = B1.m_layerKey;
165
166 const bool isBarrel1 = (lk1 / 10000) == 8;
167
168 //prepare a sliding window for each bin2 in the group
169
170 std::vector<GBTS_SlidingWindow> vSLW;
171
172 vSLW.resize(bg.second.size());//initialization using default ctor
173
174 int win_idx = 0;
175
176 for(const auto& b2_idx : bg.second) { //loop over n2 eta-bins in L2 layers
177
178 const TrigFTF_GNN_EtaBin& B2 = storage->getEtaBin(b2_idx);
179
180 if(B2.empty()) {
181 win_idx++;
182 continue;
183 }
184
185 float rb2 = B2.getMaxBinRadius();
186
187 float deltaPhi = deltaPhi0;//the default
188
189 if(m_useEtaBinning) { //override the default window width
190 float abs_dr = std::fabs(rb2-rb1);
191 if (m_useOldTunings) {
192 deltaPhi = min_deltaPhi + dphi_coeff*abs_dr;
193 }
194 else {
195 if(abs_dr < 60.0) {
196 deltaPhi = 0.002f + 4.33e-4f*pt_scale*abs_dr;
197 } else {
198 deltaPhi = 0.015f + 2.2e-4f*pt_scale*abs_dr;
199 }
200 }
201 }
202
203 vSLW[win_idx].m_bin = &B2;
204 vSLW[win_idx].m_has_nodes = true;
205 vSLW[win_idx].m_deltaPhi = deltaPhi;
206 win_idx++;
207 }
208
209 for(unsigned int n1Idx = 0;n1Idx<B1.m_vn.size();n1Idx++) {//in GBTSv3 the outer loop goes over n1 nodes in the Layer 1 bin
210
211 B1.m_vFirstEdge[n1Idx] = nEdges;//initialization using the top watermark of the edge storage
212
213 unsigned short num_created_edges = 0;//the counter for the incoming graph edges created for n1
214
215 bool is_connected = false;
216
217 std::array<unsigned char, 16> z0_histo = {};
218
219 const std::array<float, 5>& n1pars = B1.m_params[n1Idx];
220
221 float phi1 = n1pars[2];
222 float r1 = n1pars[3];
223 float z1 = n1pars[4];
224
225 for(unsigned int winIdx = 0; winIdx < vSLW.size(); winIdx++) {//the intermediate loop over sliding windows
226
227 GBTS_SlidingWindow& slw = vSLW[winIdx];
228
229 if (!slw.m_has_nodes) continue;
230
231 const TrigFTF_GNN_EtaBin& B2 = *slw.m_bin;
232
233 const unsigned int lk2 = B2.m_layerKey;
234
235 const bool isBarrel2 = (lk2 / 10000) == 8;
236
237 float deltaPhi = slw.m_deltaPhi;
238
239 //sliding window phi1 +/- deltaPhi
240
241 float minPhi = phi1 - deltaPhi;
242 float maxPhi = phi1 + deltaPhi;
243
244 for(unsigned int n2PhiIdx = slw.m_first_it; n2PhiIdx<B2.m_vPhiNodes.size();n2PhiIdx++) {//the inner loop over n2 nodes using sliding window
245
246 float phi2 = B2.m_vPhiNodes[n2PhiIdx].first;
247
248 if(phi2 < minPhi) {
249 slw.m_first_it = n2PhiIdx; //update the window position
250 continue;
251 }
252 if(phi2 > maxPhi) break; //break and go to the next window
253
254 unsigned int n2Idx = B2.m_vPhiNodes[n2PhiIdx].second;
255
256 unsigned short node_info = B2.m_vIsConnected[n2Idx];
257
258 if ((lk1 == 80000) && (node_info == 0) ) continue;//skip isolated nodes as their incoming edges lead to nowhere
259
260 unsigned int n2_first_edge = B2.m_vFirstEdge[n2Idx];
261 unsigned short n2_num_edges = B2.m_vNumEdges[n2Idx];
262 unsigned int n2_last_edge = n2_first_edge + n2_num_edges;
263
264 const std::array<float, 5>& n2pars = B2.m_params[n2Idx];
265
266 float r2 = n2pars[3];
267
268 float dr = r2 - r1;
269
270 if(dr < minDeltaRadius) {
271 continue;
272 }
273
274 float z2 = n2pars[4];
275
276 float dz = z2 - z1;
277 float tau = dz/dr;
278 float ftau = std::fabs(tau);
279 if (ftau > 36.0) {
280 continue;
281 }
282
283 if(ftau < n1pars[0]) continue;
284 if(ftau > n1pars[1]) continue;
285
286 if(ftau < n2pars[0]) continue;
287 if(ftau > n2pars[1]) continue;
288
289 float z0 = z1 - r1*tau;
290
291 if (lk1 == 80000) {//check against non-empty z0 histogram
292
293 if ( !check_z0_bitmask(node_info, z0, min_z0, z0_histo_coeff) ) {
294 continue;
295 }
296 }
297
298 if (m_doubletFilterRZ) {
299
300 if(z0 < min_z0 || z0 > max_z0) continue;
301
302 float zouter = z0 + maxOuterRadius*tau;
303
304 if(zouter < cut_zMinU || zouter > cut_zMaxU) continue;
305 }
306
307 float curv = (phi2-phi1)/dr;
308 float abs_curv = std::abs(curv);
309
310 if(ftau < 4.0) {//eta = 2.1
311 if(abs_curv > maxKappa_low_eta) {
312 continue;
313 }
314 }
315 else {
316 if(abs_curv > maxKappa_high_eta) {
317 continue;
318 }
319 }
320
321 float exp_eta = std::sqrt(1.f+tau*tau) - tau;
322
323 if (m_matchBeforeCreate && (lk1 == 80000 || lk1 == 81000) ) {//match edge candidate against edges incoming to n2
324
325 bool isGood = n2_num_edges <= 2;//we must have enough incoming edges to decide
326
327 if(!isGood) {
328
329 float uat_1 = 1.0f/exp_eta;
330
331 for(unsigned int n2_in_idx = n2_first_edge; n2_in_idx < n2_last_edge; n2_in_idx++) {
332
333 float tau2 = edgeStorage.at(n2_in_idx).m_p[0];
334 float tau_ratio = tau2*uat_1 - 1.0f;
335
336 if(std::fabs(tau_ratio) > tau_ratio_precut){//bad match
337 continue;
338 }
339 isGood = true;//good match found
340 break;
341 }
342 }
343
344 if(!isGood) {//no match found, skip creating [n1 <- n2] edge
345 continue;
346 }
347 }
348
349 float dPhi2 = curv*r2;
350 float dPhi1 = curv*r1;
351
352 if(nEdges < m_nMaxEdges) {
353
354 edgeStorage.emplace_back(B1.m_vn[n1Idx], B2.m_vn[n2Idx], exp_eta, curv, phi1 + dPhi1);
355
356 num_created_edges++;
357
358 int outEdgeIdx = nEdges;
359
360 float uat_2 = 1.f/exp_eta;
361 float Phi2 = phi2 + dPhi2;
362 float curv2 = curv;
363
364 for(unsigned int inEdgeIdx = n2_first_edge; inEdgeIdx < n2_last_edge; inEdgeIdx++) {//looking for neighbours of the new edge
365
366 TrigFTF_GNN_Edge* pS = &(edgeStorage.at(inEdgeIdx));
367
368 if(pS->m_nNei >= N_SEG_CONNS) continue;
369
370 const unsigned int lk3 = m_geo->getTrigFTF_GNN_LayerKeyByIndex(pS->m_n2->m_layer);
371
372 const bool isBarrel3 = (lk3 / 10000) == 8;
373
374 float abs_tau_ratio = std::abs(pS->m_p[0]*uat_2 - 1.0f);
375 float add_tau_ratio_corr = 0;
376
377 if (m_useAdaptiveCuts) {
378
379 if (isBarrel1 && isBarrel2 && isBarrel3) {
380 bool no_gap = ((lk3-lk2) == 1000) && ((lk2-lk1) == 1000);
381 if(!no_gap) {
382 add_tau_ratio_corr = m_tau_ratio_corr;//assume more scattering due to the layer in between
383 }
384 }
385 else {
386 bool mixed_triplet = isBarrel1 && isBarrel2 && !isBarrel3;
387 if (mixed_triplet) {
388 add_tau_ratio_corr = m_tau_ratio_corr;
389 }
390 }
391 }
392
393 if(abs_tau_ratio > cut_tau_ratio_max + add_tau_ratio_corr){//bad match
394 continue;
395 }
396
397 float dPhi = Phi2 - pS->m_p[2];
398
399 if(dPhi<-M_PI) dPhi += M_2PI;
400 else if(dPhi>M_PI) dPhi -= M_2PI;
401
402 if(std::abs(dPhi) > cut_dphi_max) {
403 continue;
404 }
405
406 float dcurv = curv2 - pS->m_p[1];
407
408 if(dcurv < -cut_dcurv_max || dcurv > cut_dcurv_max) {
409 continue;
410 }
411
412 //final check: cuts on pT and d0
413
414 if (isBarrel1 && isBarrel2 && isBarrel3) {//Pixel barrel
415
416 std::array<const GNN_Node*, 3> sps = {B1.m_vn[n1Idx], B2.m_vn[n2Idx], pS->m_n2};
417
418 if (!validate_triplet(sps, tripletPtMin, abs_tau_ratio, cut_tau_ratio_max) ) continue;
419
420 }
421
422 pS->m_vNei[pS->m_nNei++] = outEdgeIdx;
423
424 is_connected = true;//there is at least one good match
425
426 //edge confirmed - update z0 histogram
427
428 int z0_bin_index = z0_histo_coeff*(z0 - min_z0);
429
430 ++z0_histo[z0_bin_index];
431
432 nConnections++;
433
434 }
435 nEdges++;
436 }
437 } //loop over n2 (outer) nodes inside a sliding window on n2 bin
438 } //loop over sliding windows associated with n2 bins
439
440 //updating the n1 node attributes
441
442 B1.m_vNumEdges[n1Idx] = num_created_edges;
443
444 if (is_connected) {
445
446 unsigned short z0_bitmask = 0x0;
447
448 for(unsigned int bIdx = 0; bIdx < 16; bIdx++) {
449
450 if (z0_histo[bIdx] == 0) continue;
451
452 z0_bitmask |= (1 << bIdx);
453 }
454
455 B1.m_vIsConnected[n1Idx] = z0_bitmask;//non-zero mask indicates that there is at least one connected edge
456 }
457
458 } //loop over n1 (inner) nodes
459 } //loop over bin groups: a single n1 bin and multiple n2 bins
460
461 if(nEdges >= m_nMaxEdges) {
462 ATH_MSG_WARNING("Maximum number of graph edges exceeded - possible efficiency loss "<< nEdges);
463 }
464
465 return std::make_pair(nEdges, nConnections);
466}
M_PI
#define M_PI
Definition ActiveFraction.h:14
deltaPhi
Scalar deltaPhi(const MatrixBase< Derived > &vec) const
Definition AmgMatrixBasePlugin.h:112
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x,...)
Definition AthMsgStreamMacros.h:46
M_2PI
#define M_2PI
Definition CaloGpuGeneral_fnc.cxx:11
N_SEG_CONNS
#define N_SEG_CONNS
Definition GNN_DataStorage.h:14
IRoiDescriptor::zedPlus
virtual double zedPlus() const =0
the zed and eta values at the most forward and most rear ends of the RoI
IRoiDescriptor::dzdrMinus
virtual double dzdrMinus() const =0
return the gradients
IRoiDescriptor::zedMinus
virtual double zedMinus() const =0
IRoiDescriptor::dzdrPlus
virtual double dzdrPlus() const =0
SeedingToolBase::check_z0_bitmask
bool check_z0_bitmask(const unsigned short &, const float &, const float &, const float &) const
Definition TrigInDetPattRecoTools/src/SeedingToolBase.cxx:811
SeedingToolBase::m_geo
std::unique_ptr< const TrigFTF_GNN_Geometry > m_geo
Definition TrigInDetPattRecoTools/src/SeedingToolBase.h:95
SeedingToolBase::validate_triplet
bool validate_triplet(std::array< const GNN_Node *, 3 > &, const float min_pt, const float tau_ratio, const float tau_ratio_cut) const
Definition TrigInDetPattRecoTools/src/SeedingToolBase.cxx:892
TrigFTF_GNN_Edge::m_vNei
unsigned int m_vNei[N_SEG_CONNS]
Definition GNN_DataStorage.h:137
TrigFTF_GNN_Edge::m_nNei
unsigned char m_nNei
Definition GNN_DataStorage.h:134
TrigFTF_GNN_Edge::m_p
float m_p[3]
Definition GNN_DataStorage.h:135
TrigFTF_GNN_Edge::m_n2
const TrigFTF_GNN_Node * m_n2
Definition GNN_DataStorage.h:130
TrigFTF_GNN_EtaBin::m_vn
std::vector< const TrigFTF_GNN_Node * > m_vn
Definition GNN_DataStorage.h:71
TrigFTF_GNN_EtaBin::getMinBinRadius
float getMinBinRadius() const
Definition GNN_DataStorage.h:63
TrigFTF_GNN_EtaBin::m_vIsConnected
std::vector< unsigned short > m_vIsConnected
Definition GNN_DataStorage.h:77
TrigFTF_GNN_EtaBin::getMaxBinRadius
float getMaxBinRadius() const
Definition GNN_DataStorage.h:67
TrigFTF_GNN_EtaBin::m_vFirstEdge
std::vector< unsigned int > m_vFirstEdge
Definition GNN_DataStorage.h:75
TrigFTF_GNN_EtaBin::m_vPhiNodes
std::vector< std::pair< float, unsigned int > > m_vPhiNodes
Definition GNN_DataStorage.h:72
TrigFTF_GNN_EtaBin::empty
bool empty() const
Definition GNN_DataStorage.h:57
TrigFTF_GNN_EtaBin::m_params
std::vector< std::array< float, 5 > > m_params
Definition GNN_DataStorage.h:74
TrigFTF_GNN_EtaBin::m_layerKey
unsigned int m_layerKey
Definition GNN_DataStorage.h:79
TrigFTF_GNN_EtaBin::m_vNumEdges
std::vector< unsigned short > m_vNumEdges
Definition GNN_DataStorage.h:76
TauClusterVars::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, float &out)
Definition ConstituentLoaderTauCluster.cxx:119
xAOD::EgammaParameters::deltaPhi0
@ deltaPhi0
difference between the cluster phi (presampler) and the eta of the track extrapolated to the presampl...
Definition EgammaEnums.h:194
TrigFTF_GNN_Node::m_layer
unsigned short m_layer
Definition GNN_DataStorage.h:35

◆ buildTheGraph() [2/2]

std::pair< int, int > SeedingToolBase::buildTheGraph ( const IRoiDescriptor & roi,
const std::unique_ptr< GNNR3_DataStorage > & storage,
std::vector< GNNR3_Edge > & edgeStorage ) const
protectedinherited

Definition at line 71 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.cxx.

71 {
72
73 const float M_2PI = 2.0*M_PI;
74
75 const float cut_dphi_max = m_LRTmode ? 0.07 : 0.012;
76 const float cut_dcurv_max = m_LRTmode ? 0.015 : 0.001;
77 const float cut_tau_ratio_max = m_LRTmode ? 0.015 : 0.007;
78 const float min_z0 = m_LRTmode ? -600.0 : roi.zedMinus();
79 const float max_z0 = m_LRTmode ? 600.0 : roi.zedPlus();
80 const float min_deltaPhi = m_LRTmode ? 0.01f : 0.001f;
81
82 const float maxOuterRadius = m_LRTmode ? 1050.0 : 550.0;
83
84 const float cut_zMinU = min_z0 + maxOuterRadius*roi.dzdrMinus();
85 const float cut_zMaxU = max_z0 + maxOuterRadius*roi.dzdrPlus();
86
87 const float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
88
89 float tripletPtMin = 0.8*m_minPt;//correction due to limited pT resolution
90
91 float maxCurv = ptCoeff/tripletPtMin;
92
93 const float maxKappa_high_eta = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.8)*maxCurv;
94 const float maxKappa_low_eta = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.6)*maxCurv;
95 const float dphi_coeff = m_LRTmode ? 1.0*maxCurv : 0.68*maxCurv;
96
97 const float minDeltaRadius = 2.0;
98
99 float deltaPhi = 0.5f*m_phiSliceWidth;//the default sliding window along phi
100
101 unsigned int nConnections = 0;
102
103 edgeStorage.reserve(m_nMaxEdges);
104
105 int nEdges = 0;
106
107 for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
108
109 TrigFTF_GNNR3_EtaBin& B1 = storage->getEtaBin(bg.first);
110
111 if(B1.empty()) continue;
112
113 float rb1 = B1.getMinBinRadius();
114
115 for(const auto& b2_idx : bg.second) {
116
117 const TrigFTF_GNNR3_EtaBin& B2 = storage->getEtaBin(b2_idx);
118
119 if(B2.empty()) continue;
120
121 float rb2 = B2.getMaxBinRadius();
122
123 if(m_useEtaBinning) {
124 deltaPhi = min_deltaPhi + dphi_coeff*std::fabs(rb2-rb1);
125 }
126
127 unsigned int first_it = 0;
128
129 for(unsigned int n1Idx = 0;n1Idx<B1.m_vn.size();n1Idx++) {//loop over nodes in Layer 1
130
131 std::vector<unsigned int>& v1In = B1.m_in[n1Idx];
132
133 if(v1In.size() >= MAX_SEG_PER_NODE) continue;
134
135 const std::array<float, 5>& n1pars = B1.m_params[n1Idx];
136
137 float phi1 = n1pars[2];
138 float r1 = n1pars[3];
139 float z1 = n1pars[4];
140
141 //sliding window phi1 +/- deltaPhi
142
143 float minPhi = phi1 - deltaPhi;
144 float maxPhi = phi1 + deltaPhi;
145
146 for(unsigned int n2PhiIdx = first_it; n2PhiIdx<B2.m_vPhiNodes.size();n2PhiIdx++) {//sliding window over nodes in Layer 2
147
148 float phi2 = B2.m_vPhiNodes[n2PhiIdx].first;
149
150 if(phi2 < minPhi) {
151 first_it = n2PhiIdx;
152 continue;
153 }
154 if(phi2 > maxPhi) break;
155
156 unsigned int n2Idx = B2.m_vPhiNodes[n2PhiIdx].second;
157
158 const std::vector<unsigned int>& v2In = B2.m_in[n2Idx];
159
160 if(v2In.size() >= MAX_SEG_PER_NODE) continue;
161
162 const std::array<float, 5>& n2pars = B2.m_params[n2Idx];
163
164 float r2 = n2pars[3];
165
166 float dr = r2 - r1;
167
168 if(dr < minDeltaRadius) {
169 continue;
170 }
171
172 float z2 = n2pars[4];
173
174 float dz = z2 - z1;
175 float tau = dz/dr;
176 float ftau = std::fabs(tau);
177 if (ftau > 36.0) {
178 continue;
179 }
180
181 if(ftau < n1pars[0]) continue;
182 if(ftau > n1pars[1]) continue;
183
184 if(ftau < n2pars[0]) continue;
185 if(ftau > n2pars[1]) continue;
186
187 if (m_doubletFilterRZ) {
188
189 float z0 = z1 - r1*tau;
190
191 if(z0 < min_z0 || z0 > max_z0) continue;
192
193 float zouter = z0 + maxOuterRadius*tau;
194
195 if(zouter < cut_zMinU || zouter > cut_zMaxU) continue;
196 }
197
198 float curv = (phi2-phi1)/dr;
199 float abs_curv = std::abs(curv);
200
201 if(ftau < 4.0) {//eta = 2.1
202 if(abs_curv > maxKappa_low_eta) {
203 continue;
204 }
205 }
206 else {
207 if(abs_curv > maxKappa_high_eta) {
208 continue;
209 }
210 }
211
212 float exp_eta = std::sqrt(1+tau*tau)-tau;
213
214 if (m_matchBeforeCreate) {//match edge candidate against edges incoming to n2
215
216 bool isGood = v2In.size() <= 2;//we must have enough incoming edges to decide
217
218 if(!isGood) {
219
220 float uat_1 = 1.0f/exp_eta;
221
222 for(const auto& n2_in_idx : v2In) {
223
224 float tau2 = edgeStorage.at(n2_in_idx).m_p[0];
225 float tau_ratio = tau2*uat_1 - 1.0f;
226
227 if(std::fabs(tau_ratio) > cut_tau_ratio_max){//bad match
228 continue;
229 }
230 isGood = true;//good match found
231 break;
232 }
233 }
234
235 if(!isGood) {//no match found, skip creating [n1 <- n2] edge
236 continue;
237 }
238 }
239
240 float dPhi2 = curv*r2;
241 float dPhi1 = curv*r1;
242
243 if(nEdges < m_nMaxEdges) {
244
245 edgeStorage.emplace_back(B1.m_vn[n1Idx], B2.m_vn[n2Idx], exp_eta, curv, phi1 + dPhi1);
246
247 if(v1In.size() < MAX_SEG_PER_NODE) v1In.push_back(nEdges);
248
249 int outEdgeIdx = nEdges;
250
251 float uat_2 = 1/exp_eta;
252 float Phi2 = phi2 + dPhi2;
253 float curv2 = curv;
254
255 for(const auto& inEdgeIdx : v2In) {//looking for neighbours of the new edge
256
257 TrigFTF_GNNR3_Edge* pS = &(edgeStorage.at(inEdgeIdx));
258
259 if(pS->m_nNei >= N_SEG_CONNS) continue;
260
261 float tau_ratio = pS->m_p[0]*uat_2 - 1.0f;
262
263 if(std::abs(tau_ratio) > cut_tau_ratio_max){//bad match
264 continue;
265 }
266
267 float dPhi = Phi2 - pS->m_p[2];
268
269 if(dPhi<-M_PI) dPhi += M_2PI;
270 else if(dPhi>M_PI) dPhi -= M_2PI;
271
272 if(dPhi < -cut_dphi_max || dPhi > cut_dphi_max) {
273 continue;
274 }
275
276 float dcurv = curv2 - pS->m_p[1];
277
278 if(dcurv < -cut_dcurv_max || dcurv > cut_dcurv_max) {
279 continue;
280 }
281
282 pS->m_vNei[pS->m_nNei++] = outEdgeIdx;
283
284 nConnections++;
285
286 }
287 nEdges++;
288 }
289 } //loop over n2 (outer) nodes
290 } //loop over n1 (inner) nodes
291 } //loop over bins in Layer 2
292 } //loop over bin groups
293
294 return std::make_pair(nEdges, nConnections);
295}
MAX_SEG_PER_NODE
#define MAX_SEG_PER_NODE
Definition GNNR3_DataStorage.h:13
TrigFTF_GNNR3_Edge::m_p
float m_p[3]
Definition GNNR3_DataStorage.h:131
TrigFTF_GNNR3_Edge::m_vNei
unsigned int m_vNei[N_SEG_CONNS]
Definition GNNR3_DataStorage.h:133
TrigFTF_GNNR3_Edge::m_nNei
unsigned char m_nNei
Definition GNNR3_DataStorage.h:130
TrigFTF_GNNR3_EtaBin::getMaxBinRadius
float getMaxBinRadius() const
Definition GNNR3_DataStorage.h:66
TrigFTF_GNNR3_EtaBin::m_params
std::vector< std::array< float, 5 > > m_params
Definition GNNR3_DataStorage.h:73
TrigFTF_GNNR3_EtaBin::getMinBinRadius
float getMinBinRadius() const
Definition GNNR3_DataStorage.h:62
TrigFTF_GNNR3_EtaBin::empty
bool empty() const
Definition GNNR3_DataStorage.h:56
TrigFTF_GNNR3_EtaBin::m_vn
std::vector< const TrigFTF_GNNR3_Node * > m_vn
Definition GNNR3_DataStorage.h:70
TrigFTF_GNNR3_EtaBin::m_vPhiNodes
std::vector< std::pair< float, unsigned int > > m_vPhiNodes
Definition GNNR3_DataStorage.h:71
TrigFTF_GNNR3_EtaBin::m_in
std::vector< std::vector< unsigned int > > m_in
Definition GNNR3_DataStorage.h:72

◆ check_z0_bitmask()

bool SeedingToolBase::check_z0_bitmask ( const unsigned short & z0_bitmask,
const float & z0,
const float & min_z0,
const float & z0_histo_coeff ) const
protectedinherited

Definition at line 811 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

811 {
812
813 if (z0_bitmask == 0) return true;
814
815 float dz = z0 - min_z0;
816 int z0_bin_index = z0_histo_coeff*dz;
817
818 if ((z0_bitmask >> z0_bin_index) & 1) return true;
819
820 //check adjacent bins as well
821
822 const float z0_resolution = 2.5;
823
824 float dzm = dz - z0_resolution;
825
826 int next_bin = z0_histo_coeff*dzm;
827
828 if (next_bin >= 0 && next_bin != z0_bin_index) {
829
830 if ((z0_bitmask >> next_bin) & 1) return true;
831
832 }
833
834 float dzp = dz + z0_resolution;
835
836 next_bin = z0_histo_coeff*dzp;
837
838 if (next_bin < 16 && next_bin != z0_bin_index) {
839
840 if ((z0_bitmask >> next_bin) & 1) return true;
841
842 }
843
844 return false;
845}

◆ createGraphNodes()

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
protected

Definition at line 635 of file TrigInDetR3TrackSeedingTool.cxx.

635 {
636
637 tmpColl.resize(spColl->size(), GNNR3_Node(layer));//all nodes belong to the same layer
638
639 int idx = 0;
640 int init_size = vSP.size();
641 for(const auto sp : *spColl) {
642 const auto& pos = sp->globalPosition();
643 vSP.emplace_back(sp);
644 float xs = pos.x() - shift_x;
645 float ys = pos.y() - shift_y;
646 float zs = pos.z();
647 tmpColl[idx].m_x = xs;
648 tmpColl[idx].m_y = ys;
649 tmpColl[idx].m_z = zs;
650 tmpColl[idx].m_r = std::sqrt(xs*xs + ys*ys);
651 tmpColl[idx].m_phi = std::atan2(ys,xs);
652 tmpColl[idx].m_idx = init_size + idx;
653
654 const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
655 if(pCL != nullptr){
656 tmpColl[idx].m_pcw = pCL->width().z();
657 }
658
659 idx++;
660 }
661}
sp
static Double_t sp
Definition LArPhysWaveHECTool.cxx:37
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
InDet::SiCluster::width
const InDet::SiWidth & width() const
return width class reference
InDet::SiWidth::z
double z() const
Definition SiWidth.h:131
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition LArNewCalib_DelayDump_OFC_Cali.py:69

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl,
const SG::VarHandleKeyType &  )
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ DeclareInterfaceID()

ITrigInDetTrackSeedingTool::DeclareInterfaceID ( ITrigInDetTrackSeedingTool ,
1 ,
0  )
inherited

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ estimate_curvature()

float SeedingToolBase::estimate_curvature ( const std::array< const GNN_Node *, 3 > & sps) const
protectedinherited

Definition at line 848 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

848 {
849
850 //conformal mapping with the center at the last spacepoint
851
852 float u[2], v[2];
853
854 float x0 = sps[2]->x();
855 float y0 = sps[2]->y();
856
857 float r0 = sps[2]->r();
858
859 float cosA = x0/r0;
860
861 float sinA = y0/r0;
862
863
864 for(unsigned int k=0;k<2;k++) {
865
866 float dx = sps[k]->x() - x0;
867
868 float dy = sps[k]->y() - y0;
869
870 float r2_inv = 1.0/(dx*dx+dy*dy);
871
872 float xn = dx*cosA + dy*sinA;
873
874 float yn =-dx*sinA + dy*cosA;
875
876 u[k] = xn*r2_inv;
877 v[k] = yn*r2_inv;
878 }
879
880 float du = u[0] - u[1];
881
882 if(du==0.0) return 0.0;
883
884 float A = (v[0] - v[1])/du;
885
886 float B = v[1] - A*u[1];
887
888 return 1000.0*B/std::sqrt(1 + A*A); //inverse meters
889
890}
TRT_PAI_physicsConstants::r0
const double r0
electron radius{cm}
Definition TRT_PAI_physicsConstants.h:22
Trk::u
@ u
Enums for curvilinear frames.
Definition ParamDefs.h:77
dqt_zlumi_alleff_HIST.A
A
Definition dqt_zlumi_alleff_HIST.py:110
dqt_zlumi_alleff_HIST.B
B
Definition dqt_zlumi_alleff_HIST.py:110

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ extractSeedsFromTheGraph()

void SeedingToolBase::extractSeedsFromTheGraph ( int maxLevel,
int nEdges,
int nHits,
std::vector< GNN_Edge > & edgeStorage,
std::vector< std::pair< float, std::vector< unsigned int > > > & vOutputSeeds ) const
protectedinherited

Definition at line 536 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

536 {
537
538 const float edge_mask_min_eta = 1.5;
539 const float hit_share_threshold = 0.49;
540 const float max_inv_rad_diff = 0.7e-2;//in inverse meters
541
542 int minLevel = 3;//a triplet + 1 confirmation
543
544 if(m_LRTmode) {
545 minLevel = 2;//a triplet + no confirmation
546 }
547
548 if(maxLevel < minLevel) return;
549
550 std::vector<GNN_Edge*> vChainHeads;
551
552 vChainHeads.reserve(nEdges/2);
553
554 for(int edgeIndex = 0; edgeIndex < nEdges; edgeIndex++) {
555
556 GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
557
558 if (m_LRTmode || !m_addTriplets) {
559 if(pS->m_level < minLevel) continue;
560 }
561 else { //eta-dependent cut
562 float edge_eta = std::abs(-std::log(pS->m_p[0]));
563
564 if (edge_eta > m_max_eta_add_triplets) {
565 if(pS->m_level < minLevel) continue;
566 }
567 else {
568 if(pS->m_level < minLevel - 1) continue;
569 }
570 }
571
572 vChainHeads.push_back(pS);
573 }
574
575 if(vChainHeads.empty()) return;
576
577 std::sort(vChainHeads.begin(), vChainHeads.end(), GNN_Edge::CompareLevel());
578
579 //backtracking
580
581 std::vector<std::tuple<float, int, std::vector<const GNN_Node*>, int > > vSeedCandidates;
582
583 vSeedCandidates.reserve(vChainHeads.size());
584
585 std::vector<std::pair<float, unsigned int> > vArgSort;
586
587 vArgSort.reserve(vChainHeads.size());
588
589 unsigned int seed_counter = 0;
590
591 auto tFilter = std::make_unique<TrigFTF_GNN_TrackingFilter>(m_layerGeometry, edgeStorage);
592
593 for(auto pS : vChainHeads) {
594
595 if(pS->m_level == -1) continue;
596
597 TrigFTF_GNN_EdgeState rs(false);
598
599 tFilter->followTrack(pS, rs);
600
601 if(!rs.m_initialized) {
602 continue;
603 }
604
605 float seed_eta = std::abs(-std::log(pS->m_p[0]));
606
607 int chain_length = static_cast<int>(rs.m_vs.size());
608
609 if (m_LRTmode || !m_addTriplets) {
610 if(chain_length < minLevel) continue;
611 }
612 else {
613 if (seed_eta > m_max_eta_add_triplets) {
614 if(chain_length < minLevel) continue;
615 }
616 else {
617 if(chain_length < minLevel - 1) continue;
618 }
619 }
620
621 std::vector<const GNN_Node*> vN;
622
623 for(std::vector<GNN_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
624
625 if (seed_eta > edge_mask_min_eta) {
626 (*sIt)->m_level = -1;//mark as collected
627 }
628
629 if(sIt == rs.m_vs.rbegin()) {
630 vN.push_back((*sIt)->m_n1);
631 }
632
633 vN.push_back((*sIt)->m_n2);
634
635 }
636
637 if(vN.size()<3) continue; //a triplet are accepted if it makes upto this point
638
639 unsigned int orig_seed_size = vN.size();
640
641 float orig_seed_quality = -rs.m_J/orig_seed_size;
642
643 int seed_split_flag = (seed_eta < m_max_eta_for_seed_split) && (orig_seed_size > 3) && (orig_seed_size <= 5) ? 1 : 0;
644
645 if (seed_split_flag) {//split the seed by dropping spacepoints
646
647 std::array< std::array<const GNN_Node*, 3>, 3> triplets;//2 "drop-outs" and the original seed candidate
648
649 std::array<float, 3> inv_rads;//triplet parameter estimate
650
651 triplets[0] = {vN[0], vN[orig_seed_size/2], vN[orig_seed_size-1]};
652
653 std::vector<const GNN_Node*> drop_out1 = {vN.begin()+1, vN.end()}; //all but the first one
654
655 triplets[1] = {drop_out1[0], drop_out1[(orig_seed_size-1)/2], drop_out1[orig_seed_size-2]};
656
657 std::vector<const GNN_Node*> drop_out2;
658
659 drop_out2.reserve(orig_seed_size-1);
660
661 for(unsigned int k = 0; k < orig_seed_size; k++) {
662
663 if (k == orig_seed_size/2) continue;//drop the middle SP in the original seed
664
665 drop_out2.emplace_back(vN[k]);
666 }
667
668 triplets[2] = {drop_out2[0], drop_out2[(orig_seed_size-1)/2], drop_out2[orig_seed_size-2]};
669
670 for (unsigned int k = 0; k < inv_rads.size(); k++) {
671
672 inv_rads[k] = estimate_curvature(triplets[k]);
673
674 }
675
676 float diffs[3] = {std::abs(inv_rads[1] - inv_rads[0]), std::abs(inv_rads[2] - inv_rads[0]), std::abs(inv_rads[2] - inv_rads[1])};
677
678 bool confirmed = diffs[0] < max_inv_rad_diff && diffs[1] < max_inv_rad_diff && diffs[2] < max_inv_rad_diff;
679
680 if (confirmed) {
681 seed_split_flag = 0;//reset the flag
682 }
683
684 }
685
686 vSeedCandidates.emplace_back(orig_seed_quality, 0, vN, seed_split_flag);
687
688 vArgSort.emplace_back(orig_seed_quality, seed_counter);
689
690 ++seed_counter;
691
692 }
693
694 //clone removal code goes below ...
695
696 std::sort(vArgSort.begin(), vArgSort.end());
697
698 std::vector<int> H2T(nHits + 1, 0);//hit to track associations
699
700 int trackId = 0;
701
702
703 for(const auto& ags : vArgSort) {
704
705 const auto& seed = vSeedCandidates[ags.second];
706
707 trackId++;
708
709 for(const auto& h : std::get<2>(seed) ) {//loop over spacepoints indices
710
711 unsigned int hit_id = h->sp_idx() + 1;
712
713 int tid = H2T[hit_id];
714
715 if(tid == 0 || tid > trackId) {//unused hit or used by a lesser track
716
717 H2T[hit_id] = trackId;//overwrite
718
719 }
720 }
721 }
722
723 unsigned int trackIdx = 0;
724
725 for(const auto& ags : vArgSort) {
726
727 const auto& seed = std::get<2>(vSeedCandidates[ags.second]);
728
729 int nTotal = seed.size();
730
731 int nOther = 0;
732
733 int trackId = trackIdx + 1;
734
735 ++trackIdx;
736
737 for(const auto& h : seed ) {
738
739 unsigned int hit_id = h->sp_idx() + 1;
740
741 int tid = H2T[hit_id];
742
743 if(tid != trackId) {//taken by a better candidate
744 nOther++;
745 }
746 }
747
748 if (nOther > hit_share_threshold*nTotal) {
749 std::get<1>(vSeedCandidates[ags.second]) = -1;//reject
750 }
751
752 }
753
754 vOutputSeeds.reserve(vSeedCandidates.size());
755
756 //drop the clones and split seeds if need be
757
758 for(const auto& ags : vArgSort) {
759
760 const auto& seed = vSeedCandidates[ags.second];
761
762 if (std::get<1>(seed) != 0) continue;//identified as a clone of a better candidate
763
764 const auto& vN = std::get<2>(seed);
765
766 if (std::get<3>(seed) == 0) {
767
768 //add seed to output
769
770 std::vector<unsigned int> vSpIdx;
771
772 vSpIdx.resize(vN.size());
773
774 for(unsigned int k = 0; k < vSpIdx.size(); k++) {
775 vSpIdx[k] = vN[k]->sp_idx();
776 }
777
778 vOutputSeeds.emplace_back(std::get<0>(seed), vSpIdx);
779
780 continue;
781
782 }
783
784 //seed split into "drop-out" seeds
785
786 unsigned int seedSize = vN.size();
787
788 std::array<std::size_t, 2> indices2drop = {0, seedSize / 2ul};//the first and the middle
789
790 for(const auto& skipIdx : indices2drop) {
791
792 std::vector<unsigned int> new_seed;
793
794 new_seed.reserve(seedSize-1);
795
796 for (unsigned int k = 0; k < seedSize; k++) {
797
798 if (k == skipIdx) continue;
799
800 new_seed.emplace_back(vN[k]->sp_idx());
801 }
802
803 vOutputSeeds.emplace_back(std::get<0>(seed), new_seed);
804
805 }
806
807 }
808
809}
rs
static Double_t rs
Definition LArPhysWaveHECTool.cxx:37
nHits
static const uint32_t nHits
Definition PixelByteStreamModuleMask.h:55
SeedingToolBase::m_layerGeometry
std::vector< TrigInDetSiLayer > m_layerGeometry
Definition TrigInDetPattRecoTools/src/SeedingToolBase.h:94
SeedingToolBase::estimate_curvature
float estimate_curvature(const std::array< const GNN_Node *, 3 > &) const
Definition TrigInDetPattRecoTools/src/SeedingToolBase.cxx:848
Generate_dsid_ranseed.seed
seed
Definition Generate_dsid_ranseed.py:10
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition DVL_algorithms.h:554
TrigFTF_GNN_Edge::CompareLevel
Definition GNN_DataStorage.h:113

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ finalize()

StatusCode TrigInDetR3TrackSeedingTool::finalize ( )
overridevirtual

Reimplemented from SeedingToolBase.

Definition at line 70 of file TrigInDetR3TrackSeedingTool.cxx.

70 {
71 return SeedingToolBase::finalize();
72}

◆ findSeeds()

TrigInDetTrackSeedingResult TrigInDetR3TrackSeedingTool::findSeeds ( const IRoiDescriptor & internalRoI,
std::vector< TrigInDetTracklet > & output,
const EventContext & ctx ) const
finaloverridevirtual

Implements ITrigInDetTrackSeedingTool.

Definition at line 75 of file TrigInDetR3TrackSeedingTool.cxx.

75 {
76
77 TrigInDetTrackSeedingResult seedStats;
78
79 output.clear();
80
81 SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
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
98 SG::ReadHandle<SpacePointContainer> sctHandle(m_sctSpacePointsContainerKey, ctx);
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
128 SG::ReadHandle<SpacePointContainer> pixHandle(m_pixelSpacePointsContainerKey, ctx);
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 //Local variable tFilter uses 320048 bytes of stack space
249 //coverity[STACK_USE]
250 TrigFTF_GNNR3_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
251
252 output.reserve(vSeeds.size());
253
254 for(auto pS : vSeeds) {
255
256 if(pS->m_level == -1) continue;
257
258 TrigFTF_GNNR3_EdgeState rs(false);
259
260 tFilter.followTrack(pS, rs);
261
262 if(!rs.m_initialized) {
263 continue;
264 }
265
266 if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
267
268 std::vector<const GNNR3_Node*> vN;
269
270 for(std::vector<GNNR3_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
271
272 (*sIt)->m_level = -1;//mark as collected
273
274 if(sIt == rs.m_vs.rbegin()) {
275 vN.push_back((*sIt)->m_n1);
276 }
277 vN.push_back((*sIt)->m_n2);
278 }
279
280 if(vN.size()<3) continue;
281
282 unsigned int lastIdx = output.size();
283 output.emplace_back(rs.m_J);
284
285 for(const auto& n : vN) {
286 output[lastIdx].addSpacePoint(vSP[n->m_idx]);
287 }
288 }
289
290 ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
291 }
292#if 0
293 else {//GPU-accelerated graph building
294
295
296 //1. data export
297
298 std::vector<const Trk::SpacePoint*> vSP;
299 std::vector<short> vL;
300
301 vSP.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
302 vL.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
303
304 std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER> dataBuffer = std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER>(new TrigAccel::DATA_EXPORT_BUFFER(5000));
305
306 size_t dataTypeSize = sizeof(TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA);
307 const size_t bufferOffset = 256;
308 size_t totalSize = bufferOffset+dataTypeSize;//make room for the header
309 if(!dataBuffer->fit(totalSize)) dataBuffer->reallocate(totalSize);
310
311 TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA* pJobData = reinterpret_cast<TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA*>(dataBuffer->m_buffer + bufferOffset);
312
313 unsigned int spIdx = 0;
314 int sp_offset = 0;
315 int nLayers = 0;
316 int MaxEtaBin = 0;
317 int nEtaBins = 0;
318
319 for(const auto& lColl : detIdMap) {
320
321 short layerIndex = lColl.first;
322
323 const TrigFTF_GNNR3_Layer* pL = m_geo->getTrigFTF_GNNR3_LayerByIndex(layerIndex);
324
325 int layerKey = pL->m_layer.m_subdet;
326
327 bool isPixel = layerKey > 20000;
328 bool isBarrel = (pL->m_layer.m_type == 0);
329
330 auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
331
332 pJobData->m_layerIdx[nLayers] = layerIndex;
333
334 pJobData->m_layerInfo[4*nLayers ] = spIdx;//layerInfo.x
335 pJobData->m_layerInfo[4*nLayers + 2] = pL->num_bins();//layerInfo.z
336 pJobData->m_layerInfo[4*nLayers + 3] = pL->m_bins[0];//layerInfo.w
337
338 pJobData->m_layerGeo[2*nLayers ] = pL->m_minEta;//layerGeo.x
339 pJobData->m_layerGeo[2*nLayers + 1] = pL->m_etaBin;//layerGeo.y
340
341 nEtaBins += pL->m_bins.size();
342
343 for(auto b : pL->m_bins) {
344 if(b > MaxEtaBin) MaxEtaBin = b;
345 }
346
347 for(const auto& idx : lColl.second) {
348
349 auto input_coll = pCont->indexFindPtr(idx);
350
351 if(input_coll == nullptr) continue;
352
353 for(const auto sp : *input_coll) {
354
355 float cw = -1.0;
356
357 const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
358 if(pCL != nullptr) {
359 cw = pCL->width().widthPhiRZ().y();
360 if(!isBarrel && m_useML) {
361 if(cw > 0.2) continue;
362 cw = -1.0;//set it to -1 so that it can be skipped later in the ML code on GPU
363 }
364 }
365
366 vSP.emplace_back(sp);
367 vL.emplace_back(layerIndex);
368
369 const auto& p = sp->globalPosition();
370
371 float params[4] = {(float)(p.x() - shift_x), float(p.y() - shift_y), (float)(p.z()), cw};
372
373 memcpy(&pJobData->m_params[sp_offset], &params[0], sizeof(params));
374
375 sp_offset += 4;
376 spIdx++;
377 if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
378 }
379 if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
380 }
381
382 pJobData->m_layerInfo[4*nLayers + 1] = spIdx;//layerInfo.y
383
384 if (isPixel) nPixels += spIdx - pJobData->m_layerInfo[4*nLayers];
385 else nStrips += spIdx - pJobData->m_layerInfo[4*nLayers];
386
387 nLayers++;
388 }
389
390 pJobData->m_nSpacepoints = spIdx;
391 pJobData->m_nLayers = nLayers;
392 pJobData->m_nEtaBins = nEtaBins;
393 pJobData->m_maxEtaBin = MaxEtaBin;
394 pJobData->m_nMaxEdges = m_nMaxEdges;
395
396 //load bin pairs
397
398 int pairIdx = 0;
399
400 for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
401
402 int bin1_idx = bg.first;
403
404 for(const auto& bin2_idx : bg.second) {
405 pJobData->m_bin_pairs[2*pairIdx ] = bin1_idx;
406 pJobData->m_bin_pairs[2*pairIdx+1] = bin2_idx;
407 pairIdx++;
408 }
409 }
410
411 pJobData->m_nBinPairs = pairIdx;
412
413 //add algorithm parameters
414
415 const float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
416
417 float tripletPtMin = 0.8*m_minPt;//correction due to limited pT resolution
418
419 float maxCurv = ptCoeff/tripletPtMin;
420
421 const float min_deltaPhi = 0.001;
422 const float dphi_coeff = 0.68*maxCurv;
423 const float cut_dphi_max = m_LRTmode ? 0.07 : 0.012;
424 const float cut_dcurv_max = m_LRTmode ? 0.015 : 0.001;
425 const float cut_tau_ratio_max = m_LRTmode ? 0.015 : 0.007;
426 const float min_z0 = m_LRTmode ? -600.0 : internalRoI.zedMinus();
427 const float max_z0 = m_LRTmode ? 600.0 : internalRoI.zedPlus();
428
429 const float maxOuterRadius = m_LRTmode ? 1050.0 : 550.0;
430 const float minDeltaRadius = 2.0;
431
432 const float cut_zMinU = min_z0 + maxOuterRadius*internalRoI.dzdrMinus();
433 const float cut_zMaxU = max_z0 + maxOuterRadius*internalRoI.dzdrPlus();
434
435 const float maxKappa_high_eta = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.8)*maxCurv;
436 const float maxKappa_low_eta = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.6)*maxCurv;
437
438 pJobData->m_algo_params[0] = min_deltaPhi;
439 pJobData->m_algo_params[1] = dphi_coeff;
440 pJobData->m_algo_params[2] = minDeltaRadius;
441 pJobData->m_algo_params[3] = min_z0;
442 pJobData->m_algo_params[4] = max_z0;
443 pJobData->m_algo_params[5] = maxOuterRadius;
444 pJobData->m_algo_params[6] = cut_zMinU;
445 pJobData->m_algo_params[7] = cut_zMaxU;
446 pJobData->m_algo_params[8] = maxKappa_low_eta;
447 pJobData->m_algo_params[9] = maxKappa_high_eta;
448 pJobData->m_algo_params[10]= cut_dphi_max;
449 pJobData->m_algo_params[11]= cut_dcurv_max;
450 pJobData->m_algo_params[12]= cut_tau_ratio_max;
451
452 int minLevel = 3;//a triplet + 1 confirmation
453
454 if(m_LRTmode) {
455 minLevel = 2;//a triplet
456 }
457
458 pJobData->m_minLevel = minLevel;
459
460 pJobData->m_useGPUseedExtraction = m_useGPUseedExtraction;
461
462 seedStats.m_nPixelSPs = nPixels;
463 seedStats.m_nStripSPs = nStrips;
464
465 ATH_MSG_DEBUG("Loaded "<<nPixels<< " Pixel Spacepoints and "<<nStrips<< " Strip SpacePoints");
466
467 std::shared_ptr<TrigAccel::OffloadBuffer> pBuff = std::make_shared<TrigAccel::OffloadBuffer>(dataBuffer.get());
468
469 std::unique_ptr<TrigAccel::Work> pWork = std::unique_ptr<TrigAccel::Work>(m_accelSvc->createWork(TrigAccel::InDetJobControlCode::RUN_GBTS, pBuff));
470
471 if(!pWork) {
472 ATH_MSG_WARNING("Failed to create a work item for task "<<TrigAccel::InDetJobControlCode::RUN_GBTS);
473 return seedStats;
474 }
475
476 ATH_MSG_DEBUG("Work item created for task "<<TrigAccel::InDetJobControlCode::RUN_GBTS);
477
478 bool workSuccess = pWork->run();
479 if(!workSuccess) {
480 ATH_MSG_WARNING("Work item failed to complete");
481 return seedStats;
482 }
483
484 std::shared_ptr<TrigAccel::OffloadBuffer> pOutput = pWork->getOutput();
485
486 TrigAccel::ITk::GRAPH_AND_SEEDS_OUTPUT* pGraphAndSeeds = reinterpret_cast<TrigAccel::ITk::GRAPH_AND_SEEDS_OUTPUT*>(pOutput->m_rawBuffer);
487 TrigAccel::ITk::COMPRESSED_GRAPH* pGraph = &pGraphAndSeeds->m_CompressedGraph;
488 TrigAccel::ITk::OUTPUT_SEEDS* pSeeds = &pGraphAndSeeds->m_OutputSeeds;
489
490 if(m_useGPUseedExtraction) {
491 //converting tracklet into GBTS-CPU format
492 for(unsigned int seed=0; seed<pSeeds->m_nSeeds; seed++) {
493
494 unsigned int lastIdx = output.size();
495 output.emplace_back(pSeeds->m_seedsArray[seed].m_Q);
496 for(int node=0; node<pSeeds->m_seedsArray[seed].m_size; node++) {
497 output[lastIdx].addSpacePoint(vSP[pSeeds->m_seedsArray[seed].m_nodes[node]]);
498 }
499 }
500 }
501 else {
502
503 unsigned int nEdges = pGraph->m_nEdges;
504 unsigned int nMaxNei = pGraph->m_nMaxNeighbours;
505
506 //populating the edgeStorage
507
508 std::vector<GNNR3_Node> nodes;
509
510 nodes.reserve(vSP.size());
511
512 for(unsigned int idx = 0;idx < vSP.size(); idx++) {
513
514 nodes.emplace_back(vL[idx]);
515
516 const auto& pos = vSP[idx]->globalPosition();
517 float xs = pos.x() - shift_x;
518 float ys = pos.y() - shift_y;
519 float zs = pos.z();
520
521 nodes[idx].m_x = xs;
522 nodes[idx].m_y = ys;
523 nodes[idx].m_z = zs;
524 nodes[idx].m_r = std::sqrt(xs*xs + ys*ys);
525
526 nodes[idx].m_idx = idx;
527
528 }
529
530 std::vector<GNNR3_Edge> edgeStorage;
531
532 std::pair<int, int> graphStats(0,0);
533
534 edgeStorage.resize(nEdges);
535
536 unsigned int edgeSize = nMaxNei + 1 + 2;//neigbours, num_neighbours, 2 nodes
537
538 for(unsigned int idx=0;idx<nEdges;idx++) {
539 unsigned int pos = idx*edgeSize;
540
541 int node1Idx = pGraph->m_graphArray[pos + TrigAccel::ITk::node1];
542 int node2Idx = pGraph->m_graphArray[pos + TrigAccel::ITk::node2];
543 int nNei = pGraph->m_graphArray[pos + TrigAccel::ITk::nNei];
544
545 if(nNei > N_SEG_CONNS) nNei = N_SEG_CONNS;
546
547 edgeStorage[idx].m_n1 = &nodes[node1Idx];
548 edgeStorage[idx].m_n2 = &nodes[node2Idx];
549 edgeStorage[idx].m_level = 1;
550 edgeStorage[idx].m_nNei = nNei;
551 for(int k=0;k<nNei;k++) {
552 edgeStorage[idx].m_vNei[k] = pGraph->m_graphArray[pos + TrigAccel::ITk::nei_idx_start + k];
553 }
554 }
555
556 graphStats.first = nEdges;
557 graphStats.second = pGraph->m_nLinks;
558
559 //run the rest of the GBTS workflow
560
561 int maxLevel = runCCA(graphStats.first, edgeStorage);
562
563 ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
564
565 if(maxLevel < minLevel) return seedStats;
566
567 std::vector<GNNR3_Edge*> vSeeds;
568
569 vSeeds.reserve(graphStats.first/2);
570
571 for(int edgeIndex=0;edgeIndex<graphStats.first;edgeIndex++) {
572 GNNR3_Edge* pS = &(edgeStorage.at(edgeIndex));
573
574 if(pS->m_level < minLevel) continue;
575
576 vSeeds.push_back(pS);
577 }
578
579 if(vSeeds.empty()) return seedStats;
580
581 std::sort(vSeeds.begin(), vSeeds.end(), GNNR3_Edge::CompareLevel());
582
583 //backtracking
584
585 TrigFTF_GNNR3_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
586
587 output.reserve(vSeeds.size());
588
589 for(auto pS : vSeeds) {
590
591 if(pS->m_level == -1) continue;
592
593 TrigFTF_GNNR3_EdgeState rs(false);
594
595 tFilter.followTrack(pS, rs);
596
597 if(!rs.m_initialized) {
598 continue;
599 }
600
601 if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
602
603 std::vector<const GNNR3_Node*> vN;
604
605 for(std::vector<GNNR3_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
606
607 (*sIt)->m_level = -1;//mark as collected
608
609 if(sIt == rs.m_vs.rbegin()) {
610 vN.push_back((*sIt)->m_n1);
611 }
612 vN.push_back((*sIt)->m_n2);
613 }
614
615 if(vN.size()<3) continue;
616
617 unsigned int lastIdx = output.size();
618 output.emplace_back(rs.m_J);
619
620 for(const auto& n : vN) {
621 output[lastIdx].addSpacePoint(vSP[n->m_idx]);
622 }
623 }
624 }
625
626 ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
627 }
628
629#endif
630
631 return seedStats;
632
633}
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
totalSize
static unsigned int totalSize(const MultiDimArray< T, N > &ht)
Definition MultiDimArray.h:310
InDet::SiWidth::widthPhiRZ
const Amg::Vector2D & widthPhiRZ() const
Definition SiWidth.h:121
SeedingToolBase::runCCA
int runCCA(int, std::vector< GNN_Edge > &) const
Definition TrigInDetPattRecoTools/src/SeedingToolBase.cxx:468
SeedingToolBase::m_layerNumberTool
ToolHandle< ITrigL2LayerNumberTool > m_layerNumberTool
Definition TrigInDetPattRecoTools/src/SeedingToolBase.h:54
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:98
TrigFTF_GNNR3_Layer::m_layer
const TrigInDetSiLayer & m_layer
Definition GNNR3_Geometry.h:30
TrigFTF_GNNR3_Layer::m_etaBin
float m_etaBin
Definition GNNR3_Geometry.h:37
TrigFTF_GNNR3_Layer::m_bins
std::vector< int > m_bins
Definition GNNR3_Geometry.h:31
TrigFTF_GNNR3_Layer::num_bins
int num_bins() const
Definition GNNR3_Geometry.h:26
TrigFTF_GNNR3_Layer::m_minEta
float m_minEta
Definition GNNR3_Geometry.h:37
TrigInDetR3TrackSeedingTool::m_sctSpacePointsContainerKey
SG::ReadHandleKey< SpacePointContainer > m_sctSpacePointsContainerKey
Definition TrigInDetR3TrackSeedingTool.h:62
TrigInDetR3TrackSeedingTool::m_regsel_pix
ToolHandle< IRegSelTool > m_regsel_pix
region selector tools
Definition TrigInDetR3TrackSeedingTool.h:67
TrigInDetR3TrackSeedingTool::createGraphNodes
void createGraphNodes(const SpacePointCollection *, std::vector< GNNR3_Node > &, std::vector< const Trk::SpacePoint * > &, unsigned short, float, float) const
Definition TrigInDetR3TrackSeedingTool.cxx:635
TrigInDetR3TrackSeedingTool::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition TrigInDetR3TrackSeedingTool.h:56
TrigInDetR3TrackSeedingTool::m_pixelSpacePointsContainerKey
SG::ReadHandleKey< SpacePointContainer > m_pixelSpacePointsContainerKey
Definition TrigInDetR3TrackSeedingTool.h:63
TrigInDetR3TrackSeedingTool::m_regsel_sct
ToolHandle< IRegSelTool > m_regsel_sct
Definition TrigInDetR3TrackSeedingTool.h:68
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:48
MuonGM::nStrips
int nStrips(const MuonGM::TgcReadoutElement &readoutEle, int layer)
Definition MuonDetDescr/MuonGeoModelTest/src/GeoModelTgcTest.cxx:46
SUSY_SimplifiedModel_PostInclude.params
params
Definition SUSY_SimplifiedModel_PostInclude.py:98
TCS::KFMET::nEtaBins
constexpr unsigned nEtaBins
Definition KalmanMETCorrectionConstants.h:18
TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA
struct TrigAccel::ITk::GraphMakingInputData GRAPH_MAKING_INPUT_DATA
TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS
static constexpr unsigned int GBTS_MAX_NUMBER_SPACEPOINTS
Definition TrigITkAccelEDM.h:110
TrigAccel::ITk::nNei
static constexpr unsigned char nNei
Definition TrigITkAccelEDM.h:123
TrigAccel::ITk::node1
static constexpr unsigned char node1
Definition TrigITkAccelEDM.h:121
TrigAccel::ITk::node2
static constexpr unsigned char node2
Definition TrigITkAccelEDM.h:122
TrigAccel::ITk::OUTPUT_SEEDS
struct TrigAccel::ITk::OutputSeeds OUTPUT_SEEDS
TrigAccel::ITk::GRAPH_AND_SEEDS_OUTPUT
struct TrigAccel::ITk::GraphAndSeedsOutput GRAPH_AND_SEEDS_OUTPUT
TrigAccel::ITk::nei_idx_start
static constexpr unsigned char nei_idx_start
Definition TrigITkAccelEDM.h:124
TrigAccel::ITk::COMPRESSED_GRAPH
struct TrigAccel::ITk::CompressedGraph COMPRESSED_GRAPH
TrigAccel::DATA_EXPORT_BUFFER
struct TrigAccel::DataExportBuffer DATA_EXPORT_BUFFER
merge.output
output
Definition merge.py:16
xAOD::SpacePointContainer
SpacePointContainer_v1 SpacePointContainer
Define the version of the space point container.
Definition Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/SpacePointContainer.h:14
TrigAccel::ITk::CompressedGraph::m_graphArray
std::unique_ptr< int[]> m_graphArray
Definition TrigITkAccelEDM.h:161
TrigAccel::ITk::GraphMakingInputData::m_bin_pairs
int m_bin_pairs[2 *GBTS_MAX_ETA_BIN_PAIR]
Definition TrigITkAccelEDM.h:145
TrigAccel::ITk::GraphMakingInputData::m_layerInfo
int m_layerInfo[4 *GBTS_MAX_SILICON_LAYERS]
Definition TrigITkAccelEDM.h:137
TrigAccel::ITk::GraphMakingInputData::m_layerGeo
float m_layerGeo[2 *GBTS_MAX_SILICON_LAYERS]
Definition TrigITkAccelEDM.h:141
TrigAccel::ITk::GraphMakingInputData::m_layerIdx
int m_layerIdx[GBTS_MAX_SILICON_LAYERS]
Definition TrigITkAccelEDM.h:133
TrigAccel::ITk::GraphMakingInputData::m_params
float m_params[4 *GBTS_MAX_NUMBER_SPACEPOINTS]
Definition TrigITkAccelEDM.h:131
TrigAccel::ITk::OutputSeeds::m_seedsArray
std::unique_ptr< Tracklet[]> m_seedsArray
Definition TrigITkAccelEDM.h:175
TrigFTF_GNNR3_Edge::CompareLevel
Definition GNNR3_DataStorage.h:109

◆ initialize()

StatusCode TrigInDetR3TrackSeedingTool::initialize ( )
overridevirtual

Reimplemented from SeedingToolBase.

Definition at line 34 of file TrigInDetR3TrackSeedingTool.cxx.

34 {
35
36 ATH_CHECK(SeedingToolBase::initialize());
37
38 ATH_CHECK(m_regsel_pix.retrieve());
39 ATH_CHECK(m_regsel_sct.retrieve());
40
41 ATH_CHECK(m_beamSpotKey.initialize());
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
50 if (!m_usePixelSpacePoints && !m_useSctSpacePoints) {
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
61 ATH_CHECK(m_pixelSpacePointsContainerKey.initialize(m_usePixelSpacePoints));
62
63 ATH_CHECK(m_sctSpacePointsContainerKey.initialize(m_useSctSpacePoints));
64
65 ATH_MSG_INFO("TrigInDetR3TrackSeedingTool initialized with " << m_useGPU);
66
67 return StatusCode::SUCCESS;
68}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_INFO
#define ATH_MSG_INFO(x,...)
Definition AthMsgStreamMacros.h:45
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x,...)
Definition AthMsgStreamMacros.h:48

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
365 handlesArray.renounce();
366 }

◆ runCCA() [1/2]

int SeedingToolBase::runCCA ( int nEdges,
std::vector< GNN_Edge > & edgeStorage ) const
protectedinherited

Definition at line 468 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

468 {
469
470 constexpr int maxIter = 15;
471
472 int maxLevel = 0;
473
474 int iter = 0;
475
476 std::vector<TrigFTF_GNN_Edge*> v_old;
477
478 for(int edgeIndex=0;edgeIndex<nEdges;edgeIndex++) {
479
480 TrigFTF_GNN_Edge* pS = &(edgeStorage[edgeIndex]);
481 if(pS->m_nNei == 0) continue;
482
483 v_old.push_back(pS);//TO-DO: increment level for segments as they already have at least one neighbour
484 }
485
486 std::vector<TrigFTF_GNN_Edge*> v_new;
487 v_new.reserve(v_old.size());
488
489 for(;iter<maxIter;iter++) {
490
491 //generate proposals
492 v_new.clear();
493
494 for(auto pS : v_old) {
495
496 int next_level = pS->m_level;
497
498 for(int nIdx=0;nIdx<pS->m_nNei;nIdx++) {
499
500 unsigned int nextEdgeIdx = pS->m_vNei[nIdx];
501
502 TrigFTF_GNN_Edge* pN = &(edgeStorage[nextEdgeIdx]);
503
504 if(pS->m_level == pN->m_level) {
505 next_level = pS->m_level + 1;
506 v_new.push_back(pS);
507 break;
508 }
509 }
510
511 pS->m_next = next_level;//proposal
512 }
513
514 //update
515
516 int nChanges = 0;
517
518 for(auto pS : v_new) {
519 if(pS->m_next != pS->m_level) {
520 nChanges++;
521 pS->m_level = pS->m_next;
522 if(maxLevel < pS->m_level) maxLevel = pS->m_level;
523 }
524 }
525
526 if(nChanges == 0) break;
527
528
529 v_old.swap(v_new);
530 v_new.clear();
531 }
532
533 return maxLevel;
534}
TrigFTF_GNN_Edge::m_level
signed char m_level
Definition GNN_DataStorage.h:132
TrigFTF_GNN_Edge::m_next
signed char m_next
Definition GNN_DataStorage.h:132

◆ runCCA() [2/2]

int SeedingToolBase::runCCA ( int nEdges,
std::vector< GNNR3_Edge > & edgeStorage ) const
protectedinherited

Definition at line 297 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.cxx.

297 {
298
299 const int maxIter = 15;
300
301 int maxLevel = 0;
302
303 int iter = 0;
304
305 std::vector<TrigFTF_GNNR3_Edge*> v_old;
306
307 for(int edgeIndex=0;edgeIndex<nEdges;edgeIndex++) {
308
309 TrigFTF_GNNR3_Edge* pS = &(edgeStorage[edgeIndex]);
310 if(pS->m_nNei == 0) continue;
311
312 v_old.push_back(pS);//TO-DO: increment level for segments as they already have at least one neighbour
313 }
314
315 for(;iter<maxIter;iter++) {
316
317 //generate proposals
318 std::vector<TrigFTF_GNNR3_Edge*> v_new;
319 v_new.clear();
320 v_new.reserve(v_old.size());
321
322 for(auto pS : v_old) {
323
324 int next_level = pS->m_level;
325
326 for(int nIdx=0;nIdx<pS->m_nNei;nIdx++) {
327
328 unsigned int nextEdgeIdx = pS->m_vNei[nIdx];
329
330 TrigFTF_GNNR3_Edge* pN = &(edgeStorage[nextEdgeIdx]);
331
332 if(pS->m_level == pN->m_level) {
333 next_level = pS->m_level + 1;
334 v_new.push_back(pS);
335 break;
336 }
337 }
338
339 pS->m_next = next_level;//proposal
340 }
341
342 //update
343
344 int nChanges = 0;
345
346 for(auto pS : v_new) {
347 if(pS->m_next != pS->m_level) {
348 nChanges++;
349 pS->m_level = pS->m_next;
350 if(maxLevel < pS->m_level) maxLevel = pS->m_level;
351 }
352 }
353
354 if(nChanges == 0) break;
355
356
357 v_old = std::move(v_new);
358 v_new.clear();
359 }
360
361 return maxLevel;
362}
TrigFTF_GNNR3_Edge::m_level
signed char m_level
Definition GNNR3_DataStorage.h:128
TrigFTF_GNNR3_Edge::m_next
signed char m_next
Definition GNNR3_DataStorage.h:128

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

◆ validate_triplet()

bool SeedingToolBase::validate_triplet ( std::array< const GNN_Node *, 3 > & sps,
const float min_pt,
const float tau_ratio,
const float tau_ratio_cut ) const
protectedinherited

Definition at line 892 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

892 {
893
894 //conformal mapping with the center at the middle spacepoint
895
896 float u[2], v[2];
897
898 const float x0 = sps[1]->x();
899 const float y0 = sps[1]->y();
900
901 const float r0 = sps[1]->r();
902
903 const float cosA = x0/r0;
904
905 const float sinA = y0/r0;
906
907 for(unsigned int k=0;k<2;k++) {
908
909 int sp_idx = (k==1) ? 2 : k;
910
911 const float dx = sps[sp_idx]->x() - x0;
912
913 const float dy = sps[sp_idx]->y() - y0;
914
915 const float r2_inv = 1.0/(dx*dx+dy*dy);
916
917 const float xn = dx*cosA + dy*sinA;
918
919 const float yn =-dx*sinA + dy*cosA;
920
921 u[k] = xn*r2_inv;
922 v[k] = yn*r2_inv;
923 }
924
925 const float du = u[0] - u[1];
926
927 if ( du == 0.0 ) return false;
928
929 const float A = (v[0] - v[1])/du;
930
931 const float B = v[1] - A*u[1];
932
933 const float d0 = r0*(B*r0 - A);
934
935 if (std::abs(d0) > m_d0_max) return false;
936
937 if (B != 0.0) {//straight-line track is OK
938
939 const float R = std::sqrt(1 + A*A)/B; //signed radius in mm
940
941 const float pT = std::abs(0.3*R); //asssuming uniform 2T field
942
943 if (pT < min_pT) return false;
944
945 if (pT > 5*min_pT) {//relatively high-pT track
946
947 if (tau_ratio > 0.9*tau_ratio_cut) return false;
948
949 }
950
951 }
952
953 return true;
954
955}
AnalysisUtils::Delta::R
double R(const INavigable4Momentum *p1, const double v_eta, const double v_phi)
Definition AnalysisMisc.h:49

Member Data Documentation

◆ m_addTriplets

BooleanProperty SeedingToolBase::m_addTriplets {this, "AddTriplets", false}
protectedinherited

Definition at line 80 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

80{this, "AddTriplets", false};

◆ m_atlasId

const AtlasDetectorID * SeedingToolBase::m_atlasId = nullptr
protectedinherited

Definition at line 56 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_beamSpotKey

SG::ReadCondHandleKey<InDet::BeamSpotData> TrigInDetR3TrackSeedingTool::m_beamSpotKey { this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" }
protected

Definition at line 56 of file TrigInDetR3TrackSeedingTool.h.

56{ this, "BeamSpotKey", "BeamSpotData", "SG key for beam spot" };

◆ m_connectionFile

StringProperty SeedingToolBase::m_connectionFile {this, "ConnectionFileName", "binTables_ITK_RUN4.txt"}
protectedinherited

Definition at line 73 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

73{this, "ConnectionFileName", "binTables_ITK_RUN4.txt"};

◆ m_connector [1/2]

std::unique_ptr<GNN_FasTrackConnector> SeedingToolBase::m_connector = nullptr
protectedinherited

Definition at line 93 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_connector [2/2]

std::unique_ptr<GNNR3_FasTrackConnector> SeedingToolBase::m_connector = nullptr
protectedinherited

Definition at line 67 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

◆ m_d0_max

FloatProperty SeedingToolBase::m_d0_max {this, "d0_max", 3.0}
protectedinherited

Definition at line 86 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

86{this, "d0_max", 3.0};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doubletFilterRZ

BooleanProperty SeedingToolBase::m_doubletFilterRZ {this, "Doublet_FilterRZ", true}
protectedinherited

Definition at line 66 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

66{this, "Doublet_FilterRZ", true};

◆ m_etaBinOverride

FloatProperty SeedingToolBase::m_etaBinOverride {this, "etaBin", 0.0f, "specify non-zero to override eta bin width from connection file (default 0.2 in createLinkingScheme.py)"}
protectedinherited

Definition at line 70 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

70{this, "etaBin", 0.0f, "specify non-zero to override eta bin width from connection file (default 0.2 in createLinkingScheme.py)"};

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_filter_phi

BooleanProperty SeedingToolBase::m_filter_phi {this, "DoPhiFiltering", true}
protectedinherited

Definition at line 60 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

60{this, "DoPhiFiltering", true};

◆ m_geo [1/2]

std::unique_ptr<const TrigFTF_GNN_Geometry> SeedingToolBase::m_geo = nullptr
protectedinherited

Definition at line 95 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_geo [2/2]

std::unique_ptr<const TrigFTF_GNNR3_Geometry> SeedingToolBase::m_geo = nullptr
protectedinherited

Definition at line 69 of file TrigInDetR3PattRecoTools/src/SeedingToolBase.h.

◆ m_layerGeometry

std::vector< TrigInDetSiLayer > SeedingToolBase::m_layerGeometry
protectedinherited

Definition at line 94 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_layerNumberTool

ToolHandle< ITrigL2LayerNumberTool > SeedingToolBase::m_layerNumberTool {this, "layerNumberTool", "TrigL2LayerNumberToolITk"}
protectedinherited

Definition at line 54 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

54{this, "layerNumberTool", "TrigL2LayerNumberToolITk"};

◆ m_LRTmode

BooleanProperty SeedingToolBase::m_LRTmode {this, "LRTMode",false}
protectedinherited

Definition at line 62 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

62{this, "LRTMode",false};

◆ m_lutFile

StringProperty SeedingToolBase::m_lutFile {this, "MLpredictorLutFileName", "gbts_ml_pixel_barrel_loose.lut"}
protectedinherited

Definition at line 74 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

74{this, "MLpredictorLutFileName", "gbts_ml_pixel_barrel_loose.lut"};

◆ m_matchBeforeCreate

BooleanProperty SeedingToolBase::m_matchBeforeCreate {this, "MatchBeforeCreate", true}
protectedinherited

Definition at line 68 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

68{this, "MatchBeforeCreate", true};

◆ m_max_eta_add_triplets

FloatProperty SeedingToolBase::m_max_eta_add_triplets {this, "add_triplets_eta_cut", 1.5}
protectedinherited

Definition at line 88 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

88{this, "add_triplets_eta_cut", 1.5};

◆ m_max_eta_for_seed_split

FloatProperty SeedingToolBase::m_max_eta_for_seed_split {this, "split_seeds_eta_cut", 0.6}
protectedinherited

Definition at line 89 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

89{this, "split_seeds_eta_cut", 0.6};

◆ m_minPt

FloatProperty SeedingToolBase::m_minPt {this, "pTmin", 1000.0}
protectedinherited

Definition at line 69 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

69{this, "pTmin", 1000.0};

◆ m_mlLUT

std::vector<std::array<float, 5> > SeedingToolBase::m_mlLUT
protectedinherited

Definition at line 96 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_nBufferEdges

IntegerProperty SeedingToolBase::m_nBufferEdges {this, "BufferEdges", 200000}
protectedinherited

Definition at line 72 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

72{this, "BufferEdges", 200000};

◆ m_nMaxEdges

IntegerProperty SeedingToolBase::m_nMaxEdges {this, "MaxGraphEdges", 2000000}
protectedinherited

Definition at line 71 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

71{this, "MaxGraphEdges", 2000000};

◆ m_nMaxPhiSlice

UnsignedIntegerProperty SeedingToolBase::m_nMaxPhiSlice {this, "nMaxPhiSlice", 53}
protectedinherited

Definition at line 65 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

65{this, "nMaxPhiSlice", 53};

◆ m_phiSliceWidth

float SeedingToolBase::m_phiSliceWidth = 0.
protectedinherited

Definition at line 91 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_pixelId

const PixelID * SeedingToolBase::m_pixelId = nullptr
protectedinherited

Definition at line 58 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_pixelSpacePointsContainerKey

SG::ReadHandleKey<SpacePointContainer> TrigInDetR3TrackSeedingTool::m_pixelSpacePointsContainerKey {this, "PixelSP_ContainerName", "ITkPixelTrigSpacePoints"}
protected

Definition at line 63 of file TrigInDetR3TrackSeedingTool.h.

63{this, "PixelSP_ContainerName", "ITkPixelTrigSpacePoints"};

◆ m_regsel_pix

ToolHandle<IRegSelTool> TrigInDetR3TrackSeedingTool::m_regsel_pix { this, "RegSelTool_Pixel", "RegSelTool/RegSelTool_Pixel" }
protected

region selector tools

Definition at line 67 of file TrigInDetR3TrackSeedingTool.h.

67{ this, "RegSelTool_Pixel", "RegSelTool/RegSelTool_Pixel" };

◆ m_regsel_sct

ToolHandle<IRegSelTool> TrigInDetR3TrackSeedingTool::m_regsel_sct { this, "RegSelTool_SCT", "RegSelTool/RegSelTool_SCT" }
protected

Definition at line 68 of file TrigInDetR3TrackSeedingTool.h.

68{ this, "RegSelTool_SCT", "RegSelTool/RegSelTool_SCT" };

◆ m_sctId

const SCT_ID * SeedingToolBase::m_sctId = nullptr
protectedinherited

Definition at line 57 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_sctSpacePointsContainerKey

SG::ReadHandleKey<SpacePointContainer> TrigInDetR3TrackSeedingTool::m_sctSpacePointsContainerKey {this, "SCT_SP_ContainerName", "ITkStripTrigSpacePoints"}
protected

Definition at line 62 of file TrigInDetR3TrackSeedingTool.h.

62{this, "SCT_SP_ContainerName", "ITkStripTrigSpacePoints"};

◆ m_tau_ratio_corr

FloatProperty SeedingToolBase::m_tau_ratio_corr {this, "tau_ratio_correction", 0.006}
protectedinherited

Definition at line 84 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

84{this, "tau_ratio_correction", 0.006};

◆ m_tau_ratio_cut

FloatProperty SeedingToolBase::m_tau_ratio_cut {this, "tau_ratio_cut", 0.007}
protectedinherited

Definition at line 83 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

83{this, "tau_ratio_cut", 0.007};

◆ m_useAdaptiveCuts

BooleanProperty SeedingToolBase::m_useAdaptiveCuts {this, "UseAdaptiveCuts", true}
protectedinherited

Definition at line 79 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

79{this, "UseAdaptiveCuts", true};

◆ m_useBeamTilt

BooleanProperty SeedingToolBase::m_useBeamTilt {this, "UseBeamTilt", false}
protectedinherited

Definition at line 61 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

61{this, "UseBeamTilt", false};

◆ m_useEtaBinning

BooleanProperty SeedingToolBase::m_useEtaBinning {this, "UseEtaBinning", true}
protectedinherited

Definition at line 67 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

67{this, "UseEtaBinning", true};

◆ m_useGPU

BooleanProperty TrigInDetR3TrackSeedingTool::m_useGPU {this, "UseGPU", false}
protected

Definition at line 72 of file TrigInDetR3TrackSeedingTool.h.

72{this, "UseGPU", false};

◆ m_useGPUseedExtraction

BooleanProperty SeedingToolBase::m_useGPUseedExtraction {this, "UseGPUseedExtraction", true}
protectedinherited

Definition at line 76 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

76{this, "UseGPUseedExtraction", true};

◆ m_useML

BooleanProperty SeedingToolBase::m_useML {this, "useML", true}
protectedinherited

Definition at line 63 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

63{this, "useML", true};

◆ m_useOldTunings

BooleanProperty SeedingToolBase::m_useOldTunings {this, "UseOldTunings", false}
protectedinherited

Definition at line 77 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

77{this, "UseOldTunings", false};

◆ m_usePixelSpacePoints

BooleanProperty TrigInDetR3TrackSeedingTool::m_usePixelSpacePoints {this, "UsePixelSpacePoints", true}
protected

Definition at line 58 of file TrigInDetR3TrackSeedingTool.h.

58{this, "UsePixelSpacePoints", true};

◆ m_useSctSpacePoints

BooleanProperty TrigInDetR3TrackSeedingTool::m_useSctSpacePoints {this, "UseSctSpacePoints", false}
protected

Definition at line 59 of file TrigInDetR3TrackSeedingTool.h.

59{this, "UseSctSpacePoints", false};

◆ m_validateTriplets

BooleanProperty SeedingToolBase::m_validateTriplets {this, "ValidateTriplets", true}
protectedinherited

Definition at line 78 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

78{this, "ValidateTriplets", true};

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.17.0