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

#include <FPGATrackSimGNNGraphConstructionTool.h>

Inheritance diagram for FPGATrackSimGNNGraphConstructionTool:
Collaboration diagram for FPGATrackSimGNNGraphConstructionTool:

Public Member Functions

 FPGATrackSimGNNGraphConstructionTool (const std::string &, const std::string &, const IInterface *)
 
virtual StatusCode initialize () override
 
virtual StatusCode getEdges (const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges)
 
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
 

Protected Member Functions

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...
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

void loadDoubletModuleMap ()
 
void doModuleMap (const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges)
 
void getDoubletEdges (const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges)
 
void applyDoubletCuts (const std::shared_ptr< FPGATrackSimGNNHit > &hit1, const std::shared_ptr< FPGATrackSimGNNHit > &hit2, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges, int hit1_index, int hit2_index, unsigned int modulemap_id)
 
bool doMask (float val, float min, float max)
 
bool doMinMaxMask (float val, float min, float max)
 
float featureSign (float feature)
 
void doMetricLearning (const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges)
 
std::vector< float > getNodeFeatures (const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits)
 
std::vector< float > embed (const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits)
 
void doClustering (const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges, std::vector< float > &gEmbedded)
 
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

ToolHandle< AthOnnx::IOnnxRuntimeInferenceToolm_MLInferenceTool {this, "MLInferenceTool", "AthOnnx::OnnxRuntimeInferenceTool"}
 
Gaudi::Property< std::string > m_graphTool { this, "graphTool", "", "Tool for graph construction" }
 
Gaudi::Property< std::string > m_moduleMapType { this, "moduleMapType", "", "Type for Module Map for graph construction" }
 
Gaudi::Property< std::string > m_moduleMapFunc { this, "moduleMapFunc", "", "Function for Module Map for graph construction" }
 
Gaudi::Property< float > m_moduleMapTol { this, "moduleMapTol", 0.0, "Tolerance value for Module Map cut calculations" }
 
Gaudi::Property< std::string > m_moduleMapPath { this, "moduleMapPath", "", "Location of Module Map ROOT file" }
 
Gaudi::Property< float > m_metricLearningR { this, "metricLearningR", 0.0, "Clustering radius for Metric Learning"}
 
Gaudi::Property< int > m_metricLearningMaxN { this, "metricLearningMaxN", 1, "Max number of neighbours for Metric Learning"}
 
std::vector< unsigned int > m_mid1 {}
 
std::vector< unsigned int > m_mid2 {}
 
std::vector< float > m_z0min_12 {}
 
std::vector< float > m_dphimin_12 {}
 
std::vector< float > m_phislopemin_12 {}
 
std::vector< float > m_detamin_12 {}
 
std::vector< float > m_z0max_12 {}
 
std::vector< float > m_dphimax_12 {}
 
std::vector< float > m_phislopemax_12 {}
 
std::vector< float > m_detamax_12 {}
 
StringArrayProperty m_MLFeatureNamesVec
 
FloatArrayProperty m_MLFeatureScalesVec
 
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 27 of file FPGATrackSimGNNGraphConstructionTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ FPGATrackSimGNNGraphConstructionTool()

FPGATrackSimGNNGraphConstructionTool::FPGATrackSimGNNGraphConstructionTool ( const std::string &  algname,
const std::string &  name,
const IInterface *  ifc 
)

Definition at line 12 of file FPGATrackSimGNNGraphConstructionTool.cxx.

13  : AthAlgTool(algname, name, ifc) {}

Member Function Documentation

◆ applyDoubletCuts()

void FPGATrackSimGNNGraphConstructionTool::applyDoubletCuts ( const std::shared_ptr< FPGATrackSimGNNHit > &  hit1,
const std::shared_ptr< FPGATrackSimGNNHit > &  hit2,
std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &  edges,
int  hit1_index,
int  hit2_index,
unsigned int  modulemap_id 
)
private

Definition at line 136 of file FPGATrackSimGNNGraphConstructionTool.cxx.

