ATLAS Offline Software
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
TrigInDetTrackSeedingTool Class Reference

#include <TrigInDetTrackSeedingTool.h>

Inheritance diagram for TrigInDetTrackSeedingTool:
Collaboration diagram for TrigInDetTrackSeedingTool:

Public Member Functions

 TrigInDetTrackSeedingTool (const std::string &, const std::string &, const IInterface *)
 
virtual ~TrigInDetTrackSeedingTool ()
 
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. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) 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< GNN_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::tuple< float, int, std::vector< unsigned int > > > &) const
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
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. More...
 

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 More...
 
ToolHandle< IRegSelTool > m_regsel_sct { this, "RegSelTool_SCT", "RegSelTool/RegSelTool_SCT" }
 
BooleanProperty m_useGPU {this, "UseGPU", false}
 
ServiceHandle< ITrigInDetAccelerationSvc > m_accelSvc {this, "TrigAccelerationSvc", ""}
 
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}
 
FloatProperty m_tau_ratio_cut {this, "tau_ratio_cut", 0.007}
 
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> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

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

Detailed Description

Definition at line 37 of file TrigInDetTrackSeedingTool.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

◆ TrigInDetTrackSeedingTool()

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

Definition at line 27 of file TrigInDetTrackSeedingTool.cxx.

29  : SeedingToolBase(t,n,p)
30 {
31 
32 }

◆ ~TrigInDetTrackSeedingTool()

virtual TrigInDetTrackSeedingTool::~TrigInDetTrackSeedingTool ( )
inlinevirtual

Definition at line 42 of file TrigInDetTrackSeedingTool.h.

42 {};

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  constexpr float M_2PI = 2.0*M_PI;
101 
102  const float cut_dphi_max = m_LRTmode ? 0.07f : 0.012f;
103  const float cut_dcurv_max = m_LRTmode ? 0.015f : 0.001f;
104  const float cut_tau_ratio_max = m_LRTmode ? 0.015f : static_cast<float>(m_tau_ratio_cut);
105  const float min_z0 = m_LRTmode ? -600.0 : roi.zedMinus();
106  const float max_z0 = m_LRTmode ? 600.0 : roi.zedPlus();
107  const float min_deltaPhi = m_LRTmode ? 0.01f : 0.001f;
108  const float tau_ratio_precut = 0.009f;
109 
110  const float maxOuterRadius = m_LRTmode ? 1050.0 : 550.0;
111 
112  const float cut_zMinU = min_z0 + maxOuterRadius*roi.dzdrMinus();
113  const float cut_zMaxU = max_z0 + maxOuterRadius*roi.dzdrPlus();
114 
115  constexpr float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
116 
117  float tripletPtMin = 0.8f*m_minPt;//correction due to limited pT resolution
118  const float pt_scale = 900.0f/m_minPt;//to re-scale original tunings done for the 900 MeV pT cut
119 
120  float maxCurv = ptCoeff/tripletPtMin;
121 
122  float maxKappa_high_eta = m_LRTmode ? 1.0f*maxCurv : std::sqrt(0.8f)*maxCurv;
123  float maxKappa_low_eta = m_LRTmode ? 1.0f*maxCurv : std::sqrt(0.6f)*maxCurv;
124 
125  if(!m_useOldTunings && !m_LRTmode) {//new settings for curvature cuts
126  maxKappa_high_eta = 4.75e-4f*pt_scale;
127  maxKappa_low_eta = 3.75e-4f*pt_scale;
128  }
129 
130  const float dphi_coeff = m_LRTmode ? 1.0f*maxCurv : 0.68f*maxCurv;
131 
132  const float minDeltaRadius = 2.0;
133 
134  float deltaPhi = 0.5f*m_phiSliceWidth;//the default sliding window along phi
135 
136  unsigned int nConnections = 0;
137 
138  edgeStorage.reserve(m_nMaxEdges);
139 
140  int nEdges = 0;
141 
142  for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
143 
144  TrigFTF_GNN_EtaBin& B1 = storage->getEtaBin(bg.first);
145 
146  if(B1.empty()) continue;
147 
148  float rb1 = B1.getMinBinRadius();
149 
150  const unsigned int lk1 = B1.m_layerKey;
151 
152  for(const auto& b2_idx : bg.second) {
153 
154  const TrigFTF_GNN_EtaBin& B2 = storage->getEtaBin(b2_idx);
155 
156  if(B2.empty()) continue;
157 
158  float rb2 = B2.getMaxBinRadius();
159 
160  if(m_useEtaBinning) {
161  float abs_dr = std::fabs(rb2-rb1);
162  if (m_useOldTunings) {
163  deltaPhi = min_deltaPhi + dphi_coeff*abs_dr;
164  }
165  else {
166  if(abs_dr < 60.0) {
167  deltaPhi = 0.002f + 4.33e-4f*pt_scale*abs_dr;
168  } else {
169  deltaPhi = 0.015f + 2.2e-4f*pt_scale*abs_dr;
170  }
171  }
172  }
173 
174  unsigned int first_it = 0;
175 
176  for(unsigned int n1Idx = 0;n1Idx<B1.m_vn.size();n1Idx++) {//loop over nodes in Layer 1
177 
178  std::vector<unsigned int>& v1In = B1.m_in[n1Idx];
179 
180  if(v1In.size() >= MAX_SEG_PER_NODE) continue;
181 
182  const std::array<float, 5>& n1pars = B1.m_params[n1Idx];
183 
184  float phi1 = n1pars[2];
185  float r1 = n1pars[3];
186  float z1 = n1pars[4];
187 
188  //sliding window phi1 +/- deltaPhi
189 
190  float minPhi = phi1 - deltaPhi;
191  float maxPhi = phi1 + deltaPhi;
192 
193  for(unsigned int n2PhiIdx = first_it; n2PhiIdx<B2.m_vPhiNodes.size();n2PhiIdx++) {//sliding window over nodes in Layer 2
194 
195  float phi2 = B2.m_vPhiNodes[n2PhiIdx].first;
196 
197  if(phi2 < minPhi) {
198  first_it = n2PhiIdx;
199  continue;
200  }
201  if(phi2 > maxPhi) break;
202 
203  unsigned int n2Idx = B2.m_vPhiNodes[n2PhiIdx].second;
204 
205  const std::vector<unsigned int>& v2In = B2.m_in[n2Idx];
206 
207  if(v2In.size() >= MAX_SEG_PER_NODE) continue;
208 
209  const std::array<float, 5>& n2pars = B2.m_params[n2Idx];
210 
211  float r2 = n2pars[3];
212 
213  float dr = r2 - r1;
214 
215  if(dr < minDeltaRadius) {
216  continue;
217  }
218 
219  float z2 = n2pars[4];
220 
221  float dz = z2 - z1;
222  float tau = dz/dr;
223  float ftau = std::fabs(tau);
224  if (ftau > 36.0) {
225  continue;
226  }
227 
228  if(ftau < n1pars[0]) continue;
229  if(ftau > n1pars[1]) continue;
230 
231  if(ftau < n2pars[0]) continue;
232  if(ftau > n2pars[1]) continue;
233 
234  if (m_doubletFilterRZ) {
235 
236  float z0 = z1 - r1*tau;
237 
238  if(z0 < min_z0 || z0 > max_z0) continue;
239 
240  float zouter = z0 + maxOuterRadius*tau;
241 
242  if(zouter < cut_zMinU || zouter > cut_zMaxU) continue;
243  }
244 
245  float curv = (phi2-phi1)/dr;
246  float abs_curv = std::abs(curv);
247 
248  if(ftau < 4.0) {//eta = 2.1
249  if(abs_curv > maxKappa_low_eta) {
250  continue;
251  }
252  }
253  else {
254  if(abs_curv > maxKappa_high_eta) {
255  continue;
256  }
257  }
258 
259  float exp_eta = std::sqrt(1.f+tau*tau)-tau;
260 
261  if (m_matchBeforeCreate && (lk1 == 80000 || lk1 == 81000) ) {//match edge candidate against edges incoming to n2
262 
263  bool isGood = v2In.size() <= 2;//we must have enough incoming edges to decide
264 
265  if(!isGood) {
266 
267  float uat_1 = 1.0f/exp_eta;
268 
269  for(const auto& n2_in_idx : v2In) {
270 
271  float tau2 = edgeStorage.at(n2_in_idx).m_p[0];
272  float tau_ratio = tau2*uat_1 - 1.0f;
273 
274  if(std::fabs(tau_ratio) > tau_ratio_precut){//bad match
275  continue;
276  }
277  isGood = true;//good match found
278  break;
279  }
280  }
281 
282  if(!isGood) {//no match found, skip creating [n1 <- n2] edge
283  continue;
284  }
285  }
286 
287  float dPhi2 = curv*r2;
288  float dPhi1 = curv*r1;
289 
290  if(nEdges < m_nMaxEdges) {
291 
292  edgeStorage.emplace_back(B1.m_vn[n1Idx], B2.m_vn[n2Idx], exp_eta, curv, phi1 + dPhi1);
293 
294  if(v1In.size() < MAX_SEG_PER_NODE) v1In.push_back(nEdges);
295 
296  int outEdgeIdx = nEdges;
297 
298  float uat_2 = 1.f/exp_eta;
299  float Phi2 = phi2 + dPhi2;
300  float curv2 = curv;
301 
302  for(const auto& inEdgeIdx : v2In) {//looking for neighbours of the new edge
303 
304  TrigFTF_GNN_Edge* pS = &(edgeStorage.at(inEdgeIdx));
305 
306  if(pS->m_nNei >= N_SEG_CONNS) continue;
307 
308  float tau_ratio = pS->m_p[0]*uat_2 - 1.0f;
309 
310  if(std::abs(tau_ratio) > cut_tau_ratio_max){//bad match
311  continue;
312  }
313 
314  float dPhi = Phi2 - pS->m_p[2];
315 
316  if(dPhi<-M_PI) dPhi += M_2PI;
317  else if(dPhi>M_PI) dPhi -= M_2PI;
318 
319  if(std::abs(dPhi) > cut_dphi_max) {
320  continue;
321  }
322 
323  float dcurv = curv2 - pS->m_p[1];
324 
325  if(dcurv < -cut_dcurv_max || dcurv > cut_dcurv_max) {
326  continue;
327  }
328 
329  pS->m_vNei[pS->m_nNei++] = outEdgeIdx;
330 
331  nConnections++;
332 
333  }
334  nEdges++;
335  }
336  } //loop over n2 (outer) nodes
337  } //loop over n1 (inner) nodes
338  } //loop over bins in Layer 2
339  } //loop over bin groups
340 
341  if(nEdges >= m_nMaxEdges) {
342  ATH_MSG_WARNING("Maximum number of graph edges exceeded - possible efficiency loss "<< nEdges);
343  }
344 
345  return std::make_pair(nEdges, nConnections);
346 }

