Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 > &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
 

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
 
int runCCA (int, std::vector< GNN_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" }
 
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", false}
 
FloatProperty m_minPt {this, "pTmin", 1000.0}
 
IntegerProperty m_nMaxEdges {this, "MaxGraphEdges", 2000000}
 
StringProperty m_connectionFile {this, "ConnectionFileName", "binTables_ITK_RUN4_UPD_10_APR_2025.txt"}
 
float m_phiSliceWidth = 0.
 
std::unique_ptr< GNN_FasTrackConnector > m_connector = nullptr
 
std::vector< TrigInDetSiLayer > m_layerGeometry
 
std::unique_ptr< const TrigFTF_GNN_Geometry > m_geo = nullptr
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &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 33 of file SeedingToolBase.h.

◆ GNN_Edge

typedef TrigFTF_GNN_Edge SeedingToolBase::GNN_Edge
protectedinherited

Definition at line 34 of file SeedingToolBase.h.

◆ GNN_Node

typedef TrigFTF_GNN_Node SeedingToolBase::GNN_Node
protectedinherited

Definition at line 32 of file 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()

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 68 of file SeedingToolBase.cxx.

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

◆ 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 612 of file TrigInDetTrackSeedingTool.cxx.

612  {
613 
614  tmpColl.resize(spColl->size(), GNN_Node(layer));//all nodes belong to the same layer
615 
616  int idx = 0;
617  int init_size = vSP.size();
618  for(const auto sp : *spColl) {
619  const auto& pos = sp->globalPosition();
620  vSP.emplace_back(sp);
621  float xs = pos.x() - shift_x;
622  float ys = pos.y() - shift_y;
623  float zs = pos.z();
624  tmpColl[idx].m_x = xs;
625  tmpColl[idx].m_y = ys;
626  tmpColl[idx].m_z = zs;
627  tmpColl[idx].m_r = std::sqrt(xs*xs + ys*ys);
628  tmpColl[idx].m_phi = std::atan2(ys,xs);
629  tmpColl[idx].m_idx = init_size + idx;
630 
631  const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
632  if(pCL != nullptr){
633  tmpColl[idx].m_pcw = pCL->width().z();
634  }
635 
636  idx++;
637  }
638 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  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 > &  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 > &  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 > &  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 > &  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 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);
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);
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  int minLevel = 3;//a triplet + 2 confirmation
222 
223  if(m_LRTmode) {
224  minLevel = 2;//a triplet + 1 confirmation
225  }
226 
227  if(maxLevel < minLevel) return seedStats;
228 
229  std::vector<GNN_Edge*> vSeeds;
230 
231  vSeeds.reserve(graphStats.first/2);
232 
233  for(int edgeIndex=0;edgeIndex<graphStats.first;edgeIndex++) {
234  GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
235 
236  if(pS->m_level < minLevel) continue;
237 
238  vSeeds.push_back(pS);
239  }
240 
241  if(vSeeds.empty()) return seedStats;
242 
243  std::sort(vSeeds.begin(), vSeeds.end(), GNN_Edge::CompareLevel());
244 
245  //backtracking
246 
247  TrigFTF_GNN_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
248 
249  output.reserve(vSeeds.size());
250 
251  for(auto pS : vSeeds) {
252 
253  if(pS->m_level == -1) continue;
254 
255  TrigFTF_GNN_EdgeState rs(false);
256 
257  tFilter.followTrack(pS, rs);
258 
259  if(!rs.m_initialized) {
260  continue;
261  }
262 
263  if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
264 
265  std::vector<const GNN_Node*> vN;
266 
267  for(std::vector<GNN_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
268 
269  (*sIt)->m_level = -1;//mark as collected
270 
271  if(sIt == rs.m_vs.rbegin()) {
272  vN.push_back((*sIt)->m_n1);
273  }
274  vN.push_back((*sIt)->m_n2);
275  }
276 
277  if(vN.size()<3) continue;
278 
279  unsigned int lastIdx = output.size();
280  output.emplace_back(rs.m_J);
281 
282  for(const auto& n : vN) {
283  output[lastIdx].addSpacePoint(vSP[n->m_idx]);
284  }
285  }
286 
287  ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
288  }
289  else {//GPU-accelerated graph building
290 
291  //1. data export
292 
293  std::vector<const Trk::SpacePoint*> vSP;
294  std::vector<short> vL;
295 
296  vSP.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
297  vL.reserve(TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS);
298 
299  TrigAccel::DATA_EXPORT_BUFFER* dataBuffer = new TrigAccel::DATA_EXPORT_BUFFER(5000);
300 
301  size_t dataTypeSize = sizeof(TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA);
302  const size_t bufferOffset = 256;
303  size_t totalSize = bufferOffset+dataTypeSize;//make room for the header
304  if(!dataBuffer->fit(totalSize)) dataBuffer->reallocate(totalSize);
305 
306  TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA* pJobData = reinterpret_cast<TrigAccel::ITk::GRAPH_MAKING_INPUT_DATA*>(dataBuffer->m_buffer + bufferOffset);
307 
308  unsigned int spIdx = 0;
309  int sp_offset = 0;
310  int nLayers = 0;
311  int MaxEtaBin = 0;
312  int nEtaBins = 0;
313 
314  for(const auto& lColl : detIdMap) {
315 
316  short layerIndex = lColl.first;
317 
318  const TrigFTF_GNN_Layer* pL = m_geo->getTrigFTF_GNN_LayerByIndex(layerIndex);
319 
320  int layerKey = pL->m_layer.m_subdet;
321 
322  bool isPixel = layerKey > 20000;
323  bool isBarrel = (pL->m_layer.m_type == 0);
324 
325  auto pCont = isPixel ? pixelSpacePointsContainer : sctSpacePointsContainer;
326 
327  pJobData->m_layerIdx[nLayers] = layerIndex;
328 
329  pJobData->m_layerInfo[4*nLayers ] = spIdx;//layerInfo.x
330  pJobData->m_layerInfo[4*nLayers + 2] = pL->num_bins();//layerInfo.z
331  pJobData->m_layerInfo[4*nLayers + 3] = pL->m_bins[0];//layerInfo.w
332 
333  pJobData->m_layerGeo[2*nLayers ] = pL->m_minEta;//layerGeo.x
334  pJobData->m_layerGeo[2*nLayers + 1] = pL->m_etaBin;//layerGeo.y
335 
336  nEtaBins += pL->m_bins.size();
337 
338  for(auto b : pL->m_bins) {
339  if(b > MaxEtaBin) MaxEtaBin = b;
340  }
341 
342  for(const auto& idx : lColl.second) {
343 
344  auto input_coll = pCont->indexFindPtr(idx);
345 
346  if(input_coll == nullptr) continue;
347 
348  for(const auto& sp : *input_coll) {
349 
350  float cw = -1.0;
351 
352  const InDet::PixelCluster* pCL = dynamic_cast<const InDet::PixelCluster*>(sp->clusterList().first);
353  if(pCL != nullptr){
354  cw = pCL->width().widthPhiRZ().y();
355  if(!isBarrel && m_useML) {
356  if(cw > 0.2) continue;
357  cw = -1.0;//set it to -1 so that it can be skipped later in the ML code on GPU
358  }
359  }
360 
361  vSP.emplace_back(sp);
362  vL.emplace_back(layerIndex);
363 
364  const auto& p = sp->globalPosition();
365 
366  float params[4] = {(float)(p.x() - shift_x), float(p.y() - shift_y), (float)(p.z()), cw};
367 
368  memcpy(&pJobData->m_params[sp_offset], &params[0], sizeof(params));
369 
370  sp_offset += 4;
371  spIdx++;
372  if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
373  }
374  if(spIdx >= TrigAccel::ITk::GBTS_MAX_NUMBER_SPACEPOINTS) break;
375  }
376 
377  pJobData->m_layerInfo[4*nLayers + 1] = spIdx;//layerInfo.y
378 
379  if (isPixel) nPixels += spIdx - pJobData->m_layerInfo[4*nLayers];
380  else nStrips += spIdx - pJobData->m_layerInfo[4*nLayers];
381 
382  nLayers++;
383  }
384 
385  pJobData->m_nSpacepoints = spIdx;
386  pJobData->m_nLayers = nLayers;
387  pJobData->m_nEtaBins = nEtaBins;
388  pJobData->m_maxEtaBin = MaxEtaBin;
389  pJobData->m_nMaxEdges = m_nMaxEdges;
390 
391  //load bin pairs
392 
393  int pairIdx = 0;
394 
395  for(const auto& bg : m_geo->bin_groups()) {//loop over bin groups
396 
397  int bin1_idx = bg.first;
398 
399  for(const auto& bin2_idx : bg.second) {
400  pJobData->m_bin_pairs[2*pairIdx ] = bin1_idx;
401  pJobData->m_bin_pairs[2*pairIdx+1] = bin2_idx;
402  pairIdx++;
403  }
404  }
405 
406  pJobData->m_nBinPairs = pairIdx;
407 
408  //add algorithm parameters
409 
410  const float ptCoeff = 0.29997*1.9972/2.0;// ~0.3*B/2 - assuming nominal field of 2*T
411 
412  float tripletPtMin = 0.8*m_minPt;//correction due to limited pT resolution
413 
414  float maxCurv = ptCoeff/tripletPtMin;
415 
416  const float min_deltaPhi = 0.001;
417  const float dphi_coeff = 0.68*maxCurv;
418  const float cut_dphi_max = m_LRTmode ? 0.07 : 0.012;
419  const float cut_dcurv_max = m_LRTmode ? 0.015 : 0.001;
420  const float cut_tau_ratio_max = m_LRTmode ? 0.015 : 0.007;
421  const float min_z0 = m_LRTmode ? -600.0 : internalRoI.zedMinus();
422  const float max_z0 = m_LRTmode ? 600.0 : internalRoI.zedPlus();
423 
424  const float maxOuterRadius = m_LRTmode ? 1050.0 : 550.0;
425  const float minDeltaRadius = 2.0;
426 
427  const float cut_zMinU = min_z0 + maxOuterRadius*internalRoI.dzdrMinus();
428  const float cut_zMaxU = max_z0 + maxOuterRadius*internalRoI.dzdrPlus();
429 
430  const float maxKappa_high_eta = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.8)*maxCurv;
431  const float maxKappa_low_eta = m_LRTmode ? 1.0*maxCurv : std::sqrt(0.6)*maxCurv;
432 
433  pJobData->m_algo_params[0] = min_deltaPhi;
434  pJobData->m_algo_params[1] = dphi_coeff;
435  pJobData->m_algo_params[2] = minDeltaRadius;
436  pJobData->m_algo_params[3] = min_z0;
437  pJobData->m_algo_params[4] = max_z0;
438  pJobData->m_algo_params[5] = maxOuterRadius;
439  pJobData->m_algo_params[6] = cut_zMinU;
440  pJobData->m_algo_params[7] = cut_zMaxU;
441  pJobData->m_algo_params[8] = maxKappa_low_eta;
442  pJobData->m_algo_params[9] = maxKappa_high_eta;
443  pJobData->m_algo_params[10]= cut_dphi_max;
444  pJobData->m_algo_params[11]= cut_dcurv_max;
445  pJobData->m_algo_params[12]= cut_tau_ratio_max;
446 
447  seedStats.m_nPixelSPs = nPixels;
448  seedStats.m_nStripSPs = nStrips;
449 
450  ATH_MSG_DEBUG("Loaded "<<nPixels<< " Pixel Spacepoints and "<<nStrips<< " Strip SpacePoints");
451 
452  std::shared_ptr<TrigAccel::OffloadBuffer> pBuff = std::make_shared<TrigAccel::OffloadBuffer>(dataBuffer);
453 
454  TrigAccel::Work* pWork = m_accelSvc->createWork(TrigAccel::InDetJobControlCode::RUN_GBTS, pBuff);
455 
456  if(!pWork) {
457  ATH_MSG_INFO("Failed to create a work item for task "<<TrigAccel::InDetJobControlCode::RUN_GBTS);
458  return seedStats;
459  }
460 
461  ATH_MSG_DEBUG("Work item created for task "<<TrigAccel::InDetJobControlCode::RUN_GBTS);
462 
463  pWork->run();
464 
465  std::shared_ptr<TrigAccel::OffloadBuffer> pOutput = pWork->getOutput();
466 
467  TrigAccel::ITk::COMPRESSED_GRAPH* pGraph = reinterpret_cast<TrigAccel::ITk::COMPRESSED_GRAPH*>(pOutput->m_rawBuffer);
468 
469  unsigned int nEdges = pGraph->m_nEdges;
470  unsigned int nMaxNei = pGraph->m_nMaxNeighbours;
471 
472  //populating the edgeStorage
473 
474  std::vector<GNN_Node> nodes;
475 
476  nodes.reserve(vSP.size());
477 
478  for(unsigned int idx = 0;idx < vSP.size(); idx++) {
479 
480  nodes.emplace_back(vL[idx]);
481 
482  const auto& pos = vSP[idx]->globalPosition();
483  float xs = pos.x() - shift_x;
484  float ys = pos.y() - shift_y;
485  float zs = pos.z();
486 
487  nodes[idx].m_x = xs;
488  nodes[idx].m_y = ys;
489  nodes[idx].m_z = zs;
490  nodes[idx].m_r = std::sqrt(xs*xs + ys*ys);
491 
492  nodes[idx].m_idx = idx;
493 
494  }
495 
496  std::vector<GNN_Edge> edgeStorage;
497 
498  std::pair<int, int> graphStats(0,0);
499 
500  edgeStorage.resize(nEdges);
501 
502  unsigned int edgeSize = nMaxNei + 1 + 2;//neigbours, num_neighbours, 2 nodes
503 
504  for(unsigned int idx=0;idx<nEdges;idx++) {
505  unsigned int pos = idx*edgeSize;
506 
507  int node1Idx = pGraph->m_graphArray[pos];
508  int node2Idx = pGraph->m_graphArray[pos+1];
509  int nNei = pGraph->m_graphArray[pos+2];
510 
511  if(nNei > N_SEG_CONNS) nNei = N_SEG_CONNS;
512 
513  edgeStorage[idx].m_n1 = &nodes[node1Idx];
514  edgeStorage[idx].m_n2 = &nodes[node2Idx];
515  edgeStorage[idx].m_level = 1;
516  edgeStorage[idx].m_nNei = nNei;
517  for(int k=0;k<nNei;k++) {
518  edgeStorage[idx].m_vNei[k] = pGraph->m_graphArray[pos+3+k];
519  }
520  }
521 
522  graphStats.first = nEdges;
523  graphStats.second = pGraph->m_nLinks;
524 
525  delete[] pGraph->m_graphArray;
526 
527  pGraph->m_graphArray = nullptr;
528 
529  delete pWork;
530 
531  delete dataBuffer;
532 
533  //run the rest of the GBTS workflow
534 
535  int maxLevel = runCCA(graphStats.first, edgeStorage);
536 
537  ATH_MSG_DEBUG("Reached Level "<<maxLevel<<" after GNN iterations");
538 
539  int minLevel = 3;//a triplet + 2 confirmation
540 
541  if(m_LRTmode) {
542  minLevel = 2;//a triplet + 1 confirmation
543  }
544 
545  if(maxLevel < minLevel) return seedStats;
546 
547  std::vector<GNN_Edge*> vSeeds;
548 
549  vSeeds.reserve(graphStats.first/2);
550 
551  for(int edgeIndex=0;edgeIndex<graphStats.first;edgeIndex++) {
552  GNN_Edge* pS = &(edgeStorage.at(edgeIndex));
553 
554  if(pS->m_level < minLevel) continue;
555 
556  vSeeds.push_back(pS);
557  }
558 
559  if(vSeeds.empty()) return seedStats;
560 
561  std::sort(vSeeds.begin(), vSeeds.end(), GNN_Edge::CompareLevel());
562 
563  //backtracking
564 
565  TrigFTF_GNN_TrackingFilter tFilter(m_layerGeometry, edgeStorage);
566 
567  output.reserve(vSeeds.size());
568 
569  for(auto pS : vSeeds) {
570 
571  if(pS->m_level == -1) continue;
572 
573  TrigFTF_GNN_EdgeState rs(false);
574 
575  tFilter.followTrack(pS, rs);
576 
577  if(!rs.m_initialized) {
578  continue;
579  }
580 
581  if(static_cast<int>(rs.m_vs.size()) < minLevel) continue;
582 
583  std::vector<const GNN_Node*> vN;
584 
585  for(std::vector<GNN_Edge*>::reverse_iterator sIt=rs.m_vs.rbegin();sIt!=rs.m_vs.rend();++sIt) {
586 
587  (*sIt)->m_level = -1;//mark as collected
588 
589  if(sIt == rs.m_vs.rbegin()) {
590  vN.push_back((*sIt)->m_n1);
591  }
592  vN.push_back((*sIt)->m_n2);
593  }
594 
595  if(vN.size()<3) continue;
596 
597  unsigned int lastIdx = output.size();
598  output.emplace_back(rs.m_J);
599 
600  for(const auto& n : vN) {
601  output[lastIdx].addSpacePoint(vSP[n->m_idx]);
602  }
603  }
604 
605  ATH_MSG_DEBUG("Found "<<output.size()<<" tracklets");
606  }
607 
608  return seedStats;
609 
610 }

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

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

