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

#include <FPGATrackSimHoughRootOutputTool.h>

Inheritance diagram for FPGATrackSimHoughRootOutputTool:
Collaboration diagram for FPGATrackSimHoughRootOutputTool:

Public Member Functions

 FPGATrackSimHoughRootOutputTool (const std::string &, const std::string &, const IInterface *)
 
virtual StatusCode initialize () override
 
StatusCode fillTree (const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, const std::vector< FPGATrackSimTruthTrack > &truthTracks, const std::vector< FPGATrackSimOfflineTrack > &offlineTracks, const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits_2nd, const bool writeOutNonSPStripHits, const float minChi2, const int maxOverlappingHits, const bool roadsAreSecondStage)
 
StatusCode fillTree (const std::vector< FPGATrackSimTrack > &track_cands, const std::vector< FPGATrackSimTruthTrack > &truthTracks, const std::vector< FPGATrackSimOfflineTrack > &offlineTracks, const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits_2nd, const bool writeOutNonSPStripHits, const bool roadsAreSecondStage)
 
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< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode bookTree ()
 
void ResetVectors ()
 
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

ServiceHandle< IFPGATrackSimEventSelectionSvc > m_EvtSel {this, "FPGATrackSimEventSelectionSvc", "FPGATrackSimEventSelectionSvc"}
 
ServiceHandle< IFPGATrackSimMappingSvc > m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", ""}
 
ServiceHandle< ITHistSvc > m_tHistSvc {this, "THistSvc", "THistSvc"}
 
Gaudi::Property< std::string > m_algorithm { this, "ORAlgo", "Normal", "Overlap removal algorithm"}
 
Gaudi::Property< std::string > m_region { this, "OutputRegion", "", "region ID"}
 
ORAlgo m_algo {ORAlgo::Normal}
 
const FPGATrackSimRegionMap * m_SUBREGIONMAP {nullptr}
 
TrackCorrType m_IdealCoordFitType = TrackCorrType::None
 
ToolHandle< GenericMonitoringTool > m_monTool {this,"MonTool", "", "Monitoring tool"}
 
TTree * m_tree = nullptr
 
std::vector< float > m_x
 
std::vector< float > m_y
 
std::vector< float > m_z
 
std::vector< int > m_volumeID
 
std::vector< int > m_custom_layerID
 
std::vector< int > m_layerID
 
std::vector< int > m_etaID
 
std::vector< float > m_gphi
 
std::vector< float > m_zIdeal
 
std::vector< float > m_gphiIdeal
 
std::vector< float > m_barcodefrac
 
std::vector< unsigned long > m_barcode
 
std::vector< int > m_eventindex
 
std::vector< unsigned int > m_isPixel
 
std::vector< unsigned int > m_layer
 
std::vector< unsigned int > m_isBarrel
 
std::vector< unsigned int > m_etawidth
 
std::vector< unsigned int > m_phiwidth
 
std::vector< unsigned int > m_etamodule
 
std::vector< unsigned int > m_phimodule
 
std::vector< unsigned int > m_ID
 
std::vector< unsigned int > m_diskLayer
 
std::vector< unsigned int > m_passesOR
 
std::vector< float > m_roadChi2
 
std::vector< float > m_nMissingHits
 
std::vector< bool > m_mapped
 
std::vector< bool > m_realHit
 
TrackCorrType m_idealCoordFitType = TrackCorrType::None
 
float m_phi = 0.0F
 
float m_invpt = 0.0F
 
unsigned int m_subregion = 0
 
long m_NTracksORMinusRoads = 0
 
float m_candidate_barcodefrac = 0.0F
 
float m_candidate_barcode = 0.0F
 
float m_candidate_eventindex = 0.0F
 
unsigned int m_fakelabel = 0
 
float m_associated_truth_d0 = 9999
 
float m_associated_truth_z0 = 9999
 
float m_associated_truth_pt = 9999
 
float m_associated_truth_q = 9999
 
float m_associated_truth_eta = 9999
 
float m_associated_truth_phi = 9999
 
int m_tracknumber = 0
 
int m_treeindex = 0
 
int m_roadnumber = 0
 
TTree * m_truthtree = nullptr
 
std::vector< float > m_truth_d0
 
std::vector< float > m_truth_z0
 
std::vector< float > m_truth_pt
 
std::vector< float > m_truth_eta
 
std::vector< float > m_truth_phi
 
std::vector< float > m_truth_pdg
 
std::vector< int > m_truth_q
 
std::vector< int > m_truth_barcode
 
std::vector< int > m_truth_eventindex
 
std::vector< bool > m_has_strip_nonspacepoint
 
std::vector< std::vector< float > > m_track_hit_x
 
std::vector< std::vector< float > > m_track_hit_y
 
std::vector< std::vector< float > > m_track_hit_z
 
std::vector< std::vector< float > > m_track_hit_R
 
std::vector< std::vector< float > > m_track_hit_eta
 
std::vector< std::vector< float > > m_track_hit_phi
 
std::vector< std::vector< int > > m_track_hit_layer_disk
 
std::vector< std::vector< bool > > m_track_hit_isPixel
 
std::vector< std::vector< bool > > m_track_hit_isStrip
 
std::vector< std::vector< bool > > m_track_hit_isClustered
 
std::vector< std::vector< bool > > m_track_hit_isSpacepoint
 
std::vector< std::vector< bool > > m_track_hit_isMapped
 
std::vector< std::vector< int > > m_track_hit_barcode
 
std::vector< std::vector< float > > m_track_hit_barcodefrac
 
std::vector< std::vector< float > > m_track_hit_zIdeal
 
std::vector< std::vector< float > > m_track_hit_gphiIdeal
 
std::vector< std::vector< long > > m_track_hit_fineID
 
std::vector< std::vector< int > > m_track_hit_volumeID
 
TTree * m_offlinetree = nullptr
 
std::vector< int > m_offline_n_holes
 
std::vector< int > m_offline_n_measurement
 
std::vector< int > m_offline_n_inertmaterial
 
std::vector< int > m_offline_n_brempoint
 
std::vector< int > m_offline_n_scatterer
 
std::vector< int > m_offline_n_perigee
 
std::vector< int > m_offline_n_outlier
 
std::vector< int > m_offline_n_other
 
std::vector< float > m_offline_d0
 
std::vector< float > m_offline_z0
 
std::vector< float > m_offline_pt
 
std::vector< float > m_offline_eta
 
std::vector< float > m_offline_phi
 
std::vector< int > m_offline_q
 
std::vector< int > m_offline_barcode
 
std::vector< float > m_offline_barcodefrac
 
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 41 of file FPGATrackSimHoughRootOutputTool.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

◆ FPGATrackSimHoughRootOutputTool()

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

Definition at line 12 of file FPGATrackSimHoughRootOutputTool.cxx.

12  :
13  AthAlgTool(algname, name, ifc)
14 {
15 }

Member Function Documentation

◆ bookTree()

StatusCode FPGATrackSimHoughRootOutputTool::bookTree ( )
private

Definition at line 35 of file FPGATrackSimHoughRootOutputTool.cxx.