◆ 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 }

◆ createGraphNodes()

void TrigInDetTrackSeedingTool::createGraphNodes ( const SpacePointCollection *  spColl,
std::vector< GNN_Node > &  tmpColl,
std::vector< const Trk::SpacePoint * > &  vSP,
unsigned short  layer,
float  shift_x,
float  shift_y 
) const
protected

Definition at line 582 of file TrigInDetTrackSeedingTool.cxx.

582  {
583 
584  tmpColl.resize(spColl->size(), GNN_Node(layer));//all nodes belong to the same layer
585 
586  int idx = 0;
587  int init_size = vSP.size();
588  for(const auto sp : *spColl) {
589  const auto& pos = sp->globalPosition();
590  vSP.emplace_back(sp);
591  float xs = pos.x() - shift_x;
592  float ys = pos.y() - shift_y;
593  float zs = pos.z();
594  tmpColl[idx].m_x = xs;
595  tmpColl[idx].m_y = ys;
596  tmpColl[idx].m_z = zs;
597  tmpColl[idx].m_r = std::sqrt(xs*xs + ys*ys);
598  tmpColl[idx].m_phi = std::atan2(ys,xs);
599  tmpColl[idx].m_idx = init_size + idx;
600 
601  const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
602  if(pCL != nullptr){
603  tmpColl[idx].m_pcw = pCL->width().z();
604  tmpColl[idx].m_locPosY = pCL->localPosition().y();
605  }
606 
607  idx++;
608  }
609 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ DeclareInterfaceID()

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

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

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  }

◆ 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; }

◆ evtStore() [1/2]

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; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extractSeedsFromTheGraph()

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

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

416  {
417 
418  const float edge_mask_min_eta = 1.5;
419  const float hit_share_threshold = 0.49;
420 
421  vSeedCandidates.clear();
422 
423  int minLevel = 3;//a triplet + 2 confirmation
424 
425  if(m_LRTmode) {
426  minLevel = 2;//a triplet + 1 confirmation
427  }
428 
429  if(maxLevel < minLevel) return;
430 
431  std::vector<GNN_Edge*> vSeeds;
432 
433  vSeeds.reserve(nEdges/2);
434 
435  for(int edgeIndex = 0; edgeIndex < nEdges; edgeIndex++) {
436 
437  GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
438 
439  if(pS->m_level < minLevel) continue;
440 
441  vSeeds.push_back(pS);
442  }
443 
444  if(vSeeds.empty()) return;
445 
446  std::sort(vSeeds.begin(), vSeeds.end(), GNN_Edge::CompareLevel());
447 
448  //backtracking
449 
450  vSeedCandidates.reserve(vSeeds.size());
451 
452  auto tFilter = std::make_unique<TrigFTF_GNN_TrackingFilter>(m_layerGeometry, edgeStorage);
453 
454  for(auto pS : vSeeds) {
455 
456  if(pS->m_level == -1) continue;
457 
458  TrigFTF_GNN_EdgeState rs(false);
459 
460  tFilter->followTrack(pS, rs);
461 
462  if(!rs.m_initialized) {
463  continue;
464  }
465 
466  if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
467 
468  float seed_eta = std::abs(-std::log(pS->m_p[0]));
469 
470  std::vector<const GNN_Node*> vN;
471 
472  for(std::vector<GNN_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
473 
474  if (seed_eta > edge_mask_min_eta) {
475  (*sIt)->m_level = -1;//mark as collected
476  }
477 
478  if(sIt == rs.m_vs.rbegin()) {
479  vN.push_back((*sIt)->m_n1);
480  }
481 
482  vN.push_back((*sIt)->m_n2);
483 
484  }
485 
486  if(vN.size()<3) continue;
487 
488  std::vector<unsigned int> vSpIdx;
489 
490  vSpIdx.resize(vN.size());
491 
492  for(unsigned int k = 0; k < vN.size(); k++) {
493  vSpIdx[k] = vN[k]->sp_idx();
494  }
495 
496  vSeedCandidates.emplace_back(-rs.m_J/vN.size(), 0, vSpIdx);
497 
498  }
499 
500  //clone removal code goes below ...
501 
502  std::sort(vSeedCandidates.begin(), vSeedCandidates.end());
503 
504  std::vector<int> vTrackIds(vSeedCandidates.size());
505 
506  // fills the vector from 1 to N
507 
508  std::iota(vTrackIds.begin(), vTrackIds.end(), 1);
509 
510  std::vector<int> H2T(nHits + 1, 0);//hit to track associations
511 
512  int seedIdx = 0;
513 
514  for(const auto& seed : vSeedCandidates) {
515 
516  for(const auto& h : std::get<2>(seed) ) {//loop over spacepoints indices
517 
518  unsigned int hit_id = h + 1;
519 
520  int tid = H2T[hit_id];
521  int trackId = vTrackIds[seedIdx];
522 
523  if(tid == 0 || tid > trackId) {//un-used hit or used by a lesser track
524 
525  H2T[hit_id] = trackId;//overwrite
526 
527  }
528  }
529 
530  seedIdx++;
531 
532  }
533 
534  for(unsigned int trackIdx = 0; trackIdx < vSeedCandidates.size(); trackIdx++) {
535 
536  int nTotal = std::get<2>(vSeedCandidates[trackIdx]).size();
537  int nOther = 0;
538 
539  int trackId = vTrackIds[trackIdx];
540 
541  for(const auto& h : std::get<2>(vSeedCandidates[trackIdx]) ) {
542 
543  unsigned int hit_id = h + 1;
544 
545  int tid = H2T[hit_id];
546 
547  if(tid != trackId) {//taken by a better candidate
548  nOther++;
549  }
550  }
551 
552  if (nOther > hit_share_threshold*nTotal) {
553  std::get<1>(vSeedCandidates[trackIdx]) = -1;//reject
554  }
555 
556  }
557 }