137 {
138  // Four types of doublet cuts (dEta, z0, dPhi, phiSlope)
139  // If an edge passes all four, then it is a valid edge and can be stored
140 
141  // delta_eta cuts
142  float deta = hit1->getEta() - hit2->getEta();
143  if(!doMask(deta, m_detamin_12[modulemap_id], m_detamax_12[modulemap_id])) return;
144 
145  // z0 cuts
146  float dz = hit2->getZ() - hit1->getZ();
147  float dr = hit2->getR() - hit1->getR();
148  float z0 = dr==0. ? 0. : hit1->getZ() - (hit1->getR() * dz / dr);
149  if(!doMask(z0, m_z0min_12[modulemap_id], m_z0max_12[modulemap_id])) return;
150 
151  // delta_phi cuts
152  float dphi = P4Helpers::deltaPhi(hit2->getPhi(),hit1->getPhi());
153  if(!doMask(dphi, m_dphimin_12[modulemap_id], m_dphimax_12[modulemap_id])) return;
154 
155  // phislope cuts
156  float phislope = dr==0. ? 0. : dphi / dr;
157  if(!doMask(phislope, m_phislopemin_12[modulemap_id], m_phislopemax_12[modulemap_id])) return;
158 
159  // if pass all doublet cuts, then record the edge information
160  std::shared_ptr<FPGATrackSimGNNEdge> edge = std::make_shared<FPGATrackSimGNNEdge>();
161  edge->setEdgeIndex1(hit1_index);
162  edge->setEdgeIndex2(hit2_index);
163  edges.emplace_back(edge);
164 }

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

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

◆ doClustering()

void FPGATrackSimGNNGraphConstructionTool::doClustering ( const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &  hits,
std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &  edges,
std::vector< float > &  gEmbedded 
)
private

Definition at line 237 of file FPGATrackSimGNNGraphConstructionTool.cxx.

239 {
240  // Create graph edges based on the hits distance in the latent space
241  // Creates a directed graph
242  int n_dim = 12;
243  int size = hits.size();
244  float r_squared = m_metricLearningR*m_metricLearningR;
245  int index1 = 0;
246  int index2 = 0;
247  int count = 0;
248  float distance = 0.;
249  std::vector<float> start(n_dim);
250 
251  // Loop over all hits
252  for(int k = 0; k < size; ++k){
253  count = 0;
254  // Setup current hit
255  for(int j = 0; j < n_dim; ++j){
256  start[j] = gEmbedded[k*n_dim + j];
257  }
258  // Loop over the hits not yet checked
259  for (int i = k + 1; i < size; ++i){
260  distance = 0.;
261  for(int d = 0; d < n_dim; ++d){
262  distance += (start[d] - gEmbedded[i*n_dim + d]) * (start[d] - gEmbedded[i*n_dim + d]);
263  }
264  // Store edge if the distance between the hits meets is below the limit
265  if(distance < r_squared){
266  std::shared_ptr<FPGATrackSimGNNEdge> edge = std::make_shared<FPGATrackSimGNNEdge>();
267  // Set order of edge indices to make a directed graph
268  float d_i_sq = (hits[i]->getR() * hits[i]->getR()) + (hits[i]->getZ() * hits[i]->getZ());
269  float d_k_sq = (hits[k]->getR() * hits[k]->getR()) + (hits[k]->getZ() * hits[k]->getZ());
270  if (d_i_sq < d_k_sq){
271  index1 = i;
272  index2 = k;
273  } else {
274  index1 = k;
275  index2 = i;
276  }
277 
278  edge->setEdgeIndex1(index1);
279  edge->setEdgeIndex2(index2);
280  edges.emplace_back(edge);
281  ++count;
282  }
283  // Upper limit for connections of the same hit
285  break;
286  }
287  }
288 
289  }
290 }

◆ doMask()

bool FPGATrackSimGNNGraphConstructionTool::doMask ( float  val,
float  min,
float  max 
)
private

Definition at line 166 of file FPGATrackSimGNNGraphConstructionTool.cxx.

167 {
168  bool mask = false;
169  if(m_moduleMapFunc == "minmax") {
170  mask = doMinMaxMask(val, min, max);
171  }
172 
173  return mask;
174 }

◆ doMetricLearning()

void FPGATrackSimGNNGraphConstructionTool::doMetricLearning ( const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &  hits,
std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &  edges 
)
private

Definition at line 195 of file FPGATrackSimGNNGraphConstructionTool.cxx.

