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

#include <Gbts2ActsSeedingTool.h>

Inheritance diagram for Gbts2ActsSeedingTool:
Collaboration diagram for Gbts2ActsSeedingTool:

Public Member Functions

 Gbts2ActsSeedingTool (const std::string &, const std::string &, const IInterface *)
 
virtual ~Gbts2ActsSeedingTool ()
 
virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual StatusCode createSeeds (const EventContext &ctx, const Acts::SpacePointContainer< ActsTrk::SpacePointCollector, Acts::detail::RefHolder > &spContainer, const Acts::Vector3 &beamSpotPos, const Acts::Vector3 &bField, ActsTrk::SeedContainer &seedContainer) const override
 
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 (ISeedingTool, 1, 0)
 
virtual StatusCode createSeeds (const EventContext &ctx, const Acts::SpacePointContainer< ActsTrk::SpacePointCollector, Acts::detail::RefHolder > &spContainer, const Acts::Vector3 &beamSpotPos, const Acts::Vector3 &bField, ActsTrk::SeedContainer &seedContainer) const
 
virtual StatusCode createSeeds2 (const EventContext &ctx, const std::vector< const xAOD::SpacePointContainer * > &spacePointCollections, const Eigen::Vector3f &beamSpotPos, float bFieldInZ, ActsTrk::SeedContainer &seedContainer) const
 

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

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 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" }
 
const std::vector< short > * m_sct_h2l {nullptr}
 
const std::vector< short > * m_pix_h2l {nullptr}
 
std::vector< bool > m_are_pixels
 
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", false}
 
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 14 of file Gbts2ActsSeedingTool.h.

Member Typedef Documentation

◆ GNN_DataStorage

typedef TrigFTF_GNN_DataStorage SeedingToolBase::GNN_DataStorage
protectedinherited

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

◆ GNN_Edge

typedef TrigFTF_GNN_Edge SeedingToolBase::GNN_Edge
protectedinherited

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

◆ GNN_Node

typedef TrigFTF_GNN_Node SeedingToolBase::GNN_Node
protectedinherited

Definition at line 32 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

◆ Gbts2ActsSeedingTool()

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

Definition at line 14 of file Gbts2ActsSeedingTool.cxx.

16  : SeedingToolBase(t,n,p)
17 {
18 }

◆ ~Gbts2ActsSeedingTool()

virtual Gbts2ActsSeedingTool::~Gbts2ActsSeedingTool ( )
inlinevirtual

Definition at line 19 of file Gbts2ActsSeedingTool.h.

19 {};

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

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

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

◆ createSeeds() [1/2]

virtual StatusCode ActsTrk::ISeedingTool::createSeeds ( const EventContext &  ctx,
const Acts::SpacePointContainer< ActsTrk::SpacePointCollector, Acts::detail::RefHolder > &  spContainer,
const Acts::Vector3 &  beamSpotPos,
const Acts::Vector3 &  bField,
ActsTrk::SeedContainer &  seedContainer 
) const
inlinevirtualinherited

Definition at line 31 of file ISeedingTool.h.

36  {
37  (void)ctx;
38  (void)spContainer;
39  (void)beamSpotPos;
40  (void)bField;
41  (void)seedContainer;
42  return StatusCode::FAILURE;
43  }

◆ createSeeds() [2/2]

StatusCode Gbts2ActsSeedingTool::createSeeds ( const EventContext &  ctx,
const Acts::SpacePointContainer< ActsTrk::SpacePointCollector, Acts::detail::RefHolder > &  spContainer,
const Acts::Vector3 &  beamSpotPos,
const Acts::Vector3 &  bField,
ActsTrk::SeedContainer &  seedContainer 
) const
overridevirtual

Definition at line 35 of file Gbts2ActsSeedingTool.cxx.