◆ 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 TrigInDetTrackSeedingTool::finalize ( )
overridevirtual

Reimplemented from SeedingToolBase.

Definition at line 68 of file TrigInDetTrackSeedingTool.cxx.

68  {
69  return SeedingToolBase::finalize();
70 }

◆ findSeeds()

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

Implements ITrigInDetTrackSeedingTool.

Definition at line 73 of file TrigInDetTrackSeedingTool.cxx.

73  {
74 
75  TrigInDetTrackSeedingResult seedStats;
76 
77  output.clear();
78 
79  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
80  const Amg::Vector3D &vertex = beamSpotHandle->beamPos();
81  float shift_x = vertex.x() - beamSpotHandle->beamTilt(0)*vertex.z();
82  float shift_y = vertex.y() - beamSpotHandle->beamTilt(1)*vertex.z();
83 
84  std::unique_ptr<GNN_DataStorage> storage = std::make_unique<GNN_DataStorage>(*m_geo, m_mlLUT);
85 
86  int nPixels = 0;
87  int nStrips = 0;
88 
89  const SpacePointContainer* sctSpacePointsContainer = nullptr;
90  const SpacePointContainer* pixelSpacePointsContainer = nullptr;
91 
92  std::map<short, std::vector<IdentifierHash> > detIdMap;//relates global detector layer ID to constituent detector elements
93 
94  if (m_useSctSpacePoints) {
95 
96  SG::ReadHandle<SpacePointContainer> sctHandle(m_sctSpacePointsContainerKey, ctx);
97 
98  if(!sctHandle.isValid()) {
99  ATH_MSG_WARNING("Invalid Strip Spacepoints handle: "<<sctHandle);
100  return seedStats;
101 
102  }
103 
104  sctSpacePointsContainer = sctHandle.ptr();
105 
106  std::vector<IdentifierHash> listOfSctIds;
107  m_regsel_sct->lookup(ctx)->HashIDList( internalRoI, listOfSctIds );
108 
109  const std::vector<short>* h2l = m_layerNumberTool->sctLayers();
110 
111  for(const auto& hashId : listOfSctIds) {
112 
113  short layerIndex = h2l->at(static_cast<int>(hashId));
114 
115  auto it = detIdMap.find(layerIndex);
116  if(it != detIdMap.end()) (*it).second.push_back(hashId);
117  else {
118  std::vector<IdentifierHash> v = {hashId};
119  detIdMap.insert(std::make_pair(layerIndex,v));
120  }
121  }
122  }
123 
124  if (m_usePixelSpacePoints) {
125 
126  SG::ReadHandle<SpacePointContainer> pixHandle(m_pixelSpacePointsContainerKey, ctx);
127 
128  if(!pixHandle.isValid()) {
129  ATH_MSG_WARNING("Invalid Pixel Spacepoints handle: "<<pixHandle);
130  return seedStats;
131  }
132 
133  pixelSpacePointsContainer = pixHandle.ptr();
134 
135  std::vector<IdentifierHash> listOfPixIds;
136 
137  m_regsel_pix->lookup(ctx)->HashIDList( internalRoI, listOfPixIds );
138 
139  const std::vector<short>* h2l = m_layerNumberTool->pixelLayers();
140 
141  for(const auto& hashId : listOfPixIds) {
142 
143  short layerIndex = h2l->at(static_cast<int>(hashId));
144 
145  auto it = detIdMap.find(layerIndex);
146  if(it != detIdMap.end()) (*it).second.push_back(hashId);
147  else {
148  std::vector<IdentifierHash> v = {hashId};
149  detIdMap.insert(std::make_pair(layerIndex,v));
150  }
151  }
152  }
153 
154  if(!m_useGPU) {
155 
156  std::unique_ptr<GNN_DataStorage> storage = std::make_unique<GNN_DataStorage>(*m_geo, m_mlLUT);
157 
158  std::vector<const Trk::SpacePoint*> vSP;
159 
160  vSP.reserve(m_nMaxEdges);
161 
162  std::vector<std::vector<GNN_Node> > trigSpStorage[2];
163 
164  trigSpStorage[1].resize(m_layerNumberTool->sctLayers()->size());
165 
166  trigSpStorage[0].resize(m_layerNumberTool->pixelLayers()->size());
167 
168  for(const auto& lColl : detIdMap) {
169 
170  short layerIndex = lColl.first;
171 
172  int layerKey = m_geo->getTrigFTF_GNN_LayerByIndex(layerIndex)->m_layer.m_subdet;
173 
174  bool isPixel = layerKey > 20000;
175 
176  auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
177 
178  int contIdx= isPixel ? 0 : 1;
179 
180  int nNewNodes = 0;
181 
182  for(const auto& idx : lColl.second) {
183 
184  std::vector<GNN_Node>& tmpColl = trigSpStorage[contIdx].at(static_cast<int>(idx));
185 
186  auto input_coll = pCont->indexFindPtr(idx);
187 
188  if(input_coll == nullptr) continue;
189 
190  createGraphNodes(input_coll, tmpColl, vSP, layerIndex, shift_x, shift_y);//TO-DO: if(m_useBeamTilt) SP full transform functor
191 
192  nNewNodes += (isPixel) ? storage->loadPixelGraphNodes(layerIndex, tmpColl, m_useML) : storage->loadStripGraphNodes(layerIndex, tmpColl);
193  }
194 
195  if(isPixel) nPixels += nNewNodes;
196  else nStrips += nNewNodes;
197  }
198 
199  seedStats.m_nPixelSPs = nPixels;
200  seedStats.m_nStripSPs = nStrips;
201 
202  storage->sortByPhi();
203  storage->initializeNodes(m_useML);
204  storage->generatePhiIndexing(1.5*m_phiSliceWidth);
205 
206  std::vector<GNN_Edge> edgeStorage;
207 
208  std::pair<int, int> graphStats = buildTheGraph(internalRoI, storage, edgeStorage);
209 
210  ATH_MSG_DEBUG("Created graph with "<<graphStats.first<<" edges and "<<graphStats.second<< " edge links");
211 
212  seedStats.m_nGraphEdges = graphStats.first;
213  seedStats.m_nEdgeLinks = graphStats.second;
214 
215  if (graphStats.second == 0) return seedStats;
216 
217  int maxLevel = runCCA(graphStats.first, edgeStorage);
218 
219  ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
220 
221  std::vector<std::tuple<float, int, std::vector<unsigned int> > > vSeedCandidates;
222 
223  extractSeedsFromTheGraph(maxLevel, graphStats.first, vSP.size(), edgeStorage, vSeedCandidates);
224 
225  if (vSeedCandidates.empty()) return seedStats;
226 
227  for(const auto& seed : vSeedCandidates) {
228 
229  if (std::get<1>(seed) != 0) continue;//identified as a clone of a better candidate
230 
231  unsigned int lastIdx = output.size();
232  output.emplace_back(std::get<0>(seed));
233 
234  for(const auto& sp_idx : std::get<2>(seed)) {
235  output[lastIdx].addSpacePoint(vSP[sp_idx]);
236  }
237  }
238 
239  ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
240  }
241  else {//GPU-accelerated graph building
242  //1. data export
243 
244  std::vector<const Trk::SpacePoint*> vSP;
245  std::vector<short> vL;
246 
247  vSP.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
248  vL.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
249 
250  std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER> dataBuffer = std::unique_ptr<TrigAccel::DATA_EXPORT_BUFFER>(new TrigAccel::DATA_EXPORT_BUFFER(5000));
251 
252  size_t dataTypeSize = sizeof(TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA);
253  const size_t bufferOffset = 256;
254  size_t totalSize = bufferOffset+dataTypeSize;//make room for the header
255  if(!dataBuffer->fit(totalSize)) dataBuffer->reallocate(totalSize);
256 
257  TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA* pJobData = reinterpret_cast<TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA*>(dataBuffer->m_buffer + bufferOffset);
258 
259  unsigned int spIdx = 0;
260  int sp_offset = 0;
261  int nLayers = 0;
262  int MaxEtaBin = 0;
263  int nEtaBins = 0;
264 
265  for(const auto& lColl : detIdMap) {
266 
267  short layerIndex = lColl.first;
268 
269  const TrigFTF_GNN_Layer* pL = m_geo->getTrigFTF_GNN_LayerByIndex(layerIndex);
270 
271  int layerKey = pL->m_layer.m_subdet;
272 
273  bool isPixel = layerKey > 20000;
274  bool isBarrel = (pL->m_layer.m_type == 0);
275 
276  auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
277 
278  pJobData->m_layerIdx[nLayers] = layerIndex;
279 
280  pJobData->m_layerInfo[4*nLayers ] = spIdx;//layerInfo.x
281  pJobData->m_layerInfo[4*nLayers + 2] = pL->num_bins();//layerInfo.z
282  pJobData->m_layerInfo[4*nLayers + 3] = pL->m_bins[0];//layerInfo.w
283 
284  pJobData->m_layerGeo[2*nLayers ] = pL->m_minEta;//layerGeo.x
285  pJobData->m_layerGeo[2*nLayers + 1] = pL->m_etaBin;//layerGeo.y
286 
287  nEtaBins += pL->m_bins.size();
288 
289  for(auto b : pL->m_bins) {
290  if(b > MaxEtaBin) MaxEtaBin = b;
291  }
292 
293  for(const auto& idx : lColl.second) {
294 
295  auto input_coll = pCont->indexFindPtr(idx);
296 
297  if(input_coll == nullptr) continue;
298 
299  for(const auto sp : *input_coll) {
300 
301  float cw = -1.0;
302 
303  const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
304  if(pCL != nullptr) {
305  cw = pCL->width().widthPhiRZ().y();
306  if(!isBarrel && m_useML) {
307  if(cw > 0.2) continue;
308  cw = -1.0;//set it to -1 so that it can be skipped later in the ML code on GPU
309  }
310  }
311 
312  vSP.emplace_back(sp);
313  vL.emplace_back(layerIndex);
314 
315  const auto& p = sp->globalPosition();
316 
317  float params[4] = {(float)(p.x() - shift_x), float(p.y() - shift_y), (float)(p.z()), cw};
318 
319  memcpy(&pJobData->m_params[sp_offset], &params[0], sizeof(params));
320 
321  sp_offset += 4;
322  spIdx++;
323  if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
324  }
325  if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
326  }
327 
328  pJobData->m_layerInfo[4*nLayers + 1] = spIdx;//layerInfo.y
329 
330  if (isPixel) nPixels += spIdx - pJobData->m_layerInfo[4*nLayers];
331  else nStrips += spIdx - pJobData->m_layerInfo[4*nLayers];
332 
333  nLayers++;
334  }
335 
336  if(spIdx == 0) return seedStats;
337 
338  pJobData->m_nSpacepoints = spIdx;
339  pJobData->m_nLayers = nLayers;
340  pJobData->m_nEtaBins = nEtaBins;
341  pJobData->m_maxEtaBin = MaxEtaBin;
342  pJobData->m_nMaxEdges = static_cast<unsigned int>(7*spIdx);
343 
344  //load bin pairs
345 
346  int pairIdx = 0;
347 
348  for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
349 
350  int bin1_idx = bg.first;
351 
352  for(const auto& bin2_idx : bg.second) {
353  pJobData->m_bin_pairs[2*pairIdx ] = bin1_idx;
354  pJobData->m_bin_pairs[2*pairIdx+1] = bin2_idx;
355  pairIdx++;
356  }
357  }
358 
359  pJobData->m_nBinPairs = pairIdx;
360 
361  //add algorithm parameters
362 
363  const float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
364 
365  float tripletPtMin = 0.8*m_minPt;//correction due to limited pT resolution
366 
367  float maxCurv = ptCoeff/tripletPtMin;
368 
369  const float pt_scale = 900/m_minPt;
370 
371  const float min_deltaPhi_low_dr = 0.002*pt_scale;
372  const float dphi_coeff_low_dr = 4.33e-4*pt_scale;
373  const float min_deltaPhi = 0.015*pt_scale;
374  const float dphi_coeff = 2.2e-4*pt_scale;
375 
376  const float cut_dphi_max = m_LRTmode ? 0.07 : 0.012;
377  const float cut_dcurv_max = m_LRTmode ? 0.015 : 0.001;
378  const float cut_tau_ratio_max = m_LRTmode ? 0.015f : 0.01;
379  const float min_z0 = m_LRTmode ? -600.0 : internalRoI.zedMinus();
380  const float max_z0 = m_LRTmode ? 600.0 : internalRoI.zedPlus();
381 
382  const float maxOuterRadius = m_LRTmode ? 1050.0 : 550.0;
383  const float minDeltaRadius = 2.0;
384 
385  const float cut_zMinU = min_z0 + maxOuterRadius*internalRoI.dzdrMinus();
386  const float cut_zMaxU = max_z0 + maxOuterRadius*internalRoI.dzdrPlus();
387 
388  const float maxKappa = m_LRTmode ? 1.0*maxCurv : 0.9*maxCurv;
389 
390  pJobData->m_algo_params[0] = min_deltaPhi;
391  pJobData->m_algo_params[1] = dphi_coeff;
392  pJobData->m_algo_params[2] = min_deltaPhi_low_dr;
393  pJobData->m_algo_params[3] = dphi_coeff_low_dr;
394  pJobData->m_algo_params[4] = minDeltaRadius;
395  pJobData->m_algo_params[5] = min_z0;
396  pJobData->m_algo_params[6] = max_z0;
397  pJobData->m_algo_params[7] = maxOuterRadius;
398  pJobData->m_algo_params[8] = cut_zMinU;
399  pJobData->m_algo_params[9] = cut_zMaxU;
400  pJobData->m_algo_params[10] = maxKappa;
401  pJobData->m_algo_params[11] = cut_dphi_max;
402  pJobData->m_algo_params[12] = cut_dcurv_max;
403  pJobData->m_algo_params[13] = cut_tau_ratio_max;
404 
405  int minLevel = 3;//a triplet + 1 confirmation
406 
407  if(m_LRTmode) {
408  minLevel = 2;//a triplet
409  }
410 
411  pJobData->m_minLevel = minLevel;
412 
413  pJobData->m_useGPUseedExtraction = m_useGPUseedExtraction;
414 
415  seedStats.m_nPixelSPs = nPixels;
416  seedStats.m_nStripSPs = nStrips;
417 
418  ATH_MSG_DEBUG("Loaded "<<nPixels<< " Pixel Spacepoints and "<<nStrips<< " Strip SpacePoints");
419 
420  std::shared_ptr<TrigAccel::OffloadBuffer> pBuff = std::make_shared<TrigAccel::OffloadBuffer>(dataBuffer.get());
421 
422  std::unique_ptr<TrigAccel::Work> pWork = std::unique_ptr<TrigAccel::Work>(m_accelSvc->createWork(TrigAccel::InDetJobControlCode::RUN_GBTS, pBuff));
423 
424  if(!pWork) {
425  ATH_MSG_WARNING("Failed to create a work item for task "<<TrigAccel::InDetJobControlCode::RUN_GBTS);
426  return seedStats;
427  }
428 
429  bool workSuccess = pWork->run();
430  if(!workSuccess) {
431  ATH_MSG_WARNING("Work item failed to complete");
432  return seedStats;
433  }
434 
435  std::shared_ptr<TrigAccel::OffloadBuffer> pOutput = pWork->getOutput();
436 
437  TrigAccel::ITk::GRAPH_AND_SEEDS_OUTPUT* pGraphAndSeeds = reinterpret_cast<TrigAccel::ITk::GRAPH_AND_SEEDS_OUTPUT*>(pOutput->m_rawBuffer);
438  TrigAccel::ITk::COMPRESSED_GRAPH* pGraph = &pGraphAndSeeds->m_CompressedGraph;
439  TrigAccel::ITk::OUTPUT_SEEDS* pSeeds = &pGraphAndSeeds->m_OutputSeeds;
440 
441  if(m_useGPUseedExtraction) {
442  if(pSeeds->m_nSeeds == 0) return seedStats;
443  //converting tracklet into GBTS-CPU format
444  for(unsigned int seed=0; seed<pSeeds->m_nSeeds; seed++) {
445 
446  unsigned int lastIdx = output.size();
447  output.emplace_back(pSeeds->m_seedsArray[seed].m_Q);
448  for(int node=0; node<pSeeds->m_seedsArray[seed].m_size; node++) {
449  output[lastIdx].addSpacePoint(vSP[pSeeds->m_seedsArray[seed].m_nodes[node]]);
450  }
451  }
452  }
453  else {
454 
455  unsigned int nEdges = pGraph->m_nEdges;
456  unsigned int nMaxNei = pGraph->m_nMaxNeighbours;
457 
458  //populating the edgeStorage
459 
460  std::vector<GNN_Node> nodes;
461 
462  nodes.reserve(vSP.size());
463 
464  for(unsigned int idx = 0;idx < vSP.size(); idx++) {
465 
466  nodes.emplace_back(vL[idx]);
467 
468  const auto& pos = vSP[idx]->globalPosition();
469  float xs = pos.x() - shift_x;
470  float ys = pos.y() - shift_y;
471  float zs = pos.z();
472 
473  nodes[idx].m_x = xs;
474  nodes[idx].m_y = ys;
475  nodes[idx].m_z = zs;
476  nodes[idx].m_r = std::sqrt(xs*xs + ys*ys);
477 
478  nodes[idx].m_idx = idx;
479 
480  }
481 
482  std::vector<GNN_Edge> edgeStorage;
483 
484  std::pair<int, int> graphStats(0,0);
485 
486  edgeStorage.resize(nEdges);
487 
488  unsigned int edgeSize = nMaxNei + 1 + 2;//neigbours, num_neighbours, 2 nodes
489 
490  for(unsigned int idx=0;idx<nEdges;idx++) {
491  unsigned int pos = idx*edgeSize;
492 
493  int node1Idx = pGraph->m_graphArray[pos + TrigAccel::ITk::node1];
494  int node2Idx = pGraph->m_graphArray[pos + TrigAccel::ITk::node2];
495  int nNei = pGraph->m_graphArray[pos + TrigAccel::ITk::nNei];
496 
497  if(nNei > N_SEG_CONNS) nNei = N_SEG_CONNS;
498 
499  edgeStorage[idx].m_n1 = &nodes[node1Idx];
500  edgeStorage[idx].m_n2 = &nodes[node2Idx];
501  edgeStorage[idx].m_level = 1;
502  edgeStorage[idx].m_nNei = nNei;
503  for(int k=0;k<nNei;k++) {
504  edgeStorage[idx].m_vNei[k] = pGraph->m_graphArray[pos + TrigAccel::ITk::nei_idx_start + k];
505  }
506  }
507 
508  graphStats.first = nEdges;
509  graphStats.second = pGraph->m_nLinks;
510 
511  //run the rest of the GBTS workflow
512 
513  int maxLevel = runCCA(graphStats.first, edgeStorage);
514 
515  ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
516 
517  if(maxLevel < minLevel) return seedStats;
518 
519  std::vector<GNN_Edge*> vSeeds;
520 
521  vSeeds.reserve(graphStats.first/2);
522 
523  for(int edgeIndex=0;edgeIndex<graphStats.first;edgeIndex++) {
524  GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
525 
526  if(pS->m_level < minLevel) continue;
527 
528  vSeeds.push_back(pS);
529  }
530 
531  if(vSeeds.empty()) return seedStats;
532 
533  std::sort(vSeeds.begin(), vSeeds.end(), GNN_Edge::CompareLevel());
534 
535  //backtracking
536 
537  TrigFTF_GNN_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
538 
539  output.reserve(vSeeds.size());
540 
541  for(auto pS : vSeeds) {
542 
543  if(pS->m_level == -1) continue;
544 
545  TrigFTF_GNN_EdgeState rs(false);
546 
547  tFilter.followTrack(pS, rs);
548 
549  if(!rs.m_initialized) {
550  continue;
551  }
552 
553  if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
554 
555  std::vector<const GNN_Node*> vN;
556 
557  for(std::vector<GNN_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
558 
559  (*sIt)->m_level = -1;//mark as collected
560 
561  if(sIt == rs.m_vs.rbegin()) {
562  vN.push_back((*sIt)->m_n1);
563  }
564  vN.push_back((*sIt)->m_n2);
565  }
566 
567  if(vN.size()<3) continue;
568 
569  unsigned int lastIdx = output.size();
570  output.emplace_back(rs.m_J);
571 
572  for(const auto& n : vN) {
573  output[lastIdx].addSpacePoint(vSP[n->m_idx]);
574  }
575  }
576  }
577  ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
578  }
579  return seedStats;
580 }