Definition at line 294 of file SeedingToolBase.cxx.

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

◆ 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 45 of file 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_UPD_10_APR_2025.txt"}
protectedinherited

Definition at line 60 of file SeedingToolBase.h.

◆ m_connector

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

Definition at line 64 of file 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 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 SeedingToolBase.h.

◆ m_geo

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

Definition at line 66 of file SeedingToolBase.h.

◆ m_layerGeometry

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

Definition at line 65 of file SeedingToolBase.h.

◆ m_layerNumberTool

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

Definition at line 43 of file SeedingToolBase.h.

◆ m_LRTmode

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

Definition at line 51 of file SeedingToolBase.h.

◆ m_matchBeforeCreate

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

Definition at line 57 of file SeedingToolBase.h.

◆ m_minPt

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

Definition at line 58 of file SeedingToolBase.h.

◆ m_nMaxEdges

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

Definition at line 59 of file SeedingToolBase.h.

◆ m_nMaxPhiSlice

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

Definition at line 54 of file SeedingToolBase.h.

◆ m_phiSliceWidth

float SeedingToolBase::m_phiSliceWidth = 0.
protectedinherited

Definition at line 62 of file SeedingToolBase.h.

◆ m_pixelId

const PixelID* SeedingToolBase::m_pixelId = nullptr
protectedinherited