35  {
36 
37  std::unique_ptr<GNN_DataStorage> storage = std::make_unique<GNN_DataStorage>(*m_geo, m_mlLUT);
38 
39  SG::ReadCondHandle<InDet::BeamSpotData> beamSpotHandle { m_beamSpotKey, ctx };
40 
41  const Amg::Vector3D &vertex = beamSpotHandle->beamPos();
42 
43  float shift_x = vertex.x() - beamSpotHandle->beamTilt(0)*vertex.z();
44  float shift_y = vertex.y() - beamSpotHandle->beamTilt(1)*vertex.z();
45 
46  std::vector<std::vector<GNN_Node> > node_storage;//layer-based collections
47  node_storage.resize(m_are_pixels.size());
48 
49  for(auto& v : node_storage) v.reserve(100000);
50 
51  unsigned int nPixelLoaded = 0;
52  unsigned int nStripLoaded = 0;
53 
54  for(size_t idx=0; idx<spContainer.size(); idx++){
55  const auto & sp = spContainer.at(idx);
56  const auto & extSP = sp.externalSpacePoint();
57  const std::vector<xAOD::DetectorIDHashType>& elementlist = extSP.elementIdList() ;
58 
59  bool isPixel(elementlist.size() == 1);
60 
61  short layer = (isPixel ? m_pix_h2l : m_sct_h2l)->at(static_cast<int>(elementlist[0]));
62 
63  //convert incoming xaod spacepoints into GNN nodes
64 
65  GNN_Node& node = node_storage[layer].emplace_back(layer);
66 
67  const auto& pos = extSP.globalPosition();
68 
69  node.m_x = pos.x() - shift_x;
70  node.m_y = pos.y() - shift_y;
71  node.m_z = pos.z();
72  node.m_r = std::sqrt(std::pow(node.m_x, 2) + std::pow(node.m_y, 2));
73  node.m_phi = std::atan2(node.m_y, node.m_x);
74  node.m_idx = idx;
75 
76  if(isPixel && m_useML){
77  //Check type in debug build otherwise assume it is correct
78  assert(dynamic_cast<const xAOD::PixelCluster*>(extSP.measurements().front())!=nullptr);
79  const xAOD::PixelCluster* pCL = static_cast<const xAOD::PixelCluster*>(extSP.measurements().front());
80  node.m_pcw = pCL->widthInEta();
81  node.m_locPosY = pCL->localPosition<2>().y();
82  }
83  }
84 
85  for(size_t l = 0; l < node_storage.size(); l++) {
86 
87  const std::vector<GNN_Node>& nodes = node_storage[l];
88 
89  if(nodes.size() == 0) continue;
90 
91  if(m_are_pixels[l])
92  nPixelLoaded += storage->loadPixelGraphNodes(l, nodes, m_useML);
93  else
94  nStripLoaded += storage->loadStripGraphNodes(l, nodes);
95  }
96 
97  ATH_MSG_DEBUG("Loaded "<<nPixelLoaded<<" pixel spacepoints and "<<nStripLoaded<<" strip spacepoints");
98 
99  storage->sortByPhi();
100 
101  storage->initializeNodes(m_useML);
102 
103  storage->generatePhiIndexing(1.5f*m_phiSliceWidth);
104 
105  std::vector<GNN_Edge> edgeStorage;
106 
107  const TrigRoiDescriptor fakeRoi = TrigRoiDescriptor(0, -4.5, 4.5, 0, -M_PI, M_PI, 0, -150.0, 150.0);
108 
109  std::pair<int, int> graphStats = buildTheGraph(fakeRoi, storage, edgeStorage);
110 
111  ATH_MSG_DEBUG("Created graph with "<<graphStats.first<<" edges and "<<graphStats.second<< " edge links");
112 
113  int maxLevel = runCCA(graphStats.first, edgeStorage);
114 
115  ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
116 
117  int minLevel = 3;//a triplet + 2 confirmation
118 
119  if(m_LRTmode) {
120  minLevel = 2;//a triplet + 1 confirmation
121  }
122 
123  if(maxLevel < minLevel) return StatusCode::SUCCESS;
124 
125  std::vector<GNN_Edge*> vSeeds;
126 
127  vSeeds.reserve(graphStats.first/2);
128 
129  for(int edgeIndex = 0; edgeIndex < graphStats.first; edgeIndex++) {
130 
131  GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
132 
133  if(pS->m_level < minLevel) continue;
134 
135  vSeeds.push_back(pS);
136  }
137 
138  if(vSeeds.empty()) return StatusCode::SUCCESS;
139 
140  std::sort(vSeeds.begin(), vSeeds.end(), GNN_Edge::CompareLevel());
141 
142  //backtracking
143 
144  TrigFTF_GNN_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
145 
146  for(auto pS : vSeeds) {
147  if(pS->m_level == -1) continue;
148 
149  TrigFTF_GNN_EdgeState rs(false);
150 
151  tFilter.followTrack(pS, rs);
152 
153  if(!rs.m_initialized) {
154  continue;
155  }
156 
157  if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
158 
159  std::vector<const GNN_Node*> vN;
160 
161  for(std::vector<GNN_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
162  (*sIt)->m_level = -1;//mark as collected
163 
164  if(sIt == rs.m_vs.rbegin()) {
165  vN.push_back((*sIt)->m_n1);
166  }
167 
168  vN.push_back((*sIt)->m_n2);
169 
170  }
171 
172  if(vN.size()<3) continue;
173 
174  std::vector<const xAOD::SpacePoint*> sps;
175  sps.reserve(vN.size());
176  for (const auto* vNptr : vN) {
177  sps.push_back(&spContainer.at(vNptr->sp_idx()).externalSpacePoint());
178  }
179 
180  //add seed to output
181 
182  std::unique_ptr<ActsTrk::Seed> to_add = std::make_unique<ActsTrk::Seed>(std::move(sps));
183 
184  seedContainer.push_back(std::move(to_add));
185  }
186 
187  ATH_MSG_DEBUG("GBTS created "<<seedContainer.size()<<" seeds");
188 
189  return StatusCode::SUCCESS;
190 }