◆ initialize()

StatusCode TrigInDetTrackSeedingTool::initialize ( )
overridevirtual

Reimplemented from SeedingToolBase.

Definition at line 34 of file TrigInDetTrackSeedingTool.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(m_useGPU) {//for GPU offloading
44  ATH_CHECK(m_accelSvc.retrieve());
45  ATH_CHECK(m_accelSvc->isReady());
46  }
47 
48  if (!m_usePixelSpacePoints && !m_useSctSpacePoints) {
49  ATH_MSG_FATAL("Both usePixelSpacePoints and useSctSpacePoints set to False. At least one needs to be True");
50  return StatusCode::FAILURE;
51  }
52 
53  if (!m_useSctSpacePoints) ATH_MSG_INFO("Only using Pixel spacepoints => Pixel seeds only");
54 
55  if (!m_usePixelSpacePoints) ATH_MSG_INFO("Only using SCT spacepoints => Strip seeds only");
56 
57  if (m_usePixelSpacePoints && m_useSctSpacePoints) ATH_MSG_INFO("Using SCT and Pixel spacepoints");
58 
59  ATH_CHECK(m_pixelSpacePointsContainerKey.initialize(m_usePixelSpacePoints));
60 
61  ATH_CHECK(m_sctSpacePointsContainerKey.initialize(m_useSctSpacePoints));
62 
63  ATH_MSG_INFO("TrigInDetTrackSeedingTool initialized with " << m_useGPU);
64 
65  return StatusCode::SUCCESS;
66 }