36 {
37  std::string tree_str = "FPGATrackSimHoughRootOutput_reg" + m_region.value();
38  m_tree = new TTree(tree_str.c_str(), tree_str.c_str());
39 
40  m_tree->Branch("x",&m_x);
41  m_tree->Branch("y",&m_y);
42  m_tree->Branch("z",&m_z);
43  m_tree->Branch("volumeID",&m_volumeID);
44  m_tree->Branch("custom_layerID",&m_custom_layerID);
45 
46  m_tree->Branch("layerID",&m_layerID);
47  m_tree->Branch("etaID",&m_etaID);
48 
49  m_tree->Branch("associated_truth_d0",&m_associated_truth_d0);
50  m_tree->Branch("associated_truth_z0",&m_associated_truth_z0);
51  m_tree->Branch("associated_truth_pt",&m_associated_truth_pt);
52  m_tree->Branch("associated_truth_q",&m_associated_truth_q);
53  m_tree->Branch("associated_truth_eta",&m_associated_truth_eta);
54  m_tree->Branch("associated_truth_phi",&m_associated_truth_phi);
55 
56  m_tree->Branch("gphi",&m_gphi);
57  m_tree->Branch("zIdeal",&m_zIdeal);
58  m_tree->Branch("gphiIdeal",&m_gphiIdeal);
59  m_tree->Branch("phi",&m_phi);
60  m_tree->Branch("invpt",&m_invpt);
61  m_tree->Branch("tracknumber",&m_tracknumber);
62  m_tree->Branch("roadnumber",&m_roadnumber);
63  m_tree->Branch("barcode",&m_barcode);
64  m_tree->Branch("barcodefrac",&m_barcodefrac);
65  m_tree->Branch("eventindex",&m_eventindex);
66  m_tree->Branch("isRealHit",&m_realHit);
67  m_tree->Branch("isPixel",&m_isPixel);
68  m_tree->Branch("layer",&m_layer);
69  m_tree->Branch("isBarrel",&m_isBarrel);
70  m_tree->Branch("etawidth",&m_etawidth);
71  m_tree->Branch("phiwidth",&m_phiwidth);
72  m_tree->Branch("etamodule",&m_etamodule);
73  m_tree->Branch("phimodule",&m_phimodule);
74  m_tree->Branch("ID",&m_ID);
75  m_tree->Branch("diskLayer",&m_diskLayer);
76 
77  m_tree->Branch("candidate_barcodefrac",&m_candidate_barcodefrac);
78  m_tree->Branch("candidate_barcode",&m_candidate_barcode);
79  m_tree->Branch("candidate_eventindex",&m_candidate_eventindex);
80  m_tree->Branch("treeindex",&m_treeindex);
81  m_tree->Branch("subregion",&m_subregion);
82  m_tree->Branch("fakelabel",&m_fakelabel);
83  m_tree->Branch("passesOR",&m_passesOR);
84  m_tree->Branch("roadChi2",&m_roadChi2);
85  m_tree->Branch("nMissingHits",&m_nMissingHits);
86  m_tree->Branch("NTracksORMinusRoads",&m_NTracksORMinusRoads);
87 
88  m_treeindex = 0;
89 
90  std::string truthtree_str = "FPGATrackSimTruthTree_reg" + m_region.value();
91  m_truthtree = new TTree(truthtree_str.c_str(), truthtree_str.c_str());
92 
93  m_truthtree->Branch("truth_d0",&m_truth_d0);
94  m_truthtree->Branch("truth_z0",&m_truth_z0);
95  m_truthtree->Branch("truth_pt",&m_truth_pt);
96  m_truthtree->Branch("truth_eta",&m_truth_eta);
97  m_truthtree->Branch("truth_phi",&m_truth_phi);
98  m_truthtree->Branch("truth_q",&m_truth_q);
99  m_truthtree->Branch("truth_pdg",&m_truth_pdg);
100  m_truthtree->Branch("truth_barcode",&m_truth_barcode);
101  m_truthtree->Branch("truth_eventindex",&m_truth_eventindex);
102  m_truthtree->Branch("truth_track_hit_x",&m_track_hit_x);
103  m_truthtree->Branch("truth_track_hit_y",&m_track_hit_y);
104  m_truthtree->Branch("truth_track_hit_z",&m_track_hit_z);
105  m_truthtree->Branch("truth_track_hit_R",&m_track_hit_R);
106  m_truthtree->Branch("truth_track_hit_phi",&m_track_hit_phi);
107  m_truthtree->Branch("truth_track_hit_layer_disk",&m_track_hit_layer_disk);
108  m_truthtree->Branch("has_strip_nonspacepoint",&m_has_strip_nonspacepoint);
109  m_truthtree->Branch("truth_track_hit_isPixel", &m_track_hit_isPixel);
110  m_truthtree->Branch("truth_track_hit_isStrip", &m_track_hit_isStrip);
111  m_truthtree->Branch("truth_track_hit_isClustered", &m_track_hit_isClustered);
112  m_truthtree->Branch("truth_track_hit_isSpacepoint", &m_track_hit_isSpacepoint);
113  m_truthtree->Branch("truth_track_hit_barcode", &m_track_hit_barcode);
114  m_truthtree->Branch("truth_track_hit_barcodefrac", &m_track_hit_barcodefrac);
115  m_truthtree->Branch("truth_track_hit_zIdeal", &m_track_hit_zIdeal);
116  m_truthtree->Branch("truth_track_hit_gphiIdeal", &m_track_hit_gphiIdeal);
117  m_truthtree->Branch("truth_track_hit_fineID", &m_track_hit_fineID);
118  m_truthtree->Branch("truth_track_hit_volumeID", &m_track_hit_volumeID);
119  m_truthtree->Branch("truth_track_hit_isMapped", &m_track_hit_isMapped);
120 
121  std::string offltree_str = "FPGATrackSimOfflineTree_reg" + m_region.value();
122  m_offlinetree = new TTree(offltree_str.c_str(), offltree_str.c_str());
123 
124  m_offlinetree->Branch("offline_d0",&m_offline_d0);
125  m_offlinetree->Branch("offline_z0",&m_offline_z0);
126  m_offlinetree->Branch("offline_pt",&m_offline_pt);
127  m_offlinetree->Branch("offline_eta",&m_offline_eta);
128  m_offlinetree->Branch("offline_phi",&m_offline_phi);
129  m_offlinetree->Branch("offline_q",&m_offline_q);
130  m_offlinetree->Branch("offline_barcode",&m_offline_barcode);
131  m_offlinetree->Branch("offline_barcodefrac",&m_offline_barcodefrac);
132  m_offlinetree->Branch("offline_n_holes",&m_offline_n_holes);
133  m_offlinetree->Branch("offline_n_inertmaterial",&m_offline_n_inertmaterial);
134  m_offlinetree->Branch("offline_n_measurement",&m_offline_n_measurement);
135  m_offlinetree->Branch("offline_n_brempoint",&m_offline_n_brempoint);
136  m_offlinetree->Branch("offline_n_scatterer",&m_offline_n_scatterer);
137  m_offlinetree->Branch("offline_n_perigee",&m_offline_n_perigee);
138  m_offlinetree->Branch("offline_n_outlier",&m_offline_n_outlier);
139  m_offlinetree->Branch("offline_n_other",&m_offline_n_other);
140 
141  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_tree->GetName()), m_tree));
142  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_truthtree->GetName()), m_truthtree));
143  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_offlinetree->GetName()), m_offlinetree));
144 
145  return StatusCode::SUCCESS;
146 }

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

◆ fillTree() [1/2]

StatusCode FPGATrackSimHoughRootOutputTool::fillTree ( const std::vector< FPGATrackSimTrack > &  track_cands,
const std::vector< FPGATrackSimTruthTrack > &  truthTracks,
const std::vector< FPGATrackSimOfflineTrack > &  offlineTracks,
const std::vector< std::shared_ptr< const FPGATrackSimHit >> &  hits_2nd,
const bool  writeOutNonSPStripHits,
const bool  roadsAreSecondStage 
)

Definition at line 149 of file FPGATrackSimHoughRootOutputTool.cxx.