◆ createSeeds2()

virtual StatusCode ActsTrk::ISeedingTool::createSeeds2 ( const EventContext &  ctx,
const std::vector< const xAOD::SpacePointContainer * > &  spacePointCollections,
const Eigen::Vector3f &  beamSpotPos,
float  bFieldInZ,
ActsTrk::SeedContainer &  seedContainer 
) const
inlinevirtualinherited

Definition at line 45 of file ISeedingTool.h.

50  {
51  (void)ctx;
52  (void)spacePointCollections;
53  (void)beamSpotPos;
54  (void)bFieldInZ;
55  (void)seedContainer;
56  return StatusCode::FAILURE;
57  }

◆ 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()

ActsTrk::ISeedingTool::DeclareInterfaceID ( ISeedingTool  ,
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; }

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

Reimplemented from SeedingToolBase.

Definition at line 31 of file Gbts2ActsSeedingTool.cxx.

31  {
32  return SeedingToolBase::finalize();
33 }

◆ initialize()

StatusCode Gbts2ActsSeedingTool::initialize ( )
overridevirtual

Reimplemented from SeedingToolBase.

Definition at line 20 of file Gbts2ActsSeedingTool.cxx.

20  {
21  ATH_CHECK(SeedingToolBase::initialize());
22  ATH_CHECK(m_beamSpotKey.initialize());
23  m_sct_h2l = m_layerNumberTool->sctLayers();
24  m_pix_h2l = m_layerNumberTool->pixelLayers();
25  m_are_pixels.resize(m_layerNumberTool->maxNumberOfUniqueLayers(), true);
26  for(const auto& l : *m_sct_h2l) m_are_pixels[l] = false;
27 
28  return StatusCode::SUCCESS;
29 }

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

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

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

std::vector<bool> Gbts2ActsSeedingTool::m_are_pixels
protected

Definition at line 38 of file Gbts2ActsSeedingTool.h.

◆ m_atlasId

const AtlasDetectorID * SeedingToolBase::m_atlasId = nullptr
protectedinherited

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

◆ m_beamSpotKey

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

Definition at line 34 of file Gbts2ActsSeedingTool.h.

◆ m_connectionFile

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

Definition at line 62 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 72 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 55 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 59 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 49 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 74 of file TrigInDetPattRecoTools/src/SeedingToolBase.h.

◆ m_layerGeometry

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

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

◆ m_layerNumberTool

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

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

◆ m_LRTmode

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

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

◆ m_lutFile

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

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

◆ m_matchBeforeCreate

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

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

◆ m_minPt

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

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

◆ m_mlLUT

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

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

◆ m_nBufferEdges

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

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

◆ m_nMaxEdges

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

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

◆ m_nMaxPhiSlice

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

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

◆ m_phiSliceWidth

float SeedingToolBase::m_phiSliceWidth = 0.
protectedinherited

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

◆ m_pix_h2l

const std::vector<short>* Gbts2ActsSeedingTool::m_pix_h2l {nullptr}
protected

Definition at line 37 of file Gbts2ActsSeedingTool.h.

◆ m_pixelId

const PixelID * SeedingToolBase::m_pixelId = nullptr
protectedinherited

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

◆ m_sct_h2l

const std::vector<short>* Gbts2ActsSeedingTool::m_sct_h2l {nullptr}
protected

Definition at line 36 of file Gbts2ActsSeedingTool.h.

◆ m_sctId

const SCT_ID * SeedingToolBase::m_sctId = nullptr
protectedinherited

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

◆ m_tau_ratio_cut

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

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

◆ m_useBeamTilt

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

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

◆ m_useEtaBinning

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

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

◆ m_useGPUseedExtraction

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

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

◆ m_useML

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

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

◆ m_useOldTunings

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