◆ 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() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ 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  }

◆ 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 348 of file TrigInDetPattRecoTools/src/SeedingToolBase.cxx.

348  {
349 
350  constexpr int maxIter = 15;
351 
352  int maxLevel = 0;
353 
354  int iter = 0;
355 
356  std::vector<TrigFTF_GNN_Edge*> v_old;
357 
358  for(int edgeIndex=0;edgeIndex<nEdges;edgeIndex++) {
359 
360  TrigFTF_GNN_Edge* pS = &(edgeStorage[edgeIndex]);
361  if(pS->m_nNei == 0) continue;
362 
363  v_old.push_back(pS);//TO-DO: increment level for segments as they already have at least one neighbour
364  }
365 
366  std::vector<TrigFTF_GNN_Edge*> v_new;
367  v_new.reserve(v_old.size());
368 
369  for(;iter<maxIter;iter++) {
370 
371  //generate proposals
372  v_new.clear();
373 
374  for(auto pS : v_old) {
375 
376  int next_level = pS->m_level;
377 
378  for(int nIdx=0;nIdx<pS->m_nNei;nIdx++) {
379 
380  unsigned int nextEdgeIdx = pS->m_vNei[nIdx];
381 
382  TrigFTF_GNN_Edge* pN = &(edgeStorage[nextEdgeIdx]);
383 
384  if(pS->m_level == pN->m_level) {
385  next_level = pS->m_level + 1;
386  v_new.push_back(pS);
387  break;
388  }
389  }
390 
391  pS->m_next = next_level;//proposal
392  }
393 
394  //update
395 
396  int nChanges = 0;
397 
398  for(auto pS : v_new) {
399  if(pS->m_next != pS->m_level) {
400  nChanges++;
401  pS->m_level = pS->m_next;
402  if(maxLevel < pS->m_level) maxLevel = pS->m_level;
403  }
404  }
405 
406  if(nChanges == 0) break;
407 
408 
409  v_old.swap(v_new);
410  v_new.clear();
411  }
412 
413  return maxLevel;
414 }