150 {
151  ATH_MSG_DEBUG("Running HoughOutputTool!!");
152 
153  m_tracknumber = 0;
154  ResetVectors();
155 
156  if (roadsAreSecondStage) m_SUBREGIONMAP = m_FPGATrackSimMapping->SubRegionMap_2nd();
157  else m_SUBREGIONMAP = m_FPGATrackSimMapping->SubRegionMap();
158 
159 
160  std::vector<float> tmp_hits_x;
161  std::vector<float> tmp_hits_y;
162  std::vector<float> tmp_hits_z;
163  std::vector<float> tmp_hits_R;
164  std::vector<float> tmp_hits_phi;
165  std::vector<int> tmp_hits_layer_disk;
166  std::vector<bool> tmp_hits_mapped;
167  std::vector<bool> tmp_hits_isPixel;
168  std::vector<bool> tmp_hits_isStrip;
169  std::vector<bool> tmp_hits_isClustered;
170  std::vector<bool> tmp_hits_isSpacepoint;
171  std::vector<float> tmp_hits_barcodefrac;
172  std::vector<int> tmp_hits_barcode;
173  std::vector<float> tmp_hits_zIdeal;
174  std::vector<float> tmp_hits_gphiIdeal;
175  std::vector<long> tmp_hits_fineID;
176  std::vector<int> tmp_hits_volumeID;
177 
178  std::vector<float> tmp_hits_x_sorted;
179  std::vector<float> tmp_hits_y_sorted;
180  std::vector<float> tmp_hits_z_sorted;
181  std::vector<float> tmp_hits_R_sorted;
182  std::vector<float> tmp_hits_phi_sorted;
183  std::vector<int> tmp_hits_layer_disk_sorted;
184  std::vector<bool> tmp_hits_isPixel_sorted;
185  std::vector<bool> tmp_hits_isStrip_sorted;
186  std::vector<bool> tmp_hits_isClustered_sorted;
187  std::vector<bool> tmp_hits_isSpacepoint_sorted;
188  std::vector<float> tmp_hits_barcodefrac_sorted;
189  std::vector<int> tmp_hits_barcode_sorted;
190  std::vector<float> tmp_hits_zIdeal_sorted;
191  std::vector<float> tmp_hits_gphiIdeal_sorted;
192  std::vector<long> tmp_hits_fineID_sorted;
193  std::vector<int> tmp_hits_volumeID_sorted;
194 
195  std::vector<bool> tmp_hits_mapped_sorted;
196  bool has_strip_nonspacepoint;
197 
198 
199  // fill the truth tree, simply once per event! to know which entry here to loop at for a given road or hit
200  // combination below, use treeindex from below to find the entry here
201  for (const auto & track : truthTracks) {
202  if (!m_EvtSel->passCuts(track)) continue;
203  if (track.getStatus() != 1) continue;
204 
205 
206  tmp_hits_x.clear();
207  tmp_hits_y.clear();
208  tmp_hits_z.clear();
209  tmp_hits_R.clear();
210  tmp_hits_phi.clear();
211  tmp_hits_layer_disk.clear();
212  tmp_hits_mapped.clear();
213  tmp_hits_isPixel.clear();
214  tmp_hits_isStrip.clear();
215  tmp_hits_isClustered.clear();
216  tmp_hits_isSpacepoint.clear();
217  tmp_hits_barcodefrac.clear();
218  tmp_hits_barcode.clear();
219  tmp_hits_zIdeal.clear();
220  tmp_hits_gphiIdeal.clear();
221  tmp_hits_fineID.clear();
222 
223  tmp_hits_x_sorted.clear();
224  tmp_hits_y_sorted.clear();
225  tmp_hits_z_sorted.clear();
226  tmp_hits_R_sorted.clear();
227  tmp_hits_phi_sorted.clear();
228  tmp_hits_layer_disk_sorted.clear();
229  tmp_hits_mapped_sorted.clear();
230  tmp_hits_isPixel_sorted.clear();
231  tmp_hits_isStrip_sorted.clear();
232  tmp_hits_isClustered_sorted.clear();
233  tmp_hits_isSpacepoint_sorted.clear();
234  tmp_hits_barcodefrac_sorted.clear();
235  tmp_hits_barcode_sorted.clear();
236  tmp_hits_zIdeal_sorted.clear();
237  tmp_hits_gphiIdeal_sorted.clear();
238  tmp_hits_fineID_sorted.clear();
239  tmp_hits_volumeID.clear();
240 
241  has_strip_nonspacepoint = false;
242 
243  double target_r;
244  std::vector<float> idealized_coords;
245  FPGATrackSimMultiTruth::Barcode tbarcode;
246  FPGATrackSimMultiTruth::Weight tfrac;
247 
248  // Collect truth tracks' 2nd stage hits
249  for (auto hit : hits_2nd) {
250  // Only write out hits belonging to the truth track
251  if (hit->getBarcode() == track.getBarcode()) {
252 
253  if (hit->isPixel() == 0 && hit->getHitType() != HitType::spacepoint) {has_strip_nonspacepoint = true;}
254 
255  FPGATrackSimMultiTruth truth = hit->getTruth();
256  truth.assign_equal_normalization();
257 
258  const bool ok = truth.best(tbarcode, tfrac);
259  if (tfrac < 1.0) { continue; }
260  if( ok ) {
261  tmp_hits_barcode.push_back((int)(tbarcode.second));
262  tmp_hits_barcodefrac.push_back(tfrac);
263  }
264  else {
265  tmp_hits_barcode.push_back(-1);
266  tmp_hits_barcodefrac.push_back(-1);
267  }
268 
269  tmp_hits_x.push_back(hit->getX());
270  tmp_hits_y.push_back(hit->getY());
271  tmp_hits_z.push_back(hit->getZ());
272  tmp_hits_R.push_back(hit->getR());
273  tmp_hits_phi.push_back(hit->getGPhi());
274  tmp_hits_layer_disk.push_back(hit->getLayerDisk(true));
275  tmp_hits_volumeID.push_back(getVolumeID(*hit));
276  tmp_hits_mapped.push_back(hit->isMapped());
277  tmp_hits_isPixel.push_back(hit->isPixel());
278  tmp_hits_isStrip.push_back(hit->isStrip());
279  tmp_hits_isClustered.push_back(hit->isClustered());
280 
281  tmp_hits_fineID.push_back(getFineID(*hit));
282 
283  target_r = m_SUBREGIONMAP->getAvgRadius(0, hit->getLayerDisk());
284  idealized_coords = computeIdealCoords(*hit, hit->getGPhi(), track.getQOverPt(), target_r, true, TrackCorrType::None);
285  tmp_hits_zIdeal.push_back(idealized_coords[0]);
286  tmp_hits_gphiIdeal.push_back(idealized_coords[1]);
287 
288  if (hit->getHitType() == HitType::spacepoint) {
289  tmp_hits_isSpacepoint.push_back(true);
290  }
291  else {
292  tmp_hits_isSpacepoint.push_back(false);
293  }
294  }
295  }
296 
297 
298  m_has_strip_nonspacepoint.push_back(has_strip_nonspacepoint);
299 
300  if ( (! writeOutNonSPStripHits & has_strip_nonspacepoint)) {
301  ATH_MSG_DEBUG("Truth Track is not written to HoughRootOutput file, because it contains a non-SP strip hit!");
302  continue;
303  }
304 
305  std::vector<int> sorting_index(tmp_hits_R.size(), 0);
306  for (unsigned int i = 0 ; i != sorting_index.size() ; i++) {
307  sorting_index[i] = i;
308  }
309  sort(sorting_index.begin(), sorting_index.end(),
310  [&](const int& a, const int& b) {
311  return (tmp_hits_R[a] < tmp_hits_R[b]);
312  }
313  );
314 
315  for (unsigned int i = 0 ; i != sorting_index.size() ; i++) {
316  tmp_hits_x_sorted.push_back(tmp_hits_x[sorting_index[i]]);
317  tmp_hits_y_sorted.push_back(tmp_hits_y[sorting_index[i]]);
318  tmp_hits_z_sorted.push_back(tmp_hits_z[sorting_index[i]]);
319  tmp_hits_R_sorted.push_back(tmp_hits_R[sorting_index[i]]);
320  tmp_hits_phi_sorted.push_back(tmp_hits_phi[sorting_index[i]]);
321  tmp_hits_layer_disk_sorted.push_back(tmp_hits_layer_disk[sorting_index[i]]);
322  tmp_hits_isPixel_sorted.push_back(tmp_hits_isPixel[sorting_index[i]]);
323  tmp_hits_isStrip_sorted.push_back(tmp_hits_isStrip[sorting_index[i]]);
324  tmp_hits_isClustered_sorted.push_back(tmp_hits_isClustered[sorting_index[i]]);
325  tmp_hits_isSpacepoint_sorted.push_back(tmp_hits_isSpacepoint[sorting_index[i]]);
326  tmp_hits_barcode_sorted.push_back(tmp_hits_barcode[sorting_index[i]]);
327  tmp_hits_barcodefrac_sorted.push_back(tmp_hits_barcodefrac[sorting_index[i]]);
328  tmp_hits_zIdeal_sorted.push_back(tmp_hits_zIdeal[sorting_index[i]]);
329  tmp_hits_gphiIdeal_sorted.push_back(tmp_hits_gphiIdeal[sorting_index[i]]);
330  tmp_hits_fineID_sorted.push_back(tmp_hits_fineID[sorting_index[i]]);
331  tmp_hits_volumeID_sorted.push_back(tmp_hits_volumeID[sorting_index[i]]);
332  tmp_hits_mapped_sorted.push_back(tmp_hits_mapped[sorting_index[i]]);
333 
334  };
335 
336  m_track_hit_x.push_back(tmp_hits_x_sorted);
337  m_track_hit_y.push_back(tmp_hits_y_sorted);
338  m_track_hit_z.push_back(tmp_hits_z_sorted);
339  m_track_hit_R.push_back(tmp_hits_R_sorted);
340  m_track_hit_phi.push_back(tmp_hits_phi_sorted);
341  m_track_hit_layer_disk.push_back(tmp_hits_layer_disk_sorted);
342  m_track_hit_isPixel.push_back(tmp_hits_isPixel_sorted);
343  m_track_hit_isStrip.push_back(tmp_hits_isStrip);
344  m_track_hit_isClustered.push_back(tmp_hits_isClustered_sorted);
345  m_track_hit_isSpacepoint.push_back(tmp_hits_isSpacepoint_sorted);
346  m_track_hit_barcode.push_back(tmp_hits_barcode_sorted);
347  m_track_hit_barcodefrac.push_back(tmp_hits_barcodefrac_sorted);
348  m_track_hit_zIdeal.push_back(tmp_hits_zIdeal_sorted);
349  m_track_hit_gphiIdeal.push_back(tmp_hits_gphiIdeal_sorted);
350  m_track_hit_fineID.push_back(tmp_hits_fineID_sorted);
351  m_track_hit_volumeID.push_back(tmp_hits_volumeID_sorted);
352  m_track_hit_isMapped.push_back(tmp_hits_mapped_sorted);
353 
354  m_truth_d0.push_back(track.getD0());
355  m_truth_z0.push_back(track.getZ0());
356  m_truth_pt.push_back(track.getPt());
357  m_truth_eta.push_back(track.getEta());
358  m_truth_phi.push_back(track.getPhi());
359  m_truth_barcode.push_back(track.getBarcode());
360  m_truth_eventindex.push_back(track.getEventIndex());
361  m_truth_q.push_back(track.getQ());
362  m_truth_pdg.push_back(track.getPDGCode());
363  }
364  // Fill only if at least one truth track to save to avoid empty events
365  if (m_truth_eventindex.size() != 0) {
366  m_truthtree->Fill();
367  }
368  ResetVectors();
369 
370 
371  // now do the same for offline tree, once per event
372  for (const auto & track : offlineTracks) {
373  if (!m_EvtSel->passCuts(track)) continue;
374 
375  m_offline_d0.push_back(track.getD0());
376  m_offline_z0.push_back(track.getZ0());
377  m_offline_pt.push_back(abs(1./track.getQOverPt()));
378  m_offline_eta.push_back(track.getEta());
379  m_offline_phi.push_back(track.getPhi());
380  m_offline_barcode.push_back(track.getBarcode());
381  m_offline_barcodefrac.push_back(track.getBarcodeFrac());
382 
383  m_offline_q.push_back(track.getQOverPt() > 0 ? 1 : -1);
384  int nhole(0), nmeasurement(0), ninert(0), nbrem(0), nscatter(0), nperigee(0), noutlier(0), nother(0);
385  for (const auto& hit : track.getOfflineHits()) {
386  if (hit.getHitType() == OfflineHitType::Measurement) nmeasurement++;
387  else if (hit.getHitType() == OfflineHitType::InertMaterial) ninert++;
388  else if (hit.getHitType() == OfflineHitType::BremPoint) nbrem++;
389  else if (hit.getHitType() == OfflineHitType::Scatterer) nscatter++;
390  else if (hit.getHitType() == OfflineHitType::Perigee) nperigee++;
391  else if (hit.getHitType() == OfflineHitType::Outlier) noutlier++;
392  else if (hit.getHitType() == OfflineHitType::Hole) nhole++;
393  else nother++;
394  }
395  m_offline_n_holes.push_back(nhole);
396  m_offline_n_measurement.push_back(nmeasurement);
397  m_offline_n_inertmaterial.push_back(ninert);
398  m_offline_n_brempoint.push_back(nbrem);
399  m_offline_n_scatterer.push_back(nscatter);
400  m_offline_n_perigee.push_back(nperigee);
401  m_offline_n_outlier.push_back(noutlier);
402  m_offline_n_other.push_back(nother);
403  }
404  m_offlinetree->Fill();
405  ResetVectors();
406 
407  // for calculating the truth for the entire combination, not just an individual hit
408  std::vector<FPGATrackSimMultiTruth> mtv;
409 
410  double target_r;
411 
412  for (size_t iroad = 0; iroad < track_cands.size(); iroad++) {
413  m_roadnumber = iroad;
414  FPGATrackSimTrack road = track_cands[iroad];
415 
416  if (roadsAreSecondStage) {
417  mtv.reserve( m_FPGATrackSimMapping->PlaneMap_2nd(road.getSubRegion())->getNLogiLayers());
418  }
419  else {
420  mtv.reserve( m_FPGATrackSimMapping->PlaneMap_1st(road.getSubRegion())->getNLogiLayers());
421  }
422 
423  m_roadChi2.push_back(track_cands[iroad].getChi2ndof());
424 
425  m_nMissingHits.push_back(track_cands[iroad].getNMissing());
426 
427  m_passesOR.push_back(road.passedOR());
428 
429  m_phi = road.getHoughX();
430  m_invpt = road.getHoughY();
431  m_subregion = road.getRegion();
432  std::vector<FPGATrackSimHit> hits = road.getFPGATrackSimHits();
433 
434 
435  // Add the hits from each combination to the tree
436  for (FPGATrackSimHit hit : hits) {
437 
438  m_realHit.push_back(hit.isReal());
439  FPGATrackSimMultiTruth truth = hit.getTruth();
440 
441  truth.assign_equal_normalization();
442  mtv.push_back( truth );
443 
444  FPGATrackSimMultiTruth::Barcode tbarcode;
445  FPGATrackSimMultiTruth::Weight tfrac;
446  const bool ok = truth.best(tbarcode,tfrac);
447  if( ok ) {
448  m_eventindex.push_back((int)(tbarcode.first));
449  m_barcode.push_back((int)(tbarcode.second));
450  m_barcodefrac.push_back(tfrac);
451  }
452  else {
453  m_eventindex.push_back(-1);
454  m_barcode.push_back(-1);
455  m_barcodefrac.push_back(-1);
456  }
457 
458  target_r = m_SUBREGIONMAP->getAvgRadius(0, hit.getLayer());
459  std::shared_ptr<const FPGATrackSimHit> hit_ptr = std::make_shared<const FPGATrackSimHit>(hit);
460  std::vector<float> idealized_coords = computeIdealCoords(hit, m_invpt, hit.getGPhi(), target_r, true, TrackCorrType::None);
461 
462  m_x.push_back(hit.getX());
463  m_y.push_back(hit.getY());
464  m_z.push_back(hit.getZ());
465  m_volumeID.push_back(getVolumeID(*hit_ptr));
466  m_custom_layerID.push_back(getFineID(*hit_ptr));
467  m_layerID.push_back(hit.getLayerDisk(true));
468  m_etaID.push_back(hit.getEtaModule(true));
469 
470  m_gphi.push_back(hit.getGPhi());
471  m_zIdeal.push_back(idealized_coords[0]);
472  m_gphiIdeal.push_back(idealized_coords[1]);
473  m_isPixel.push_back(hit.isPixel() ? 1 : 0);
474  m_layer.push_back(hit.getLayer());
475  m_isBarrel.push_back(hit.isBarrel() ? 1 : 0);
476  m_etawidth.push_back(hit.getEtaWidth());
477  m_phiwidth.push_back(hit.getPhiWidth());
478  m_etamodule.push_back(hit.getEtaModule(true));
479  m_phimodule.push_back(hit.getPhiModule());
480  m_ID.push_back(hit.getIdentifierHash());
481  m_diskLayer.push_back(hit.getLayerDisk(true));
482  }
483 
484  // done looping over hits, now we do the truth calculation for this track candidate
485  // first compute the best geant match, the barcode with the largest number of contributing hits
486  // frac is then the fraction of the total number of hits on the candidate attributed to the barcode.
487  FPGATrackSimMultiTruth mt( std::accumulate(mtv.begin(),mtv.end(),FPGATrackSimMultiTruth(),FPGATrackSimMultiTruth::AddAccumulator()) );
488  // retrieve the best barcode and frac and store it
489  FPGATrackSimMultiTruth::Barcode tbarcode;
490  FPGATrackSimMultiTruth::Weight tfrac;
491  const bool ok = mt.best(tbarcode,tfrac);
492  if( ok ) {
493  m_candidate_eventindex = (int)(tbarcode.first);
494  m_candidate_barcode = (int)(tbarcode.second);
495  m_candidate_barcodefrac = tfrac;
496  if ( tfrac <= 0.5 ) m_fakelabel = 1;
497  else if ( tfrac == 1.0 ) m_fakelabel = 0;
498  }
499  else {
500  m_candidate_eventindex = -1;
501  m_candidate_barcode = -1;
502  m_candidate_barcodefrac = 0;
503  m_fakelabel = 2;
504  }
505 
506  for (const auto & track : truthTracks) {
507  if (!m_EvtSel->passCuts(track)) continue;
508  if (track.getStatus() != 1) continue;
509 
510  m_associated_truth_d0 = track.getD0();
511  m_associated_truth_z0 = track.getZ0();
512  m_associated_truth_pt = track.getPt();
513  m_associated_truth_q = track.getQ();
514  m_associated_truth_eta = track.getEta();
515  m_associated_truth_phi = track.getPhi();
516  break;
517  }
518 
519  m_tree->Fill();
520 
521  mtv.clear();
522  ResetVectors();
523  m_tracknumber++;
524  }
525  m_treeindex++;
526  return StatusCode::SUCCESS;
527 }