196 {
197  // Use Metric Learning for edge construction
198  // Clustering properties can be set in the input scripta as Gaudi::Property variables
199  std::vector<float> gNodeFeatures = getNodeFeatures(hits);
200  std::vector<float> gEmbedded = embed(hits);
201  doClustering(hits, edges, gEmbedded);
202 }

◆ doMinMaxMask()

bool FPGATrackSimGNNGraphConstructionTool::doMinMaxMask ( float  val,
float  min,
float  max 
)
private

Definition at line 176 of file FPGATrackSimGNNGraphConstructionTool.cxx.

177 {
178  bool mask = false;
179 
180  if((val <= max * (1.0 + featureSign(max) * m_moduleMapTol)) &&
181  (val >= min * (1.0 - featureSign(min) * m_moduleMapTol))) {
182  mask = true;
183  }
184 
185  return mask;
186 }

◆ doModuleMap()

void FPGATrackSimGNNGraphConstructionTool::doModuleMap ( const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &  hits,
std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &  edges 
)
private

Definition at line 93 of file FPGATrackSimGNNGraphConstructionTool.cxx.

94 {
95  // Use Module Map method for edge building
96  // Two types of module maps: Doublet and Triplet
97  // For each type of module map there is three functions: minmax, meanrms, and hybrid
98  // Use the proper configuration set by the input script and passed as Gaudi::Property variables
99  // Currently only Doublet Module Map with minmax cuts exist, but others can be implemented later on as desired
100 
101  if(m_moduleMapType == "doublet") {
102  getDoubletEdges(hits, edges);
103  }
104 }

◆ embed()

std::vector< float > FPGATrackSimGNNGraphConstructionTool::embed ( const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &  hits)
private

Definition at line 222 of file FPGATrackSimGNNGraphConstructionTool.cxx.

223 {
224  // Use the ML network to embed the hits in a 12-dim latent space
225  std::vector<float> gNodeFeatures = getNodeFeatures(hits);
226  std::vector<float> gEmbedded;
227 
228  std::vector<Ort::Value> gInputTensor;
229  StatusCode s = m_MLInferenceTool->addInput(gInputTensor, gNodeFeatures, 0, hits.size());
230  std::vector<Ort::Value> gOutputTensor;
231  s = m_MLInferenceTool->addOutput(gOutputTensor, gEmbedded, 0, hits.size());
232  s = m_MLInferenceTool->inference(gInputTensor, gOutputTensor);
233 
234  return gEmbedded;
235 }

◆ 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

◆ featureSign()

float FPGATrackSimGNNGraphConstructionTool::featureSign ( float  feature)
private

Definition at line 188 of file FPGATrackSimGNNGraphConstructionTool.cxx.

189 {
190  if(feature < 0.0) { return -1.0; }
191  else if(feature > 0.0) { return 1.0; }
192  else { return 0.0; }
193 }

◆ getDoubletEdges()

void FPGATrackSimGNNGraphConstructionTool::getDoubletEdges ( const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &  hits,
std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &  edges 
)
private

Definition at line 106 of file FPGATrackSimGNNGraphConstructionTool.cxx.

107 {
108  // Take the list of hits and use the doublet module map to generate all the edges between hits that pass the doublet cuts
109 
110  for (size_t i = 0; i < m_mid2.size(); i++) {
111  std::vector<std::shared_ptr<FPGATrackSimGNNHit>> hit1_matches;
112  std::vector<std::shared_ptr<FPGATrackSimGNNHit>> hit2_matches;
113 
114  std::vector<int> hit1_indices;
115  std::vector<int> hit2_indices;
116 
117  for (size_t j = 0; j < hits.size(); j++) {
118  if (hits[j]->getIdentifier() == m_mid1[i]) {
119  hit1_matches.emplace_back(hits[j]);
120  hit1_indices.emplace_back(j);
121  }
122  if (hits[j]->getIdentifier() == m_mid2[i]) {
123  hit2_matches.emplace_back(hits[j]);
124  hit2_indices.emplace_back(j);
125  }
126  }
127 
128  for (size_t h1 = 0; h1 < hit1_matches.size(); h1++) {
129  for (size_t h2 = 0; h2 < hit2_matches.size(); h2++) {
130  applyDoubletCuts(hit1_matches[h1], hit2_matches[h2], edges, hit1_indices[h1], hit2_indices[h2], i);
131  }
132  }
133  }
134 }