◆ 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 }

◆ 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 DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ 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  }

Member Data Documentation

◆ m_accelSvc

ServiceHandle<ITrigInDetAccelerationSvc> TrigInDetTrackSeedingTool::m_accelSvc {this, "TrigAccelerationSvc", ""}
protected

Definition at line 72 of file TrigInDetTrackSeedingTool.h.

◆ m_atlasId

const AtlasDetectorID * SeedingToolBase::m_atlasId = nullptr
protectedinherited

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

◆ m_beamSpotKey

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

Definition at line 55 of file TrigInDetTrackSeedingTool.h.

◆ m_connectionFile

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

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

◆ m_connector [1/2]

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

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

◆ m_connector [2/2]

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

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

◆ 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 60 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ 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 64 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ 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 54 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_geo [1/2]

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

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

◆ m_geo [2/2]

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

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

◆ m_layerGeometry

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

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

◆ m_layerNumberTool

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

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

◆ m_LRTmode

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

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

◆ m_lutFile

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

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

◆ m_matchBeforeCreate

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

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

◆ m_minPt

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

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

◆ m_mlLUT

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

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

◆ m_nBufferEdges

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

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

◆ m_nMaxEdges

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

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

◆ m_nMaxPhiSlice

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

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

◆ m_phiSliceWidth

float SeedingToolBase::m_phiSliceWidth = 0.
protectedinherited

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

◆ m_pixelId

const PixelID * SeedingToolBase::m_pixelId = nullptr
protectedinherited

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

◆ m_pixelSpacePointsContainerKey

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

Definition at line 62 of file TrigInDetTrackSeedingTool.h.

◆ m_regsel_pix

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

region selector tools

Definition at line 66 of file TrigInDetTrackSeedingTool.h.

◆ m_regsel_sct

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

Definition at line 67 of file TrigInDetTrackSeedingTool.h.

◆ m_sctId

const SCT_ID * SeedingToolBase::m_sctId = nullptr
protectedinherited

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

◆ m_sctSpacePointsContainerKey

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

Definition at line 61 of file TrigInDetTrackSeedingTool.h.

◆ m_tau_ratio_cut

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

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

◆ m_useBeamTilt

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

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

◆ m_useEtaBinning

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

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

◆ m_useGPU

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

Definition at line 71 of file TrigInDetTrackSeedingTool.h.

◆ m_useGPUseedExtraction

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

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

◆ m_useML

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

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

◆ m_useOldTunings

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

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

◆ m_usePixelSpacePoints

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

Definition at line 57 of file TrigInDetTrackSeedingTool.h.

◆ m_useSctSpacePoints

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

Definition at line 58 of file TrigInDetTrackSeedingTool.h.