◆ fillTree() [2/2]

StatusCode FPGATrackSimHoughRootOutputTool::fillTree ( const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &  roads,
const std::vector< FPGATrackSimTruthTrack > &  truthTracks,
const std::vector< FPGATrackSimOfflineTrack > &  offlineTracks,
const std::vector< std::shared_ptr< const FPGATrackSimHit >> &  hits_2nd,
const bool  writeOutNonSPStripHits,
const float  minChi2,
const int  maxOverlappingHits,
const bool  roadsAreSecondStage 
)

Definition at line 531 of file FPGATrackSimHoughRootOutputTool.cxx.

532 {
533  ATH_MSG_DEBUG("Running HoughOutputTool!!");
534 
535 
536  // Create a list of track candidates by taking all possible combinations of hits in road.
537  std::vector<FPGATrackSimTrack> track_cands;
538 
539  for (size_t iroad = 0; iroad < roads.size(); iroad++) {
540  m_roadnumber = iroad;
541  std::shared_ptr<const FPGATrackSimRoad> road = roads[iroad];
542  std::vector<FPGATrackSimTrack> track_cand;
543  if (road == nullptr) continue; // Not Hough roads
544 
545  auto pmap = m_FPGATrackSimMapping->PlaneMap_1st(road->getSubRegion());
546 
547  if (roadsAreSecondStage) {
548  pmap = m_FPGATrackSimMapping->PlaneMap_2nd(road->getSubRegion());
549  }
550 
551  std::vector<std::vector<int>> combs = ::getComboIndices(road->getNHits_layer());
552  m_phi = road->getX();
553  m_invpt = road->getY();
554 
555  // Build track candidate for OR tool
556  int nMissing;
557  bool missPixel;
558  bool missStrip;
559  layer_bitmask_t missing_mask;
560  layer_bitmask_t norecovery_mask; // mask to prevent majority in planes with multiple hits
561  getMissingInfo(*road, nMissing, missPixel, missStrip, missing_mask, norecovery_mask, m_FPGATrackSimMapping, m_idealCoordFitType);
562  // Create a template track with common parameters filled already for initializing below
563  FPGATrackSimTrack temp;
564 
565  if (roadsAreSecondStage) {
566  temp.setTrackStage(TrackStage::SECOND);
567  }
568  else {
569  temp.setTrackStage(TrackStage::FIRST);
570  }
571  temp.setSecondSectorID(road->getSector());
572  temp.setNLayers(pmap->getNLogiLayers());
573  temp.setBankID(-1); // TODO
574  temp.setPatternID(road->getPID());
575  temp.setHitMap(missing_mask);
576  temp.setNMissing(nMissing);
577  temp.setHoughX(road->getX());
578  temp.setHoughY(road->getY());
579  temp.setQOverPt(road->getY());
580  temp.setTrackCorrType(m_IdealCoordFitType);
581  temp.setDoDeltaGPhis(true);
582  temp.setPassedOR(1);
583 
584  makeTrackCandidates(*road, temp, track_cand, m_FPGATrackSimMapping);
585  for (auto const &tr : track_cand) {
586  track_cands.push_back(tr);
587  }
588  }
589 
590  ATH_CHECK(runOverlapRemoval(track_cands, minChi2, maxOverlappingHits, m_algo, m_monTool));
591  unsigned long passed = 0;
592  for (auto const &cand : track_cands) {
593  if (cand.passedOR()) {
594  passed++;
595  }
596  }
597 
598  m_NTracksORMinusRoads = passed - roads.size();
599 
600  return fillTree(track_cands, truthTracks, offlineTracks, hits_2nd, writeOutNonSPStripHits, roadsAreSecondStage);
601 }

◆ initialize()

StatusCode FPGATrackSimHoughRootOutputTool::initialize ( )
overridevirtual

Definition at line 20 of file FPGATrackSimHoughRootOutputTool.cxx.

21 {
22  ATH_CHECK(m_FPGATrackSimMapping.retrieve());
23  ATH_CHECK(m_tHistSvc.retrieve());
24  ATH_CHECK(m_EvtSel.retrieve());
25 
26  if(m_algorithm == "Normal") m_algo=ORAlgo::Normal;
27  else if(m_algorithm == "Invert") m_algo=ORAlgo::InvertGrouping;
28 
29  ATH_CHECK(bookTree());
30  return StatusCode::SUCCESS;
31 }

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

◆ ResetVectors()

void FPGATrackSimHoughRootOutputTool::ResetVectors ( )
private

Definition at line 603 of file FPGATrackSimHoughRootOutputTool.cxx.