◆ getEdges()

StatusCode FPGATrackSimGNNGraphConstructionTool::getEdges ( const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &  hits,
std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &  edges 
)
virtual

Definition at line 38 of file FPGATrackSimGNNGraphConstructionTool.cxx.

39 {
40  if(m_graphTool == "ModuleMap") {
41  doModuleMap(hits, edges);
42  }
43  else if(m_graphTool == "MetricLearning") {
44  doMetricLearning(hits, edges);
45  }
46 
47  return StatusCode::SUCCESS;
48 }

◆ getNodeFeatures()

std::vector< float > FPGATrackSimGNNGraphConstructionTool::getNodeFeatures ( const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &  hits)
private

Definition at line 204 of file FPGATrackSimGNNGraphConstructionTool.cxx.

205 {
206  std::vector<float> gNodeFeatures;
207 
208  for(auto hit : hits) {
209  std::map<std::string, float> features;
210  features["r"] = hit->getR();
211  features["phi"] = hit->getPhi();
212  features["z"] = hit->getZ();
213 
214  for(size_t i = 0; i < m_MLFeatureNamesVec.size(); i++){
215  gNodeFeatures.push_back(
217  }
218  }
219  return gNodeFeatures;
220 }

◆ initialize()

StatusCode FPGATrackSimGNNGraphConstructionTool::initialize ( )
overridevirtual

Definition at line 15 of file FPGATrackSimGNNGraphConstructionTool.cxx.

16 {
17  if(m_graphTool == "ModuleMap") {
18  if(m_moduleMapPath == "") { // Require a path provided for the Module Map
19  ATH_MSG_FATAL("ERROR! No Module Map provided. Please provide a valid path to a ROOT file.");
20  return StatusCode::FAILURE;
21  }
22  if(m_moduleMapType == "doublet") {
23  loadDoubletModuleMap(); // Load the doublet module map and store entry branches in vectors
24  }
25  }
26  else if(m_graphTool == "MetricLearning") {
27  ATH_CHECK( m_MLInferenceTool.retrieve() );
28  m_MLInferenceTool->printModelInfo();
29  assert(m_MLFeatureNamesVec.size() == m_MLFeatureScalesVec.size());
30  }
31 
32  return StatusCode::SUCCESS;
33 }

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

◆ loadDoubletModuleMap()

void FPGATrackSimGNNGraphConstructionTool::loadDoubletModuleMap ( )
private

Definition at line 50 of file FPGATrackSimGNNGraphConstructionTool.cxx.

51 {
52  std::unique_ptr<TFile> file(TFile::Open(m_moduleMapPath.value().c_str()));
53  std::unique_ptr<TTree> tree(static_cast<TTree*>(file->Get("TreeModuleDoublet")));
54 
55  unsigned int mid1_value = 0;
56  unsigned int mid2_value = 0;
57  float z0min_12_value = 0.0;
58  float dphimin_12_value = 0.0;
59  float phislopemin_12_value = 0.0;
60  float detamin_12_value = 0.0;
61  float z0max_12_value = 0.0;
62  float dphimax_12_value = 0.0;
63  float phislopemax_12_value = 0.0;
64  float detamax_12_value = 0.0;
65 
66  tree->SetBranchAddress("Module1", &mid1_value);
67  tree->SetBranchAddress("Module2", &mid2_value);
68  tree->SetBranchAddress("z0min_12", &z0min_12_value);
69  tree->SetBranchAddress("dphimin_12", &dphimin_12_value);
70  tree->SetBranchAddress("phiSlopemin_12", &phislopemin_12_value);
71  tree->SetBranchAddress("detamin_12", &detamin_12_value);
72  tree->SetBranchAddress("z0max_12", &z0max_12_value);
73  tree->SetBranchAddress("dphimax_12", &dphimax_12_value);
74  tree->SetBranchAddress("phiSlopemax_12", &phislopemax_12_value);
75  tree->SetBranchAddress("detamax_12", &detamax_12_value);
76 
77  int64_t nEntries = tree->GetEntries();
78  for (int64_t i = 0; i < nEntries; ++i) {
79  tree->GetEntry(i);
80  m_mid1.emplace_back(mid1_value);
81  m_mid2.emplace_back(mid2_value);
82  m_z0min_12.emplace_back(z0min_12_value);
83  m_dphimin_12.emplace_back(dphimin_12_value);
84  m_phislopemin_12.emplace_back(phislopemin_12_value);
85  m_detamin_12.emplace_back(detamin_12_value);
86  m_z0max_12.emplace_back(z0max_12_value);
87  m_dphimax_12.emplace_back(dphimax_12_value);
88  m_phislopemax_12.emplace_back(phislopemax_12_value);
89  m_detamax_12.emplace_back(detamax_12_value);
90  }
91 }

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

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

std::vector<float> FPGATrackSimGNNGraphConstructionTool::m_detamax_12 {}
private

Definition at line 75 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_detamin_12

std::vector<float> FPGATrackSimGNNGraphConstructionTool::m_detamin_12 {}
private

Definition at line 71 of file FPGATrackSimGNNGraphConstructionTool.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_dphimax_12

std::vector<float> FPGATrackSimGNNGraphConstructionTool::m_dphimax_12 {}
private

Definition at line 73 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_dphimin_12

std::vector<float> FPGATrackSimGNNGraphConstructionTool::m_dphimin_12 {}
private

Definition at line 69 of file FPGATrackSimGNNGraphConstructionTool.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_graphTool

Gaudi::Property<std::string> FPGATrackSimGNNGraphConstructionTool::m_graphTool { this, "graphTool", "", "Tool for graph construction" }
private

Definition at line 54 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_metricLearningMaxN

Gaudi::Property<int> FPGATrackSimGNNGraphConstructionTool::m_metricLearningMaxN { this, "metricLearningMaxN", 1, "Max number of neighbours for Metric Learning"}
private

Definition at line 60 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_metricLearningR

Gaudi::Property<float> FPGATrackSimGNNGraphConstructionTool::m_metricLearningR { this, "metricLearningR", 0.0, "Clustering radius for Metric Learning"}
private

Definition at line 59 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_mid1

std::vector<unsigned int> FPGATrackSimGNNGraphConstructionTool::m_mid1 {}
private

Definition at line 66 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_mid2

std::vector<unsigned int> FPGATrackSimGNNGraphConstructionTool::m_mid2 {}
private

Definition at line 67 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_MLFeatureNamesVec

StringArrayProperty FPGATrackSimGNNGraphConstructionTool::m_MLFeatureNamesVec
private
Initial value:
{
this, "MLFeatureNames",
{"r", "phi", "z"},
"Feature names for the Metric Learning model"}

Definition at line 96 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_MLFeatureScalesVec

FloatArrayProperty FPGATrackSimGNNGraphConstructionTool::m_MLFeatureScalesVec
private
Initial value:
{
this, "MLFeatureScales",
{1000.0, 3.14159265359, 1000.0},
"Feature scales for the Metric Learning model"}

Definition at line 100 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_MLInferenceTool

ToolHandle<AthOnnx::IOnnxRuntimeInferenceTool> FPGATrackSimGNNGraphConstructionTool::m_MLInferenceTool {this, "MLInferenceTool", "AthOnnx::OnnxRuntimeInferenceTool"}
private

Definition at line 49 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_moduleMapFunc

Gaudi::Property<std::string> FPGATrackSimGNNGraphConstructionTool::m_moduleMapFunc { this, "moduleMapFunc", "", "Function for Module Map for graph construction" }
private

Definition at line 56 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_moduleMapPath

Gaudi::Property<std::string> FPGATrackSimGNNGraphConstructionTool::m_moduleMapPath { this, "moduleMapPath", "", "Location of Module Map ROOT file" }
private

Definition at line 58 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_moduleMapTol

Gaudi::Property<float> FPGATrackSimGNNGraphConstructionTool::m_moduleMapTol { this, "moduleMapTol", 0.0, "Tolerance value for Module Map cut calculations" }
private

Definition at line 57 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_moduleMapType

Gaudi::Property<std::string> FPGATrackSimGNNGraphConstructionTool::m_moduleMapType { this, "moduleMapType", "", "Type for Module Map for graph construction" }
private

Definition at line 55 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_phislopemax_12

std::vector<float> FPGATrackSimGNNGraphConstructionTool::m_phislopemax_12 {}
private

Definition at line 74 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_phislopemin_12

std::vector<float> FPGATrackSimGNNGraphConstructionTool::m_phislopemin_12 {}
private

Definition at line 70 of file FPGATrackSimGNNGraphConstructionTool.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.

◆ m_z0max_12

std::vector<float> FPGATrackSimGNNGraphConstructionTool::m_z0max_12 {}
private

Definition at line 72 of file FPGATrackSimGNNGraphConstructionTool.h.

◆ m_z0min_12

std::vector<float> FPGATrackSimGNNGraphConstructionTool::m_z0min_12 {}
private

Definition at line 68 of file FPGATrackSimGNNGraphConstructionTool.h.


The documentation for this class was generated from the following files:
getMenu.algname
algname
Definition: getMenu.py:54
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
FPGATrackSimGNNGraphConstructionTool::getNodeFeatures
std::vector< float > getNodeFeatures(const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:204
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSimGNNGraphConstructionTool::m_MLFeatureScalesVec
FloatArrayProperty m_MLFeatureScalesVec
Definition: FPGATrackSimGNNGraphConstructionTool.h:100
FPGATrackSimGNNGraphConstructionTool::m_metricLearningMaxN
Gaudi::Property< int > m_metricLearningMaxN
Definition: FPGATrackSimGNNGraphConstructionTool.h:60
hist_file_dump.d
d
Definition: hist_file_dump.py:142
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
FPGATrackSimGNNGraphConstructionTool::embed
std::vector< float > embed(const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:222
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
FPGATrackSimGNNGraphConstructionTool::m_dphimin_12
std::vector< float > m_dphimin_12
Definition: FPGATrackSimGNNGraphConstructionTool.h:69
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
tree
TChain * tree
Definition: tile_monitor.h:30
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
FPGATrackSimGNNGraphConstructionTool::m_moduleMapFunc
Gaudi::Property< std::string > m_moduleMapFunc
Definition: FPGATrackSimGNNGraphConstructionTool.h:56
FPGATrackSimGNNGraphConstructionTool::m_moduleMapTol
Gaudi::Property< float > m_moduleMapTol
Definition: FPGATrackSimGNNGraphConstructionTool.h:57
python.TurnDataReader.dr
dr
Definition: TurnDataReader.py:111
FPGATrackSimGNNEdge::setEdgeIndex1
void setEdgeIndex1(int v)
Definition: FPGATrackSimGNNEdge.h:27
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
read_hist_ntuple.h1
h1
Definition: read_hist_ntuple.py:21
FPGATrackSimGNNGraphConstructionTool::m_MLFeatureNamesVec
StringArrayProperty m_MLFeatureNamesVec
Definition: FPGATrackSimGNNGraphConstructionTool.h:96
FPGATrackSimGNNEdge::setEdgeIndex2
void setEdgeIndex2(int v)
Definition: FPGATrackSimGNNEdge.h:28
XMLtoHeader.count
count
Definition: XMLtoHeader.py:84
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:459
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
FPGATrackSimGNNGraphConstructionTool::applyDoubletCuts
void applyDoubletCuts(const std::shared_ptr< FPGATrackSimGNNHit > &hit1, const std::shared_ptr< FPGATrackSimGNNHit > &hit2, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges, int hit1_index, int hit2_index, unsigned int modulemap_id)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:136
FPGATrackSimGNNHit::getR
float getR() const
Definition: FPGATrackSimGNNHit.h:44
FPGATrackSimGNNGraphConstructionTool::m_z0min_12
std::vector< float > m_z0min_12
Definition: FPGATrackSimGNNGraphConstructionTool.h:68
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
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
P4Helpers::deltaPhi
double deltaPhi(double phiA, double phiB)
delta Phi in range [-pi,pi[
Definition: P4Helpers.h:34
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
Trk::index1
@ index1
Definition: BoundarySurfaceFace.h:48
lumiFormat.i
int i
Definition: lumiFormat.py:85
FPGATrackSimGNNGraphConstructionTool::doMetricLearning
void doMetricLearning(const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:195
FPGATrackSimGNNGraphConstructionTool::doMinMaxMask
bool doMinMaxMask(float val, float min, float max)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:176
FPGATrackSimGNNHit::getEta
float getEta() const
Definition: FPGATrackSimGNNHit.h:46
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
FPGATrackSimGNNGraphConstructionTool::m_phislopemin_12
std::vector< float > m_phislopemin_12
Definition: FPGATrackSimGNNGraphConstructionTool.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
FPGATrackSimGNNGraphConstructionTool::m_MLInferenceTool
ToolHandle< AthOnnx::IOnnxRuntimeInferenceTool > m_MLInferenceTool
Definition: FPGATrackSimGNNGraphConstructionTool.h:49
FPGATrackSimGNNGraphConstructionTool::m_detamin_12
std::vector< float > m_detamin_12
Definition: FPGATrackSimGNNGraphConstructionTool.h:71
file
TFile * file
Definition: tile_monitor.h:29
FPGATrackSimGNNGraphConstructionTool::getDoubletEdges
void getDoubletEdges(const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:106
FPGATrackSimGNNHit::getZ
float getZ() const
Definition: FPGATrackSimGNNHit.h:43
FPGATrackSimGNNGraphConstructionTool::m_phislopemax_12
std::vector< float > m_phislopemax_12
Definition: FPGATrackSimGNNGraphConstructionTool.h:74
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimGNNGraphConstructionTool::m_moduleMapType
Gaudi::Property< std::string > m_moduleMapType
Definition: FPGATrackSimGNNGraphConstructionTool.h:55
FPGATrackSimGNNGraphConstructionTool::m_z0max_12
std::vector< float > m_z0max_12
Definition: FPGATrackSimGNNGraphConstructionTool.h:72
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
FPGATrackSimGNNGraphConstructionTool::m_mid2
std::vector< unsigned int > m_mid2
Definition: FPGATrackSimGNNGraphConstructionTool.h:67
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
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
Trk::index2
@ index2
Definition: BoundarySurfaceFace.h:49
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
FPGATrackSimGNNGraphConstructionTool::doModuleMap
void doModuleMap(const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:93
FPGATrackSimGNNGraphConstructionTool::m_detamax_12
std::vector< float > m_detamax_12
Definition: FPGATrackSimGNNGraphConstructionTool.h:75
a
TList * a
Definition: liststreamerinfos.cxx:10
h
FPGATrackSimGNNGraphConstructionTool::m_mid1
std::vector< unsigned int > m_mid1
Definition: FPGATrackSimGNNGraphConstructionTool.h:66
FPGATrackSimGNNGraphConstructionTool::doClustering
void doClustering(const std::vector< std::shared_ptr< FPGATrackSimGNNHit >> &hits, std::vector< std::shared_ptr< FPGATrackSimGNNEdge >> &edges, std::vector< float > &gEmbedded)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:237
FPGATrackSimGNNGraphConstructionTool::doMask
bool doMask(float val, float min, float max)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:166
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
FPGATrackSimGNNGraphConstructionTool::m_metricLearningR
Gaudi::Property< float > m_metricLearningR
Definition: FPGATrackSimGNNGraphConstructionTool.h:59
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
FPGATrackSimGNNGraphConstructionTool::m_moduleMapPath
Gaudi::Property< std::string > m_moduleMapPath
Definition: FPGATrackSimGNNGraphConstructionTool.h:58
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
FPGATrackSimGNNHit::getPhi
float getPhi() const
Definition: FPGATrackSimGNNHit.h:45
FPGATrackSimGNNGraphConstructionTool::featureSign
float featureSign(float feature)
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:188
dqBeamSpot.nEntries
int nEntries
Definition: dqBeamSpot.py:72
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
FPGATrackSimGNNGraphConstructionTool::m_graphTool
Gaudi::Property< std::string > m_graphTool
Definition: FPGATrackSimGNNGraphConstructionTool.h:54
FPGATrackSimGNNGraphConstructionTool::loadDoubletModuleMap
void loadDoubletModuleMap()
Definition: FPGATrackSimGNNGraphConstructionTool.cxx:50
FPGATrackSimGNNGraphConstructionTool::m_dphimax_12
std::vector< float > m_dphimax_12
Definition: FPGATrackSimGNNGraphConstructionTool.h:73
fitman.k
k
Definition: fitman.py:528