◆ 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:
TrigFTF_GNN_EtaBin
Definition: GNN_DataStorage.h:41
TrigInDetTrackSeedingTool::m_accelSvc
ServiceHandle< ITrigInDetAccelerationSvc > m_accelSvc
Definition: TrigInDetTrackSeedingTool.h:72
SeedingToolBase::m_layerGeometry
std::vector< TrigInDetSiLayer > m_layerGeometry
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:78
SeedingToolBase::m_matchBeforeCreate
BooleanProperty m_matchBeforeCreate
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:62
TrigAccel::ITk::GraphAndSeedsOutput::m_OutputSeeds
OUTPUT_SEEDS m_OutputSeeds
Definition: TrigITkAccelEDM.h:182
TrigInDetTrackSeedingResult::m_nStripSPs
int m_nStripSPs
Definition: TrigInDetTrackSeedingResult.h:12
TrigAccel::ITk::CompressedGraph::m_nEdges
unsigned int m_nEdges
Definition: TrigITkAccelEDM.h:157
TrigAccel::DataExportBuffer
Definition: DataExportBuffer.h:14
TrigAccel::ITk::GraphMakingInputData
Definition: TrigITkAccelEDM.h:126
TrigAccel::DataExportBuffer::fit
bool fit(size_t s)
Definition: DataExportBuffer.h:26
createLinkingScheme.iter
iter
Definition: createLinkingScheme.py:62
TrigFTF_GNN_EtaBin::m_in
std::vector< std::vector< unsigned int > > m_in
Definition: GNN_DataStorage.h:73
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SeedingToolBase::initialize
virtual StatusCode initialize()
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:24
TrigInDetTrackSeedingTool::m_useSctSpacePoints
BooleanProperty m_useSctSpacePoints
Definition: TrigInDetTrackSeedingTool.h:58
StandaloneBunchgroupHandler.bg
bg
Definition: StandaloneBunchgroupHandler.py:241
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TCS::KFMET::nEtaBins
constexpr unsigned nEtaBins
Definition: KalmanMETCorrectionConstants.h:18
TrigInDetTrackSeedingTool::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: TrigInDetTrackSeedingTool.h:55
TrigAccel::DataExportBuffer::reallocate
void reallocate(size_t s)
Definition: DataExportBuffer.h:30
TrigAccel::ITk::GraphMakingInputData::m_layerIdx
int m_layerIdx[GBTS_MAX_SILICON_LAYERS]
Definition: TrigITkAccelEDM.h:133
TrigFTF_GNN_DataStorage::sortByPhi
void sortByPhi()
Definition: GNN_DataStorage.cxx:178
TrigAccel::Work::run
virtual bool run()=0
SG::ReadHandle< SpacePointContainer >
TrigAccel::ITk::OutputSeeds::m_nSeeds
unsigned int m_nSeeds
Definition: TrigITkAccelEDM.h:173
TrigFTF_GNN_EdgeState
Definition: GNN_TrackingFilter.h:11
xAOD::deltaPhi
setSAddress setEtaMS setDirPhiMS setDirZMS setBarrelRadius setEndcapAlpha setEndcapRadius setInterceptInner setEtaMap setEtaBin setIsTgcFailure setDeltaPt deltaPhi
Definition: L2StandAloneMuon_v1.cxx:161
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
InDet::SiWidth::widthPhiRZ
const Amg::Vector2D & widthPhiRZ() const
Definition: SiWidth.h:121
TrigFTF_GNN_Edge::m_vNei
unsigned int m_vNei[N_SEG_CONNS]
Definition: GNN_DataStorage.h:135
TrigFTF_GNNR3_Edge
Definition: GNNR3_DataStorage.h:106
TrigFTF_GNNR3_EtaBin::m_params
std::vector< std::array< float, 5 > > m_params
Definition: GNNR3_DataStorage.h:73
SeedingToolBase::m_nMaxEdges
IntegerProperty m_nMaxEdges
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:65
TrigAccel::Work::getOutput
virtual std::shared_ptr< OffloadBuffer > getOutput()=0
skel.it
it
Definition: skel.GENtoEVGEN.py:407
TrigFTF_GNNR3_EtaBin::getMaxBinRadius
float getMaxBinRadius() const
Definition: GNNR3_DataStorage.h:66
M_PI
#define M_PI
Definition: ActiveFraction.h:11
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
TrigFTF_GNN_Layer::m_bins
std::vector< int > m_bins
Definition: GNN_Geometry.h:31
TrigFTF_GNNR3_Edge::m_level
signed char m_level
Definition: GNNR3_DataStorage.h:128
TrigFTF_GNNR3_EtaBin::getMinBinRadius
float getMinBinRadius() const
Definition: GNNR3_DataStorage.h:62
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:111
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SeedingToolBase::GNN_Node
TrigFTF_GNN_Node GNN_Node
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:35
MCP::ScaleSmearParam::r2
@ r2
TauClusterVars::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::CaloVertexedTopoCluster &cluster, float &out)
Definition: ConstituentLoaderTauCluster.cxx:119
IRoiDescriptor::dzdrMinus
virtual double dzdrMinus() const =0
return the gradients
SeedingToolBase::m_mlLUT
std::vector< std::array< float, 5 > > m_mlLUT
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:80
TrigInDetTrackSeedingTool::m_usePixelSpacePoints
BooleanProperty m_usePixelSpacePoints
Definition: TrigInDetTrackSeedingTool.h:57
TrigFTF_GNNR3_DataStorage::getEtaBin
TrigFTF_GNNR3_EtaBin & getEtaBin(int idx)
Definition: GNNR3_DataStorage.h:93
TrigAccel::RUN_GBTS
@ RUN_GBTS
Definition: TrigInDetAccelCodes.h:31
TrigInDetTrackSeedingTool::m_regsel_pix
ToolHandle< IRegSelTool > m_regsel_pix
region selector tools
Definition: TrigInDetTrackSeedingTool.h:66
TrigInDetTrackSeedingTool::m_useGPU
BooleanProperty m_useGPU
Definition: TrigInDetTrackSeedingTool.h:71
IRoiDescriptor::dzdrPlus
virtual double dzdrPlus() const =0
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
TrigFTF_GNNR3_Edge::m_next
signed char m_next
Definition: GNNR3_DataStorage.h:128
TrigAccel::ITk::GraphAndSeedsOutput
Definition: TrigITkAccelEDM.h:179
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
N_SEG_CONNS
#define N_SEG_CONNS
Definition: GNN_DataStorage.h:14
SeedingToolBase::extractSeedsFromTheGraph
void extractSeedsFromTheGraph(int, int, int, std::vector< GNN_Edge > &, std::vector< std::tuple< float, int, std::vector< unsigned int > > > &) const
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:416
TrigFTF_GNN_EtaBin::empty
bool empty() const
Definition: GNN_DataStorage.h:57
TrigFTF_GNNR3_EtaBin::empty
bool empty() const
Definition: GNNR3_DataStorage.h:56
SeedingToolBase::m_useGPUseedExtraction
BooleanProperty m_useGPUseedExtraction
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:70
TrigAccel::ITk::GraphAndSeedsOutput::m_CompressedGraph
COMPRESSED_GRAPH m_CompressedGraph
Definition: TrigITkAccelEDM.h:181
SeedingToolBase::GNN_Edge
TrigFTF_GNN_Edge GNN_Edge
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:37
TrigFTF_GNN_Edge::m_next
signed char m_next
Definition: GNN_DataStorage.h:130
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
SeedingToolBase::SeedingToolBase
SeedingToolBase(const std::string &t, const std::string &n, const IInterface *p)
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:31
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Generate_dsid_ranseed.seed
seed
Definition: Generate_dsid_ranseed.py:10
SeedingToolBase::m_LRTmode
BooleanProperty m_LRTmode
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:56
TrigFTF_GNN_Edge
Definition: GNN_DataStorage.h:108
TrigFTF_GNN_DataStorage::generatePhiIndexing
void generatePhiIndexing(float)
Definition: GNN_DataStorage.cxx:257
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TrigAccel::ITk::GraphMakingInputData::m_nEtaBins
unsigned int m_nEtaBins
Definition: TrigITkAccelEDM.h:129
TrigInDetTrackSeedingTool::m_sctSpacePointsContainerKey
SG::ReadHandleKey< SpacePointContainer > m_sctSpacePointsContainerKey
Definition: TrigInDetTrackSeedingTool.h:61
TrigInDetTrackSeedingTool::m_regsel_sct
ToolHandle< IRegSelTool > m_regsel_sct
Definition: TrigInDetTrackSeedingTool.h:67
TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA
struct TrigAccel::ITk::GraphMakingInputData GRAPH_MAKING_INPUT_DATA
TrigFTF_GNN_EtaBin::m_vPhiNodes
std::vector< std::pair< float, unsigned int > > m_vPhiNodes
Definition: GNN_DataStorage.h:72
TrigAccel::ITk::OutputSeeds::m_seedsArray
std::unique_ptr< Tracklet[]> m_seedsArray
Definition: TrigITkAccelEDM.h:175
TrigFTF_GNN_Edge::m_level
signed char m_level
Definition: GNN_DataStorage.h:130
SeedingToolBase::m_minPt
FloatProperty m_minPt
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:63
TrigFTF_GNN_EtaBin::m_layerKey
unsigned int m_layerKey
Definition: GNN_DataStorage.h:77
beamspotman.n
n
Definition: beamspotman.py:727
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
TrigAccel::ITk::GraphMakingInputData::m_params
float m_params[4 *GBTS_MAX_NUMBER_SPACEPOINTS]
Definition: TrigITkAccelEDM.h:131
TrigFTF_GNN_Layer::m_layer
const TrigInDetSiLayer & m_layer
Definition: GNN_Geometry.h:30
TrigAccel::ITk::GraphMakingInputData::m_nSpacepoints
unsigned int m_nSpacepoints
Definition: TrigITkAccelEDM.h:129
SeedingToolBase::finalize
virtual StatusCode finalize()
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:93
TrigAccel::ITk::GraphMakingInputData::m_minLevel
int m_minLevel
Definition: TrigITkAccelEDM.h:149
TrigAccel::ITk::CompressedGraph::m_nLinks
unsigned int m_nLinks
Definition: TrigITkAccelEDM.h:160
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
hist_file_dump.f
f
Definition: hist_file_dump.py:140
MAX_SEG_PER_NODE
#define MAX_SEG_PER_NODE
Definition: GNN_DataStorage.h:13
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
TrigAccel::ITk::GraphMakingInputData::m_maxEtaBin
unsigned int m_maxEtaBin
Definition: TrigITkAccelEDM.h:129
TrigFTF_GNN_Layer::m_etaBin
float m_etaBin
Definition: GNN_Geometry.h:37
TrigFTF_GNN_DataStorage::getEtaBin
TrigFTF_GNN_EtaBin & getEtaBin(int idx)
Definition: GNN_DataStorage.h:94
TrigAccel::ITk::GraphMakingInputData::m_bin_pairs
int m_bin_pairs[2 *GBTS_MAX_ETA_BIN_PAIR]
Definition: TrigITkAccelEDM.h:145
TrigFTF_GNN_DataStorage::loadPixelGraphNodes
int loadPixelGraphNodes(short, const std::vector< TrigFTF_GNN_Node > &, bool)
Definition: GNN_DataStorage.cxx:105
TrigFTF_GNNR3_EtaBin::m_vn
std::vector< const TrigFTF_GNNR3_Node * > m_vn
Definition: GNNR3_DataStorage.h:70
TrigFTF_GNN_EtaBin::getMaxBinRadius
float getMaxBinRadius() const
Definition: GNN_DataStorage.h:67
SeedingToolBase::m_doubletFilterRZ
BooleanProperty m_doubletFilterRZ
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:60
TrigFTF_GNN_Layer::m_minEta
float m_minEta
Definition: GNN_Geometry.h:37
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
TrigInDetSiLayer::m_type
int m_type
Definition: TrigInDetSiLayer.h:11
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge.output
output
Definition: merge.py:16
SeedingToolBase::m_layerNumberTool
ToolHandle< ITrigL2LayerNumberTool > m_layerNumberTool
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:48
MuonGM::nStrips
int nStrips(const MuonGM::TgcReadoutElement &readoutEle, int layer)
Definition: MuonDetDescr/MuonGeoModelTest/src/GeoModelTgcTest.cxx:46
SeedingToolBase::m_useEtaBinning
BooleanProperty m_useEtaBinning
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:61
TrigAccel::ITk::GraphMakingInputData::m_layerInfo
int m_layerInfo[4 *GBTS_MAX_SILICON_LAYERS]
Definition: TrigITkAccelEDM.h:137
TrigFTF_GNN_DataStorage::initializeNodes
void initializeNodes(bool)
Definition: GNN_DataStorage.cxx:183
TrigAccel::ITk::GraphMakingInputData::m_nMaxEdges
unsigned int m_nMaxEdges
Definition: TrigITkAccelEDM.h:129
SeedingToolBase::m_geo
std::unique_ptr< const TrigFTF_GNN_Geometry > m_geo
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:79
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
TrigFTF_GNN_Layer
Definition: GNN_Geometry.h:16
TrigInDetTrackSeedingResult::m_nPixelSPs
int m_nPixelSPs
Definition: TrigInDetTrackSeedingResult.h:10
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
Trk::PrepRawData::localPosition
const Amg::Vector2D & localPosition() const
return the local position reference
TrigAccel::ITk::GraphMakingInputData::m_layerGeo
float m_layerGeo[2 *GBTS_MAX_SILICON_LAYERS]
Definition: TrigITkAccelEDM.h:141
SeedingToolBase::m_phiSliceWidth
float m_phiSliceWidth
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:75
TrigInDetTrackSeedingTool::createGraphNodes
void createGraphNodes(const SpacePointCollection *, std::vector< GNN_Node > &, std::vector< const Trk::SpacePoint * > &, unsigned short, float, float) const
Definition: TrigInDetTrackSeedingTool.cxx:582
TrigInDetTrackSeedingResult
Definition: TrigInDetTrackSeedingResult.h:8
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TrigFTF_GNNR3_Edge::m_vNei
unsigned int m_vNei[N_SEG_CONNS]
Definition: GNNR3_DataStorage.h:133
TrigAccel::ITk::GraphMakingInputData::m_nBinPairs
unsigned int m_nBinPairs
Definition: TrigITkAccelEDM.h:129
TrigInDetTrackSeedingResult::m_nGraphEdges
int m_nGraphEdges
Definition: TrigInDetTrackSeedingResult.h:12
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
TrigAccel::ITk::CompressedGraph::m_graphArray
std::unique_ptr< int[]> m_graphArray
Definition: TrigITkAccelEDM.h:161
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
TrigFTF_GNN_Edge::m_nNei
unsigned char m_nNei
Definition: GNN_DataStorage.h:132
TrigFTF_GNNR3_EtaBin::m_vPhiNodes
std::vector< std::pair< float, unsigned int > > m_vPhiNodes
Definition: GNNR3_DataStorage.h:71
TrigAccel::DataExportBuffer::m_buffer
char * m_buffer
Definition: DataExportBuffer.h:57
InDet::PixelCluster
Definition: InnerDetector/InDetRecEvent/InDetPrepRawData/InDetPrepRawData/PixelCluster.h:49
python.PyAthena.v
v
Definition: PyAthena.py:154
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
TrigAccel::ITk::GraphMakingInputData::m_useGPUseedExtraction
bool m_useGPUseedExtraction
Definition: TrigITkAccelEDM.h:151
InDet::SiCluster::width
const InDet::SiWidth & width() const
return width class reference
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigAccel::OffloadBuffer::m_rawBuffer
unsigned char * m_rawBuffer
Definition: OffloadBuffer.h:39
h
TrigAccel::ITk::GraphMakingInputData::m_algo_params
float m_algo_params[32]
Definition: TrigITkAccelEDM.h:147
IRoiDescriptor::zedPlus
virtual double zedPlus() const =0
the zed and eta values at the most forward and most rear ends of the RoI
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TrigFTF_GNNR3_EtaBin
Definition: GNNR3_DataStorage.h:40
TrigAccel::ITk::CompressedGraph
Definition: TrigITkAccelEDM.h:155
TrigFTF_GNN_Layer::num_bins
int num_bins() const
Definition: GNN_Geometry.h:26
TrigFTF_GNNR3_EtaBin::m_in
std::vector< std::vector< unsigned int > > m_in
Definition: GNNR3_DataStorage.h:72
TrigFTF_GNN_Edge::m_p
float m_p[3]
Definition: GNN_DataStorage.h:133
TrigFTF_GNNR3_Edge::m_p
float m_p[3]
Definition: GNNR3_DataStorage.h:131
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
TrigAccel::ITk::OutputSeeds
Definition: TrigITkAccelEDM.h:171
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
TrigFTF_GNN_DataStorage::loadStripGraphNodes
int loadStripGraphNodes(short, const std::vector< TrigFTF_GNN_Node > &)
Definition: GNN_DataStorage.cxx:143
IRoiDescriptor::zedMinus
virtual double zedMinus() const =0
SeedingToolBase::m_useML
BooleanProperty m_useML
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:57
TrigAccel::ITk::GraphMakingInputData::m_nLayers
unsigned int m_nLayers
Definition: TrigITkAccelEDM.h:129
python.copyTCTOutput.totalSize
totalSize
Definition: copyTCTOutput.py:90
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
TrigFTF_GNNR3_Edge::m_nNei
unsigned char m_nNei
Definition: GNNR3_DataStorage.h:130
SpacePointContainer
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePointContainer.h:29
SeedingToolBase::m_useOldTunings
BooleanProperty m_useOldTunings
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:71
TrigInDetTrackSeedingTool::m_pixelSpacePointsContainerKey
SG::ReadHandleKey< SpacePointContainer > m_pixelSpacePointsContainerKey
Definition: TrigInDetTrackSeedingTool.h:62
M_2PI
#define M_2PI
Definition: CaloGpuGeneral_fnc.cxx:11
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
TrigAccel::ITk::CompressedGraph::m_nMaxNeighbours
unsigned int m_nMaxNeighbours
Definition: TrigITkAccelEDM.h:159
MCP::ScaleSmearParam::r1
@ r1
TrigFTF_GNN_EtaBin::m_vn
std::vector< const TrigFTF_GNN_Node * > m_vn
Definition: GNN_DataStorage.h:71
SeedingToolBase::m_tau_ratio_cut
FloatProperty m_tau_ratio_cut
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:73
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
SeedingToolBase::runCCA
int runCCA(int, std::vector< GNN_Edge > &) const
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:348
InDet::SiWidth::z
double z() const
Definition: SiWidth.h:131
node
Definition: node.h:21
TrigInDetSiLayer::m_subdet
int m_subdet
Definition: TrigInDetSiLayer.h:10
fitman.k
k
Definition: fitman.py:528
TrigFTF_GNN_EtaBin::getMinBinRadius
float getMinBinRadius() const
Definition: GNN_DataStorage.h:63
TrigFTF_GNN_EtaBin::m_params
std::vector< std::array< float, 5 > > m_params
Definition: GNN_DataStorage.h:74
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
TrigInDetTrackSeedingResult::m_nEdgeLinks
int m_nEdgeLinks
Definition: TrigInDetTrackSeedingResult.h:12
TrigFTF_GNN_TrackingFilter
Definition: GNN_TrackingFilter.h:44
Generated on Sat Nov 1 2025 21:52:59 for ATLAS Offline Software by   doxygen 1.8.18