603  {
604  m_x.clear();
605  m_y.clear();
606  m_z.clear();
607  m_volumeID.clear();
608  m_custom_layerID.clear();
609 
610  m_layerID.clear();
611  m_etaID.clear();
612 
613  m_barcode.clear();
614  m_barcodefrac.clear();
615  m_eventindex.clear();
616  m_realHit.clear();
617  m_isPixel.clear();
618  m_layer.clear();
619  m_isBarrel.clear();
620  m_etawidth.clear();
621  m_phiwidth.clear();
622  m_etamodule.clear();
623  m_phimodule.clear();
624  m_ID.clear();
625  m_diskLayer.clear();
626  m_passesOR.clear();
627  m_roadChi2.clear();
628  m_nMissingHits.clear();
629  m_truth_d0.clear();
630  m_truth_z0.clear();
631  m_truth_pt.clear();
632  m_truth_eta.clear();
633  m_truth_phi.clear();
634  m_truth_q.clear();
635  m_truth_barcode.clear();
636  m_truth_eventindex.clear();
637  m_truth_pdg.clear();
638  m_track_hit_volumeID.clear();
639  m_offline_n_holes.clear();
640  m_offline_n_measurement.clear();
641  m_offline_n_inertmaterial.clear();
642  m_offline_n_brempoint.clear();
643  m_offline_n_scatterer.clear();
644  m_offline_n_perigee.clear();
645  m_offline_n_outlier.clear();
646  m_offline_n_other.clear();
647  m_offline_d0.clear();
648  m_offline_z0.clear();
649  m_offline_pt.clear();
650  m_offline_eta.clear();
651  m_offline_phi.clear();
652  m_offline_q.clear();
653  m_offline_barcode.clear();
654  m_offline_barcodefrac.clear();
655  m_track_hit_x.clear();
656  m_track_hit_y.clear();
657  m_track_hit_z.clear();
658  m_track_hit_R.clear();
659  m_track_hit_phi.clear();
660  m_track_hit_layer_disk.clear();
661  m_track_hit_isPixel.clear();
662  m_track_hit_isStrip.clear();
663  m_track_hit_isClustered.clear();
664  m_track_hit_isSpacepoint.clear();
665  m_track_hit_barcode.clear();
666  m_track_hit_barcodefrac.clear();
667  m_track_hit_zIdeal.clear();
668  m_track_hit_gphiIdeal.clear();
669  m_track_hit_fineID.clear();
670  m_track_hit_isMapped.clear();
671 
672  m_gphi.clear();
673  m_zIdeal.clear();
674  m_gphiIdeal.clear();
675  m_has_strip_nonspacepoint.clear();
676 }

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

ORAlgo FPGATrackSimHoughRootOutputTool::m_algo {ORAlgo::Normal}
private

Definition at line 68 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_algorithm

Gaudi::Property<std::string> FPGATrackSimHoughRootOutputTool::m_algorithm { this, "ORAlgo", "Normal", "Overlap removal algorithm"}
private

Definition at line 65 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_d0

float FPGATrackSimHoughRootOutputTool::m_associated_truth_d0 = 9999
private

Definition at line 117 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_eta

float FPGATrackSimHoughRootOutputTool::m_associated_truth_eta = 9999
private

Definition at line 121 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_phi

float FPGATrackSimHoughRootOutputTool::m_associated_truth_phi = 9999
private

Definition at line 122 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_pt

float FPGATrackSimHoughRootOutputTool::m_associated_truth_pt = 9999
private

Definition at line 119 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_q

float FPGATrackSimHoughRootOutputTool::m_associated_truth_q = 9999
private

Definition at line 120 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_z0

float FPGATrackSimHoughRootOutputTool::m_associated_truth_z0 = 9999
private

Definition at line 118 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_barcode

std::vector<unsigned long> FPGATrackSimHoughRootOutputTool::m_barcode
private

Definition at line 87 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_barcodefrac

std::vector<float> FPGATrackSimHoughRootOutputTool::m_barcodefrac
private

Definition at line 86 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_candidate_barcode

float FPGATrackSimHoughRootOutputTool::m_candidate_barcode = 0.0F
private

Definition at line 114 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_candidate_barcodefrac

float FPGATrackSimHoughRootOutputTool::m_candidate_barcodefrac = 0.0F
private

Definition at line 113 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_candidate_eventindex

float FPGATrackSimHoughRootOutputTool::m_candidate_eventindex = 0.0F
private

Definition at line 115 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_custom_layerID

std::vector<int> FPGATrackSimHoughRootOutputTool::m_custom_layerID
private

Definition at line 80 of file FPGATrackSimHoughRootOutputTool.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_diskLayer

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_diskLayer
private

Definition at line 97 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_etaID

std::vector<int> FPGATrackSimHoughRootOutputTool::m_etaID
private

Definition at line 82 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_etamodule

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_etamodule
private

Definition at line 94 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_etawidth

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_etawidth
private

Definition at line 92 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_eventindex

std::vector<int> FPGATrackSimHoughRootOutputTool::m_eventindex
private

Definition at line 88 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_EvtSel

ServiceHandle<IFPGATrackSimEventSelectionSvc> FPGATrackSimHoughRootOutputTool::m_EvtSel {this, "FPGATrackSimEventSelectionSvc", "FPGATrackSimEventSelectionSvc"}
private

Definition at line 62 of file FPGATrackSimHoughRootOutputTool.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_fakelabel

unsigned int FPGATrackSimHoughRootOutputTool::m_fakelabel = 0
private

Definition at line 116 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_FPGATrackSimMapping

ServiceHandle<IFPGATrackSimMappingSvc> FPGATrackSimHoughRootOutputTool::m_FPGATrackSimMapping {this, "FPGATrackSimMappingSvc", ""}
private

Definition at line 63 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_gphi

std::vector<float> FPGATrackSimHoughRootOutputTool::m_gphi
private

Definition at line 83 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_gphiIdeal

std::vector<float> FPGATrackSimHoughRootOutputTool::m_gphiIdeal
private

Definition at line 85 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_has_strip_nonspacepoint

std::vector<bool> FPGATrackSimHoughRootOutputTool::m_has_strip_nonspacepoint
private

Definition at line 147 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_ID

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_ID
private

Definition at line 96 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_IdealCoordFitType

TrackCorrType FPGATrackSimHoughRootOutputTool::m_IdealCoordFitType = TrackCorrType::None
private

Definition at line 71 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_idealCoordFitType

TrackCorrType FPGATrackSimHoughRootOutputTool::m_idealCoordFitType = TrackCorrType::None
private

Definition at line 104 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_invpt

float FPGATrackSimHoughRootOutputTool::m_invpt = 0.0F
private

Definition at line 108 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_isBarrel

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_isBarrel
private

Definition at line 91 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_isPixel

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_isPixel
private

Definition at line 89 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_layer

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_layer
private

Definition at line 90 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_layerID

std::vector<int> FPGATrackSimHoughRootOutputTool::m_layerID
private

Definition at line 81 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_mapped

std::vector<bool> FPGATrackSimHoughRootOutputTool::m_mapped
private

Definition at line 101 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_monTool

ToolHandle<GenericMonitoringTool> FPGATrackSimHoughRootOutputTool::m_monTool {this,"MonTool", "", "Monitoring tool"}
private

Definition at line 73 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_nMissingHits

std::vector<float> FPGATrackSimHoughRootOutputTool::m_nMissingHits
private

Definition at line 100 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_NTracksORMinusRoads

long FPGATrackSimHoughRootOutputTool::m_NTracksORMinusRoads = 0
private

Definition at line 110 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_barcode

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_barcode
private

Definition at line 184 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_barcodefrac

std::vector<float> FPGATrackSimHoughRootOutputTool::m_offline_barcodefrac
private

Definition at line 185 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_d0

std::vector<float> FPGATrackSimHoughRootOutputTool::m_offline_d0
private

Definition at line 178 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_eta

std::vector<float> FPGATrackSimHoughRootOutputTool::m_offline_eta
private

Definition at line 181 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_brempoint

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_n_brempoint
private

Definition at line 172 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_holes

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_n_holes
private

Definition at line 169 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_inertmaterial

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_n_inertmaterial
private

Definition at line 171 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_measurement

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_n_measurement
private

Definition at line 170 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_other

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_n_other
private

Definition at line 176 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_outlier

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_n_outlier
private

Definition at line 175 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_perigee

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_n_perigee
private

Definition at line 174 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_scatterer

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_n_scatterer
private

Definition at line 173 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_phi

std::vector<float> FPGATrackSimHoughRootOutputTool::m_offline_phi
private

Definition at line 182 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_pt

std::vector<float> FPGATrackSimHoughRootOutputTool::m_offline_pt
private

Definition at line 180 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_q

std::vector<int> FPGATrackSimHoughRootOutputTool::m_offline_q
private

Definition at line 183 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_z0

std::vector<float> FPGATrackSimHoughRootOutputTool::m_offline_z0
private

Definition at line 179 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offlinetree

TTree* FPGATrackSimHoughRootOutputTool::m_offlinetree = nullptr
private

Definition at line 168 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_passesOR

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_passesOR
private

Definition at line 98 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_phi

float FPGATrackSimHoughRootOutputTool::m_phi = 0.0F
private

Definition at line 107 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_phimodule

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_phimodule
private

Definition at line 95 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_phiwidth

std::vector<unsigned int> FPGATrackSimHoughRootOutputTool::m_phiwidth
private

Definition at line 93 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_realHit

std::vector<bool> FPGATrackSimHoughRootOutputTool::m_realHit
private

Definition at line 102 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_region

Gaudi::Property<std::string> FPGATrackSimHoughRootOutputTool::m_region { this, "OutputRegion", "", "region ID"}
private

Definition at line 66 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_roadChi2

std::vector<float> FPGATrackSimHoughRootOutputTool::m_roadChi2
private

Definition at line 99 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_roadnumber

int FPGATrackSimHoughRootOutputTool::m_roadnumber = 0
private

Definition at line 133 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_subregion

unsigned int FPGATrackSimHoughRootOutputTool::m_subregion = 0
private

Definition at line 109 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_SUBREGIONMAP

const FPGATrackSimRegionMap* FPGATrackSimHoughRootOutputTool::m_SUBREGIONMAP {nullptr}
private