Definition at line 66 of file TrigInDetPattRecoTools/src/SeedingToolBase.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
SeedingToolBase::m_layerGeometry
std::vector< TrigInDetSiLayer > m_layerGeometry
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:73
SeedingToolBase::m_matchBeforeCreate
BooleanProperty m_matchBeforeCreate
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:57
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
SeedingToolBase::initialize
virtual StatusCode initialize()
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:19
xAOD::PixelCluster_v1::widthInEta
float widthInEta() const
Returns the width of the cluster in phi (x) and eta (y) directions, respectively.
StandaloneBunchgroupHandler.bg
bg
Definition: StandaloneBunchgroupHandler.py:241
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
TrigFTF_GNN_DataStorage::sortByPhi
void sortByPhi()
Definition: GNN_DataStorage.cxx:178
Gbts2ActsSeedingTool::m_beamSpotKey
SG::ReadCondHandleKey< InDet::BeamSpotData > m_beamSpotKey
Definition: Gbts2ActsSeedingTool.h:34
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:93
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:60
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_GNNR3_Edge::m_level
signed char m_level
Definition: GNNR3_DataStorage.h:128
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:157
TrigRoiDescriptor
nope - should be used for standalone also, perhaps need to protect the class def bits #ifndef XAOD_AN...
Definition: TrigRoiDescriptor.h:56
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:32
MCP::ScaleSmearParam::r2
@ r2
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:75
TrigFTF_GNNR3_DataStorage::getEtaBin
TrigFTF_GNNR3_EtaBin & getEtaBin(int idx)
Definition: GNNR3_DataStorage.h:93
Gbts2ActsSeedingTool::m_pix_h2l
const std::vector< short > * m_pix_h2l
Definition: Gbts2ActsSeedingTool.h:37
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
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
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::GNN_Edge
TrigFTF_GNN_Edge GNN_Edge
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:34
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:28
AthCommonDataStore
Definition: AthCommonDataStore.h:52
SeedingToolBase::m_LRTmode
BooleanProperty m_LRTmode
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:51
TrigFTF_GNN_Edge
Definition: GNN_DataStorage.h:108
TrigFTF_GNN_DataStorage::generatePhiIndexing
void generatePhiIndexing(float)
Definition: GNN_DataStorage.cxx:254
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TrigFTF_GNN_EtaBin::m_vPhiNodes
std::vector< std::pair< float, unsigned int > > m_vPhiNodes
Definition: GNN_DataStorage.h:72
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:58
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
SeedingToolBase::finalize
virtual StatusCode finalize()
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.cxx:88
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
TRT::Track::z0
@ z0
Definition: InnerDetector/InDetCalibEvent/TRT_CalibData/TRT_CalibData/TrackInfo.h:63
TrigFTF_GNN_DataStorage::getEtaBin
TrigFTF_GNN_EtaBin & getEtaBin(int idx)
Definition: GNN_DataStorage.h:94
TrigFTF_GNN_DataStorage::loadPixelGraphNodes
int loadPixelGraphNodes(short, const std::vector< TrigFTF_GNN_Node > &, bool)
Definition: GNN_DataStorage.cxx:105
xAOD::UncalibratedMeasurement_v1::localPosition
ConstVectorMap< N > localPosition() const
Returns the local position of the measurement.
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
Gbts2ActsSeedingTool::m_sct_h2l
const std::vector< short > * m_sct_h2l
Definition: Gbts2ActsSeedingTool.h:36
SeedingToolBase::m_doubletFilterRZ
BooleanProperty m_doubletFilterRZ
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:55
Gbts2ActsSeedingTool::m_are_pixels
std::vector< bool > m_are_pixels
Definition: Gbts2ActsSeedingTool.h:38
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
SeedingToolBase::m_layerNumberTool
ToolHandle< ITrigL2LayerNumberTool > m_layerNumberTool
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:43
SeedingToolBase::m_useEtaBinning
BooleanProperty m_useEtaBinning
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:56
TrigFTF_GNN_DataStorage::initializeNodes
void initializeNodes(bool)
Definition: GNN_DataStorage.cxx:183
SeedingToolBase::m_geo
std::unique_ptr< const TrigFTF_GNN_Geometry > m_geo
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:74
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
SeedingToolBase::m_phiSliceWidth
float m_phiSliceWidth
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:70
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
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
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
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
python.PyAthena.v
v
Definition: PyAthena.py:154
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
a
TList * a
Definition: liststreamerinfos.cxx:10
xAOD::PixelCluster_v1
Definition: PixelCluster_v1.h:17
y
#define y
h
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
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
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, float &out)
Definition: TauGNNUtils.cxx:412
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
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:52
TrigRoiDescriptor
Athena::TPCnvVers::Current TrigRoiDescriptor
Definition: TrigSteeringEventTPCnv.cxx:68
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
SeedingToolBase::m_useOldTunings
BooleanProperty m_useOldTunings
Definition: TrigInDetPattRecoTools/src/SeedingToolBase.h:66
M_2PI
#define M_2PI
Definition: CaloGpuGeneral_fnc.cxx:11
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:68
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
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:340
node
Definition: node.h:21
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
TrigFTF_GNN_TrackingFilter
Definition: GNN_TrackingFilter.h:44
Generated on Mon Sep 29 2025 21:35:08 for ATLAS Offline Software by   doxygen 1.8.18