Definition at line 47 of file 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 46 of file 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_useBeamTilt

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

Definition at line 50 of file SeedingToolBase.h.

◆ m_useEtaBinning

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

Definition at line 56 of file SeedingToolBase.h.

◆ m_useGPU

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

Definition at line 71 of file TrigInDetTrackSeedingTool.h.

◆ m_useML

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

Definition at line 52 of file 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:40
TrigInDetTrackSeedingTool::m_accelSvc
ServiceHandle< ITrigInDetAccelerationSvc > m_accelSvc
Definition: TrigInDetTrackSeedingTool.h:72
SeedingToolBase::m_matchBeforeCreate
BooleanProperty m_matchBeforeCreate
Definition: SeedingToolBase.h:57
TrigInDetTrackSeedingResult::m_nStripSPs
int m_nStripSPs
Definition: TrigInDetTrackSeedingResult.h:12
TrigAccel::ITk::CompressedGraph::m_nEdges
unsigned int m_nEdges
Definition: TrigITkAccelEDM.h:149
TrigAccel::DataExportBuffer
Definition: DataExportBuffer.h:14
TrigAccel::ITk::GraphMakingInputData
Definition: TrigITkAccelEDM.h:117
TrigAccel::DataExportBuffer::fit
bool fit(size_t s)
Definition: DataExportBuffer.h:26
TrigAccel::DATA_EXPORT_BUFFER
struct TrigAccel::DataExportBuffer DATA_EXPORT_BUFFER
TrigFTF_GNN_EtaBin::m_in
std::vector< std::vector< unsigned int > > m_in
Definition: GNN_DataStorage.h:72
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
SeedingToolBase::initialize
virtual StatusCode initialize()
Definition: SeedingToolBase.cxx:19
TrigInDetTrackSeedingTool::m_useSctSpacePoints
BooleanProperty m_useSctSpacePoints
Definition: TrigInDetTrackSeedingTool.h:58
TrigAccel::ITk::CompressedGraph::m_graphArray
int * m_graphArray
Definition: TrigITkAccelEDM.h:152
StandaloneBunchgroupHandler.bg
bg
Definition: StandaloneBunchgroupHandler.py:243
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:124
TrigFTF_GNN_DataStorage::sortByPhi
void sortByPhi()
Definition: GNN_DataStorage.cxx:177
TrigAccel::Work::run
virtual bool run()=0
SG::ReadHandle< SpacePointContainer >
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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:160
SeedingToolBase::buildTheGraph
std::pair< int, int > buildTheGraph(const IRoiDescriptor &, const std::unique_ptr< GNN_DataStorage > &, std::vector< GNN_Edge > &) const
Definition: SeedingToolBase.cxx:68
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:133
SeedingToolBase::m_nMaxEdges
IntegerProperty m_nMaxEdges
Definition: SeedingToolBase.h:59
TrigAccel::Work::getOutput
virtual std::shared_ptr< OffloadBuffer > getOutput()=0
skel.it
it
Definition: skel.GENtoEVGEN.py:407
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
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:112
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
SeedingToolBase::GNN_Node
TrigFTF_GNN_Node GNN_Node
Definition: SeedingToolBase.h:32
MCP::ScaleSmearParam::r2
@ r2
IRoiDescriptor::dzdrMinus
virtual double dzdrMinus() const =0
return the gradients
TrigInDetTrackSeedingTool::m_usePixelSpacePoints
BooleanProperty m_usePixelSpacePoints
Definition: TrigInDetTrackSeedingTool.h:57
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
N_SEG_CONNS
#define N_SEG_CONNS
Definition: GNN_DataStorage.h:14
TrigFTF_GNN_EtaBin::empty
bool empty() const
Definition: GNN_DataStorage.h:56
SeedingToolBase::GNN_Edge
TrigFTF_GNN_Edge GNN_Edge
Definition: SeedingToolBase.h:34
TrigFTF_GNN_Edge::m_next
signed char m_next
Definition: GNN_DataStorage.h:128
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
SeedingToolBase::SeedingToolBase
SeedingToolBase(const std::string &t, const std::string &n, const IInterface *p)
Definition: SeedingToolBase.h:28
AthCommonDataStore
Definition: AthCommonDataStore.h:52
SeedingToolBase::m_LRTmode
BooleanProperty m_LRTmode
Definition: SeedingToolBase.h:51
TrigFTF_GNN_Edge
Definition: GNN_DataStorage.h:106
TrigFTF_GNN_DataStorage::generatePhiIndexing
void generatePhiIndexing(float)
Definition: GNN_DataStorage.cxx:226
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TrigAccel::ITk::GraphMakingInputData::m_nEtaBins
unsigned int m_nEtaBins
Definition: TrigITkAccelEDM.h:120
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:71
TrigFTF_GNN_Edge::m_level
signed char m_level
Definition: GNN_DataStorage.h:128
SeedingToolBase::m_minPt
FloatProperty m_minPt
Definition: SeedingToolBase.h:58
beamspotman.n
n
Definition: beamspotman.py:731
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
SeedingToolBase::m_layerGeometry
std::vector< TrigInDetSiLayer > m_layerGeometry
Definition: SeedingToolBase.h:65
TauGNNUtils::Variables::Track::dPhi
bool dPhi(const xAOD::TauJet &tau, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:548
TrigAccel::ITk::GraphMakingInputData::m_params
float m_params[4 *GBTS_MAX_NUMBER_SPACEPOINTS]
Definition: TrigITkAccelEDM.h:122
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:120
SeedingToolBase::finalize
virtual StatusCode finalize()
Definition: SeedingToolBase.cxx:63
TrigAccel::ITk::CompressedGraph::m_nLinks
unsigned int m_nLinks
Definition: TrigITkAccelEDM.h:151
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
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:120
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:93
TrigAccel::ITk::GraphMakingInputData::m_bin_pairs
int m_bin_pairs[2 *GBTS_MAX_ETA_BIN_PAIR]
Definition: TrigITkAccelEDM.h:136
TrigFTF_GNN_DataStorage::loadPixelGraphNodes
int loadPixelGraphNodes(short, const std::vector< TrigFTF_GNN_Node > &, bool)
Definition: GNN_DataStorage.cxx:104
TrigFTF_GNN_EtaBin::getMaxBinRadius
float getMaxBinRadius() const
Definition: GNN_DataStorage.h:66
SeedingToolBase::m_doubletFilterRZ
BooleanProperty m_doubletFilterRZ
Definition: SeedingToolBase.h:55
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:17
MuonGM::nStrips
int nStrips(const MuonGM::TgcReadoutElement &readoutEle, int layer)
Definition: MuonDetDescr/MuonGeoModelTest/src/GeoModelTgcTest.cxx:46
SeedingToolBase::m_useEtaBinning
BooleanProperty m_useEtaBinning
Definition: SeedingToolBase.h:56
TrigAccel::ITk::GraphMakingInputData::m_layerInfo
int m_layerInfo[4 *GBTS_MAX_SILICON_LAYERS]
Definition: TrigITkAccelEDM.h:128
TrigFTF_GNN_DataStorage::initializeNodes
void initializeNodes(bool)
Definition: GNN_DataStorage.cxx:182
TrigAccel::ITk::GraphMakingInputData::m_nMaxEdges
unsigned int m_nMaxEdges
Definition: TrigITkAccelEDM.h:120
SeedingToolBase::m_geo
std::unique_ptr< const TrigFTF_GNN_Geometry > m_geo
Definition: SeedingToolBase.h:66
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:77
TrigAccel::Work
Definition: Work.h:14
TrigAccel::ITk::GraphMakingInputData::m_layerGeo
float m_layerGeo[2 *GBTS_MAX_SILICON_LAYERS]
Definition: TrigITkAccelEDM.h:132
SeedingToolBase::m_phiSliceWidth
float m_phiSliceWidth
Definition: SeedingToolBase.h:62
TrigInDetTrackSeedingTool::createGraphNodes
void createGraphNodes(const SpacePointCollection *, std::vector< GNN_Node > &, std::vector< const Trk::SpacePoint * > &, unsigned short, float, float) const
Definition: TrigInDetTrackSeedingTool.cxx:612
TrigInDetTrackSeedingResult
Definition: TrigInDetTrackSeedingResult.h:8
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
TrigAccel::ITk::GraphMakingInputData::m_nBinPairs
unsigned int m_nBinPairs
Definition: TrigITkAccelEDM.h:120
TrigInDetTrackSeedingResult::m_nGraphEdges
int m_nGraphEdges
Definition: TrigInDetTrackSeedingResult.h:12
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
TrigFTF_GNN_Edge::m_nNei
unsigned char m_nNei
Definition: GNN_DataStorage.h:130
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
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:138
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
TrigAccel::ITk::CompressedGraph
Definition: TrigITkAccelEDM.h:142
TrigFTF_GNN_Layer::num_bins
int num_bins() const
Definition: GNN_Geometry.h:26
TrigFTF_GNN_Edge::m_p
float m_p[3]
Definition: GNN_DataStorage.h:131
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
python.LArCondContChannels.isBarrel
isBarrel
Definition: LArCondContChannels.py:659
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:142
IRoiDescriptor::zedMinus
virtual double zedMinus() const =0
SeedingToolBase::m_useML
BooleanProperty m_useML
Definition: SeedingToolBase.h:52
TrigAccel::ITk::GraphMakingInputData::m_nLayers
unsigned int m_nLayers
Definition: TrigITkAccelEDM.h:120
python.copyTCTOutput.totalSize
totalSize
Definition: copyTCTOutput.py:93
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
SpacePointContainer
Definition: Tracking/TrkEvent/TrkSpacePoint/TrkSpacePoint/SpacePointContainer.h:29
TrigInDetTrackSeedingTool::m_pixelSpacePointsContainerKey
SG::ReadHandleKey< SpacePointContainer > m_pixelSpacePointsContainerKey
Definition: TrigInDetTrackSeedingTool.h:62
M_2PI
#define M_2PI
Definition: CaloGpuGeneral_fnc.cxx:8
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
TrigAccel::ITk::CompressedGraph::m_nMaxNeighbours
unsigned int m_nMaxNeighbours
Definition: TrigITkAccelEDM.h:150
MCP::ScaleSmearParam::r1
@ r1
TrigFTF_GNN_EtaBin::m_vn
std::vector< const TrigFTF_GNN_Node * > m_vn
Definition: GNN_DataStorage.h:70
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
SeedingToolBase::runCCA
int runCCA(int, std::vector< GNN_Edge > &) const
Definition: SeedingToolBase.cxx:294
SeedingToolBase::m_layerNumberTool
ToolHandle< ITrigL2LayerNumberTool > m_layerNumberTool
Definition: SeedingToolBase.h:43
InDet::SiWidth::z
double z() const
Definition: SiWidth.h:131
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:62
TrigFTF_GNN_EtaBin::m_params
std::vector< std::array< float, 5 > > m_params
Definition: GNN_DataStorage.h:73
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 Apr 12 2025 21:50:26 for ATLAS Offline Software by   doxygen 1.8.18