Definition at line 70 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_tHistSvc

ServiceHandle<ITHistSvc> FPGATrackSimHoughRootOutputTool::m_tHistSvc {this, "THistSvc", "THistSvc"}
private

Definition at line 64 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_barcode

std::vector<std::vector<int> > FPGATrackSimHoughRootOutputTool::m_track_hit_barcode
private

Definition at line 160 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_barcodefrac

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_barcodefrac
private

Definition at line 161 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_eta

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_eta
private

Definition at line 152 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_fineID

std::vector<std::vector<long> > FPGATrackSimHoughRootOutputTool::m_track_hit_fineID
private

Definition at line 164 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_gphiIdeal

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_gphiIdeal
private

Definition at line 163 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isClustered

std::vector<std::vector<bool> > FPGATrackSimHoughRootOutputTool::m_track_hit_isClustered
private

Definition at line 157 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isMapped

std::vector<std::vector<bool> > FPGATrackSimHoughRootOutputTool::m_track_hit_isMapped
private

Definition at line 159 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isPixel

std::vector<std::vector<bool> > FPGATrackSimHoughRootOutputTool::m_track_hit_isPixel
private

Definition at line 155 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isSpacepoint

std::vector<std::vector<bool> > FPGATrackSimHoughRootOutputTool::m_track_hit_isSpacepoint
private

Definition at line 158 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isStrip

std::vector<std::vector<bool> > FPGATrackSimHoughRootOutputTool::m_track_hit_isStrip
private

Definition at line 156 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_layer_disk

std::vector<std::vector<int> > FPGATrackSimHoughRootOutputTool::m_track_hit_layer_disk
private

Definition at line 154 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_phi

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_phi
private

Definition at line 153 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_R

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_R
private

Definition at line 151 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_volumeID

std::vector<std::vector<int> > FPGATrackSimHoughRootOutputTool::m_track_hit_volumeID
private

Definition at line 165 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_x

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_x
private

Definition at line 148 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_y

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_y
private

Definition at line 149 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_z

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_z
private

Definition at line 150 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_zIdeal

std::vector<std::vector<float> > FPGATrackSimHoughRootOutputTool::m_track_hit_zIdeal
private

Definition at line 162 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_tracknumber

int FPGATrackSimHoughRootOutputTool::m_tracknumber = 0
private

Definition at line 127 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_tree

TTree* FPGATrackSimHoughRootOutputTool::m_tree = nullptr
private

Definition at line 75 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_treeindex

int FPGATrackSimHoughRootOutputTool::m_treeindex = 0
private

Definition at line 130 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_barcode

std::vector<int> FPGATrackSimHoughRootOutputTool::m_truth_barcode
private

Definition at line 145 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_d0

std::vector<float> FPGATrackSimHoughRootOutputTool::m_truth_d0
private

Definition at line 138 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_eta

std::vector<float> FPGATrackSimHoughRootOutputTool::m_truth_eta
private

Definition at line 141 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_eventindex

std::vector<int> FPGATrackSimHoughRootOutputTool::m_truth_eventindex
private

Definition at line 146 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_pdg

std::vector<float> FPGATrackSimHoughRootOutputTool::m_truth_pdg
private

Definition at line 143 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_phi

std::vector<float> FPGATrackSimHoughRootOutputTool::m_truth_phi
private

Definition at line 142 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_pt

std::vector<float> FPGATrackSimHoughRootOutputTool::m_truth_pt
private

Definition at line 140 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_q

std::vector<int> FPGATrackSimHoughRootOutputTool::m_truth_q
private

Definition at line 144 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_z0

std::vector<float> FPGATrackSimHoughRootOutputTool::m_truth_z0
private

Definition at line 139 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truthtree

TTree* FPGATrackSimHoughRootOutputTool::m_truthtree = nullptr
private

Definition at line 136 of file FPGATrackSimHoughRootOutputTool.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_volumeID

std::vector<int> FPGATrackSimHoughRootOutputTool::m_volumeID
private

Definition at line 79 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_x

std::vector<float> FPGATrackSimHoughRootOutputTool::m_x
private

Definition at line 76 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_y

std::vector<float> FPGATrackSimHoughRootOutputTool::m_y
private

Definition at line 77 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_z

std::vector<float> FPGATrackSimHoughRootOutputTool::m_z
private

Definition at line 78 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_zIdeal

std::vector<float> FPGATrackSimHoughRootOutputTool::m_zIdeal
private

Definition at line 84 of file FPGATrackSimHoughRootOutputTool.h.

The documentation for this class was generated from the following files:
FPGATrackSimTrack::setHitMap
void setHitMap(unsigned int v)
Definition: FPGATrackSimTrack.h:101
OfflineHitType::Hole
@ Hole
FPGATrackSimHoughRootOutputTool::m_roadChi2
std::vector< float > m_roadChi2
Definition: FPGATrackSimHoughRootOutputTool.h:99
FPGATrackSimHoughRootOutputTool::m_track_hit_isClustered
std::vector< std::vector< bool > > m_track_hit_isClustered
Definition: FPGATrackSimHoughRootOutputTool.h:157
FPGATrackSimHoughRootOutputTool::m_barcodefrac
std::vector< float > m_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:86
FPGATrackSimHoughRootOutputTool::m_track_hit_isMapped
std::vector< std::vector< bool > > m_track_hit_isMapped
Definition: FPGATrackSimHoughRootOutputTool.h:159
FPGATrackSimHoughRootOutputTool::m_track_hit_y
std::vector< std::vector< float > > m_track_hit_y
Definition: FPGATrackSimHoughRootOutputTool.h:149
FPGATrackSimHoughRootOutputTool::m_truth_phi
std::vector< float > m_truth_phi
Definition: FPGATrackSimHoughRootOutputTool.h:142
FPGATrackSimHoughRootOutputTool::m_offline_z0
std::vector< float > m_offline_z0
Definition: FPGATrackSimHoughRootOutputTool.h:179
getMenu.algname
algname
Definition: getMenu.py:54
FPGATrackSimHoughRootOutputTool::m_track_hit_gphiIdeal
std::vector< std::vector< float > > m_track_hit_gphiIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:163
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSimTrack::setBankID
void setBankID(int v)
Definition: FPGATrackSimTrack.h:84
FPGATrackSimHoughRootOutputTool::m_track_hit_barcode
std::vector< std::vector< int > > m_track_hit_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:160
FPGATrackSimHoughRootOutputTool::m_associated_truth_d0
float m_associated_truth_d0
Definition: FPGATrackSimHoughRootOutputTool.h:117
FPGATrackSimHoughRootOutputTool::m_isBarrel
std::vector< unsigned int > m_isBarrel
Definition: FPGATrackSimHoughRootOutputTool.h:91
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:118
FPGATrackSimHoughRootOutputTool::m_layer
std::vector< unsigned int > m_layer
Definition: FPGATrackSimHoughRootOutputTool.h:90
FPGATrackSimRoad::getSubRegion
int getSubRegion() const
Definition: FPGATrackSimRoad.h:86
FPGATrackSimHoughRootOutputTool::m_track_hit_phi
std::vector< std::vector< float > > m_track_hit_phi
Definition: FPGATrackSimHoughRootOutputTool.h:153
OfflineHitType::InertMaterial
@ InertMaterial
FPGATrackSimTrack
Definition: FPGATrackSimTrack.h:18
FPGATrackSimHoughRootOutputTool::m_offline_phi
std::vector< float > m_offline_phi
Definition: FPGATrackSimHoughRootOutputTool.h:182
FPGATrackSimTrack::setPatternID
void setPatternID(int v)
Definition: FPGATrackSimTrack.h:85
OfflineHitType::BremPoint
@ BremPoint
FPGATrackSimMultiTruth::Weight
float Weight
Definition: FPGATrackSimMultiTruth.h:50
OfflineHitType::Measurement
@ Measurement
FPGATrackSimHoughRootOutputTool::m_track_hit_zIdeal
std::vector< std::vector< float > > m_track_hit_zIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:162
FPGATrackSimHoughRootOutputTool::m_realHit
std::vector< bool > m_realHit
Definition: FPGATrackSimHoughRootOutputTool.h:102
FPGATrackSimHoughRootOutputTool::m_x
std::vector< float > m_x
Definition: FPGATrackSimHoughRootOutputTool.h:76
FPGATrackSimHoughRootOutputTool::m_offlinetree
TTree * m_offlinetree
Definition: FPGATrackSimHoughRootOutputTool.h:168
FPGATrackSimTrack::setNMissing
void setNMissing(int v)
Definition: FPGATrackSimTrack.h:99
ORAlgo::Normal
@ Normal
FPGATrackSimHoughRootOutputTool::m_offline_n_brempoint
std::vector< int > m_offline_n_brempoint
Definition: FPGATrackSimHoughRootOutputTool.h:172
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
FPGATrackSimTrack::setPassedOR
void setPassedOR(unsigned int)
Definition: FPGATrackSimTrack.cxx:259
FPGATrackSimTrack::getRegion
int getRegion() const
Definition: FPGATrackSimTrack.h:48
FPGATrackSimHoughRootOutputTool::m_gphiIdeal
std::vector< float > m_gphiIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:85
FPGATrackSimHoughRootOutputTool::m_diskLayer
std::vector< unsigned int > m_diskLayer
Definition: FPGATrackSimHoughRootOutputTool.h:97
FPGATrackSimHoughRootOutputTool::m_etawidth
std::vector< unsigned int > m_etawidth
Definition: FPGATrackSimHoughRootOutputTool.h:92
HitType::spacepoint
@ spacepoint
FPGATrackSimHoughRootOutputTool::m_treeindex
int m_treeindex
Definition: FPGATrackSimHoughRootOutputTool.h:130
FPGATrackSimHoughRootOutputTool::m_track_hit_R
std::vector< std::vector< float > > m_track_hit_R
Definition: FPGATrackSimHoughRootOutputTool.h:151
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
FPGATrackSimHoughRootOutputTool::m_track_hit_layer_disk
std::vector< std::vector< int > > m_track_hit_layer_disk
Definition: FPGATrackSimHoughRootOutputTool.h:154
FPGATrackSimTrack::getSubRegion
int getSubRegion() const
Definition: FPGATrackSimTrack.h:47
FPGATrackSimTrack::passedOR
unsigned int passedOR() const
Definition: FPGATrackSimTrack.h:139
FPGATrackSimTrack::getHoughY
float getHoughY() const
Definition: FPGATrackSimTrack.h:35
FPGATrackSimHoughRootOutputTool::m_has_strip_nonspacepoint
std::vector< bool > m_has_strip_nonspacepoint
Definition: FPGATrackSimHoughRootOutputTool.h:147
FPGATrackSimRoad::getNHits_layer
std::vector< size_t > getNHits_layer() const
Definition: FPGATrackSimRoad.cxx:27
FPGATrackSimHoughRootOutputTool::m_isPixel
std::vector< unsigned int > m_isPixel
Definition: FPGATrackSimHoughRootOutputTool.h:89
FPGATrackSimRoad::getX
float getX() const
Definition: FPGATrackSimRoad.h:89
std::sort
void sort(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:554
FPGATrackSimHoughRootOutputTool::m_phi
float m_phi
Definition: FPGATrackSimHoughRootOutputTool.h:107
FPGATrackSimMultiTruth::best
bool best(FPGATrackSimMultiTruth::Barcode &code, FPGATrackSimMultiTruth::Weight &weight) const
Definition: FPGATrackSimMultiTruth.h:86
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
FPGATrackSimHit
Definition: FPGATrackSimHit.h:41
FPGATrackSimTrack::setSecondSectorID
void setSecondSectorID(int v)
Definition: FPGATrackSimTrack.h:87
FPGATrackSimHoughRootOutputTool::m_passesOR
std::vector< unsigned int > m_passesOR
Definition: FPGATrackSimHoughRootOutputTool.h:98
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
FPGATrackSimTrack::getFPGATrackSimHits
const std::vector< FPGATrackSimHit > & getFPGATrackSimHits() const
Definition: FPGATrackSimTrack.h:63
computeIdealCoords
std::vector< float > computeIdealCoords(const FPGATrackSimHit &hit, const double hough_x, const double hough_y, const double target_r, const bool doDeltaGPhis, const TrackCorrType trackCorrType)
Definition: FPGATrackSimFunctions.cxx:116
FPGATrackSimHoughRootOutputTool::m_offline_n_outlier
std::vector< int > m_offline_n_outlier
Definition: FPGATrackSimHoughRootOutputTool.h:175
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
FPGATrackSimHoughRootOutputTool::m_idealCoordFitType
TrackCorrType m_idealCoordFitType
Definition: FPGATrackSimHoughRootOutputTool.h:104
OfflineHitType::Perigee
@ Perigee
FPGATrackSimHoughRootOutputTool::m_subregion
unsigned int m_subregion
Definition: FPGATrackSimHoughRootOutputTool.h:109
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
FPGATrackSimHoughRootOutputTool::m_phiwidth
std::vector< unsigned int > m_phiwidth
Definition: FPGATrackSimHoughRootOutputTool.h:93
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
FPGATrackSimHoughRootOutputTool::m_track_hit_fineID
std::vector< std::vector< long > > m_track_hit_fineID
Definition: FPGATrackSimHoughRootOutputTool.h:164
lumiFormat.i
int i
Definition: lumiFormat.py:85
FPGATrackSimHoughRootOutputTool::m_region
Gaudi::Property< std::string > m_region
Definition: FPGATrackSimHoughRootOutputTool.h:66
FPGATrackSimHoughRootOutputTool::m_truth_z0
std::vector< float > m_truth_z0
Definition: FPGATrackSimHoughRootOutputTool.h:139
FPGATrackSimHoughRootOutputTool::m_offline_d0
std::vector< float > m_offline_d0
Definition: FPGATrackSimHoughRootOutputTool.h:178
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
FPGATrackSimHoughRootOutputTool::m_offline_eta
std::vector< float > m_offline_eta
Definition: FPGATrackSimHoughRootOutputTool.h:181
getFineID
long getFineID(const FPGATrackSimHit &hit)
Definition: FPGATrackSimHoughFunctions.cxx:624
TrackStage::FIRST
@ FIRST
FPGATrackSimTrack::setDoDeltaGPhis
void setDoDeltaGPhis(bool v)
Definition: FPGATrackSimTrack.h:83
FPGATrackSimMultiTruth::Barcode
std::pair< unsigned long, unsigned long > Barcode
Definition: FPGATrackSimMultiTruth.h:49
FPGATrackSimHoughRootOutputTool::m_z
std::vector< float > m_z
Definition: FPGATrackSimHoughRootOutputTool.h:78
FPGATrackSimHoughRootOutputTool::m_offline_n_measurement
std::vector< int > m_offline_n_measurement
Definition: FPGATrackSimHoughRootOutputTool.h:170
FPGATrackSimHoughRootOutputTool::m_candidate_eventindex
float m_candidate_eventindex
Definition: FPGATrackSimHoughRootOutputTool.h:115
FPGATrackSimHoughRootOutputTool::m_candidate_barcodefrac
float m_candidate_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:113
FPGATrackSimHoughRootOutputTool::m_track_hit_z
std::vector< std::vector< float > > m_track_hit_z
Definition: FPGATrackSimHoughRootOutputTool.h:150
FPGATrackSimHoughRootOutputTool::m_invpt
float m_invpt
Definition: FPGATrackSimHoughRootOutputTool.h:108
FPGATrackSimHoughRootOutputTool::m_SUBREGIONMAP
const FPGATrackSimRegionMap * m_SUBREGIONMAP
Definition: FPGATrackSimHoughRootOutputTool.h:70
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimHoughRootOutputTool::m_truth_eventindex
std::vector< int > m_truth_eventindex
Definition: FPGATrackSimHoughRootOutputTool.h:146
TrackStage::SECOND
@ SECOND
FPGATrackSimHoughRootOutputTool::m_truthtree
TTree * m_truthtree
Definition: FPGATrackSimHoughRootOutputTool.h:136
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
FPGATrackSimHoughRootOutputTool::m_offline_q
std::vector< int > m_offline_q
Definition: FPGATrackSimHoughRootOutputTool.h:183
FPGATrackSimHoughRootOutputTool::m_associated_truth_q
float m_associated_truth_q
Definition: FPGATrackSimHoughRootOutputTool.h:120
FPGATrackSimHoughRootOutputTool::ResetVectors
void ResetVectors()
Definition: FPGATrackSimHoughRootOutputTool.cxx:603
FPGATrackSimTrack::setTrackCorrType
void setTrackCorrType(TrackCorrType v)
Definition: FPGATrackSimTrack.h:81
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
FPGATrackSimHoughRootOutputTool::m_truth_d0
std::vector< float > m_truth_d0
Definition: FPGATrackSimHoughRootOutputTool.h:138
FPGATrackSimHoughRootOutputTool::m_gphi
std::vector< float > m_gphi
Definition: FPGATrackSimHoughRootOutputTool.h:83
getComboIndices
std::vector< std::vector< int > > getComboIndices(std::vector< size_t > const &sizes)
Given a vector of sizes (of arrays), generates a vector of all combinations of indices to index one e...
Definition: FPGATrackSimFunctions.cxx:21
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
FPGATrackSimHoughRootOutputTool::m_etamodule
std::vector< unsigned int > m_etamodule
Definition: FPGATrackSimHoughRootOutputTool.h:94
FPGATrackSimHoughRootOutputTool::m_truth_pdg
std::vector< float > m_truth_pdg
Definition: FPGATrackSimHoughRootOutputTool.h:143
FPGATrackSimHoughRootOutputTool::m_offline_n_perigee
std::vector< int > m_offline_n_perigee
Definition: FPGATrackSimHoughRootOutputTool.h:174
FPGATrackSimTrack::setTrackStage
void setTrackStage(TrackStage v)
Definition: FPGATrackSimTrack.h:82
FPGATrackSimMultiTruth
Definition: FPGATrackSimMultiTruth.h:46
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
FPGATrackSimHoughRootOutputTool::m_FPGATrackSimMapping
ServiceHandle< IFPGATrackSimMappingSvc > m_FPGATrackSimMapping
Definition: FPGATrackSimHoughRootOutputTool.h:63
FPGATrackSimMultiTruth::AddAccumulator
Definition: FPGATrackSimMultiTruth.h:57
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
FPGATrackSimHoughRootOutputTool::m_nMissingHits
std::vector< float > m_nMissingHits
Definition: FPGATrackSimHoughRootOutputTool.h:100
FPGATrackSimHoughRootOutputTool::m_volumeID
std::vector< int > m_volumeID
Definition: FPGATrackSimHoughRootOutputTool.h:79
TrackCorrType::None
@ None
FPGATrackSimHoughRootOutputTool::m_track_hit_isSpacepoint
std::vector< std::vector< bool > > m_track_hit_isSpacepoint
Definition: FPGATrackSimHoughRootOutputTool.h:158
FPGATrackSimTrack::setHoughY
void setHoughY(float v)
Definition: FPGATrackSimTrack.h:91
FPGATrackSimHoughRootOutputTool::m_truth_eta
std::vector< float > m_truth_eta
Definition: FPGATrackSimHoughRootOutputTool.h:141
FPGATrackSimTrack::setQOverPt
void setQOverPt(float v)
Definition: FPGATrackSimTrack.h:92
FPGATrackSimHoughRootOutputTool::fillTree
StatusCode fillTree(const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, const std::vector< FPGATrackSimTruthTrack > &truthTracks, const std::vector< FPGATrackSimOfflineTrack > &offlineTracks, const std::vector< std::shared_ptr< const FPGATrackSimHit >> &hits_2nd, const bool writeOutNonSPStripHits, const float minChi2, const int maxOverlappingHits, const bool roadsAreSecondStage)
Definition: FPGATrackSimHoughRootOutputTool.cxx:531
FPGATrackSimHoughRootOutputTool::m_truth_q
std::vector< int > m_truth_q
Definition: FPGATrackSimHoughRootOutputTool.h:144
FPGATrackSimHoughRootOutputTool::m_offline_n_inertmaterial
std::vector< int > m_offline_n_inertmaterial
Definition: FPGATrackSimHoughRootOutputTool.h:171
FPGATrackSimRoad::getY
float getY() const
Definition: FPGATrackSimRoad.h:90
FPGATrackSimHoughRootOutputTool::m_algo
ORAlgo m_algo
Definition: FPGATrackSimHoughRootOutputTool.h:68
FPGATrackSimHoughRootOutputTool::m_tHistSvc
ServiceHandle< ITHistSvc > m_tHistSvc
Definition: FPGATrackSimHoughRootOutputTool.h:64
FPGATrackSimHoughRootOutputTool::m_EvtSel
ServiceHandle< IFPGATrackSimEventSelectionSvc > m_EvtSel
Definition: FPGATrackSimHoughRootOutputTool.h:62
FPGATrackSimHoughRootOutputTool::m_roadnumber
int m_roadnumber
Definition: FPGATrackSimHoughRootOutputTool.h:133
ORAlgo::InvertGrouping
@ InvertGrouping
FPGATrackSimHoughRootOutputTool::m_barcode
std::vector< unsigned long > m_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:87
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:107
FPGATrackSimHoughRootOutputTool::m_track_hit_x
std::vector< std::vector< float > > m_track_hit_x
Definition: FPGATrackSimHoughRootOutputTool.h:148
getVolumeID
long getVolumeID(const FPGATrackSimHit &hit)
Definition: FPGATrackSimHoughFunctions.cxx:532
a
TList * a
Definition: liststreamerinfos.cxx:10
h
FPGATrackSimHoughRootOutputTool::m_algorithm
Gaudi::Property< std::string > m_algorithm
Definition: FPGATrackSimHoughRootOutputTool.h:65
runOverlapRemoval
StatusCode runOverlapRemoval(std::vector< FPGATrackSimTrack > &tracks, const float minChi2, const int NumOfHitPerGrouping, ORAlgo orAlgo, ToolHandle< GenericMonitoringTool > &monTool, bool compareAllHits=false)
Definition: FPGATrackSimHoughFunctions.cxx:15
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
FPGATrackSimHoughRootOutputTool::m_associated_truth_z0
float m_associated_truth_z0
Definition: FPGATrackSimHoughRootOutputTool.h:118
FPGATrackSimHoughRootOutputTool::m_offline_barcode
std::vector< int > m_offline_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:184
makeTrackCandidates
void makeTrackCandidates(const FPGATrackSimRoad &road, const FPGATrackSimTrack &temp, std::vector< FPGATrackSimTrack > &track_cands, const ServiceHandle< IFPGATrackSimMappingSvc > &FPGATrackSimMapping)
Creates a list of track candidates by taking all possible combination of hits in road.
Definition: FPGATrackSimHoughFunctions.cxx:463
FPGATrackSimHoughRootOutputTool::m_offline_n_scatterer
std::vector< int > m_offline_n_scatterer
Definition: FPGATrackSimHoughRootOutputTool.h:173
FPGATrackSimHoughRootOutputTool::m_layerID
std::vector< int > m_layerID
Definition: FPGATrackSimHoughRootOutputTool.h:81
FPGATrackSimHoughRootOutputTool::m_fakelabel
unsigned int m_fakelabel
Definition: FPGATrackSimHoughRootOutputTool.h:116
layer_bitmask_t
uint32_t layer_bitmask_t
Definition: FPGATrackSimTypes.h:22
FPGATrackSimHoughRootOutputTool::m_eventindex
std::vector< int > m_eventindex
Definition: FPGATrackSimHoughRootOutputTool.h:88
FPGATrackSimHoughRootOutputTool::m_candidate_barcode
float m_candidate_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:114
FPGATrackSimHoughRootOutputTool::m_associated_truth_pt
float m_associated_truth_pt
Definition: FPGATrackSimHoughRootOutputTool.h:119
FPGATrackSimHoughRootOutputTool::m_offline_n_other
std::vector< int > m_offline_n_other
Definition: FPGATrackSimHoughRootOutputTool.h:176
FPGATrackSimHoughRootOutputTool::m_offline_n_holes
std::vector< int > m_offline_n_holes
Definition: FPGATrackSimHoughRootOutputTool.h:169
FPGATrackSimHoughRootOutputTool::m_associated_truth_eta
float m_associated_truth_eta
Definition: FPGATrackSimHoughRootOutputTool.h:121
FPGATrackSimHoughRootOutputTool::m_offline_pt
std::vector< float > m_offline_pt
Definition: FPGATrackSimHoughRootOutputTool.h:180
FPGATrackSimHoughRootOutputTool::m_tracknumber
int m_tracknumber
Definition: FPGATrackSimHoughRootOutputTool.h:127
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
FPGATrackSimHoughRootOutputTool::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: FPGATrackSimHoughRootOutputTool.h:73
FPGATrackSimHoughRootOutputTool::m_track_hit_barcodefrac
std::vector< std::vector< float > > m_track_hit_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:161
FPGATrackSimRoad::getSector
sector_t getSector() const
Definition: FPGATrackSimRoad.h:94
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
FPGATrackSimHoughRootOutputTool::m_NTracksORMinusRoads
long m_NTracksORMinusRoads
Definition: FPGATrackSimHoughRootOutputTool.h:110
FPGATrackSimRoad::getPID
pid_t getPID() const
Definition: FPGATrackSimRoad.h:93
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
FPGATrackSimHoughRootOutputTool::m_etaID
std::vector< int > m_etaID
Definition: FPGATrackSimHoughRootOutputTool.h:82
FPGATrackSimHoughRootOutputTool::m_offline_barcodefrac
std::vector< float > m_offline_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:185
FPGATrackSimHoughRootOutputTool::m_phimodule
std::vector< unsigned int > m_phimodule
Definition: FPGATrackSimHoughRootOutputTool.h:95
OfflineHitType::Scatterer
@ Scatterer
FPGATrackSimTrack::setNLayers
void setNLayers(int)
set the number of layers in the track.
Definition: FPGATrackSimTrack.cxx:107
FPGATrackSimHoughRootOutputTool::m_IdealCoordFitType
TrackCorrType m_IdealCoordFitType
Definition: FPGATrackSimHoughRootOutputTool.h:71
FPGATrackSimHoughRootOutputTool::m_ID
std::vector< unsigned int > m_ID
Definition: FPGATrackSimHoughRootOutputTool.h:96
FPGATrackSimHoughRootOutputTool::m_track_hit_isStrip
std::vector< std::vector< bool > > m_track_hit_isStrip
Definition: FPGATrackSimHoughRootOutputTool.h:156
FPGATrackSimHoughRootOutputTool::m_truth_barcode
std::vector< int > m_truth_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:145
FPGATrackSimTrack::getHoughX
float getHoughX() const
Definition: FPGATrackSimTrack.h:34
OfflineHitType::Outlier
@ Outlier
FPGATrackSimHoughRootOutputTool::m_track_hit_isPixel
std::vector< std::vector< bool > > m_track_hit_isPixel
Definition: FPGATrackSimHoughRootOutputTool.h:155
FPGATrackSimHoughRootOutputTool::m_y
std::vector< float > m_y
Definition: FPGATrackSimHoughRootOutputTool.h:77
FPGATrackSimHoughRootOutputTool::m_tree
TTree * m_tree
Definition: FPGATrackSimHoughRootOutputTool.h:75
getMissingInfo
void getMissingInfo(const FPGATrackSimRoad &road, int &nMissing, bool &missPixel, bool &missStrip, layer_bitmask_t &missing_mask, layer_bitmask_t &norecovery_mask, const ServiceHandle< IFPGATrackSimMappingSvc > &FPGATrackSimMapping, const TrackCorrType idealCoordFitType)
Definition: FPGATrackSimHoughFunctions.cxx:401
FPGATrackSimHoughRootOutputTool::m_truth_pt
std::vector< float > m_truth_pt
Definition: FPGATrackSimHoughRootOutputTool.h:140
FPGATrackSimHoughRootOutputTool::m_custom_layerID
std::vector< int > m_custom_layerID
Definition: FPGATrackSimHoughRootOutputTool.h:80
FPGATrackSimHoughRootOutputTool::m_associated_truth_phi
float m_associated_truth_phi
Definition: FPGATrackSimHoughRootOutputTool.h:122
FPGATrackSimTrack::setHoughX
void setHoughX(float v)
Definition: FPGATrackSimTrack.h:90
fitman.k
k
Definition: fitman.py:528
FPGATrackSimHoughRootOutputTool::m_track_hit_volumeID
std::vector< std::vector< int > > m_track_hit_volumeID
Definition: FPGATrackSimHoughRootOutputTool.h:165
FPGATrackSimRegionMap::getAvgRadius
double getAvgRadius(unsigned region, unsigned layer) const
Definition: FPGATrackSimRegionMap.cxx:396
FPGATrackSimHoughRootOutputTool::bookTree
StatusCode bookTree()
Definition: FPGATrackSimHoughRootOutputTool.cxx:35
FPGATrackSimMultiTruth::assign_equal_normalization
void assign_equal_normalization()
Definition: FPGATrackSimMultiTruth.cxx:69
FPGATrackSimHoughRootOutputTool::m_zIdeal
std::vector< float > m_zIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:84
Generated on Mon Sep 29 2025 21:35:00 for ATLAS Offline Software by   doxygen 1.8.18