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_roadChi2ndof
 
std::vector< float > m_roadNCoords
 
std::vector< float > m_nMissingHits
 
std::vector< bool > m_mapped
 
std::vector< bool > m_realHit
 
std::vector< bool > m_isSP
 
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("isSP",&m_isSP);
69  m_tree->Branch("layer",&m_layer);
70  m_tree->Branch("isBarrel",&m_isBarrel);
71  m_tree->Branch("etawidth",&m_etawidth);
72  m_tree->Branch("phiwidth",&m_phiwidth);
73  m_tree->Branch("etamodule",&m_etamodule);
74  m_tree->Branch("phimodule",&m_phimodule);
75  m_tree->Branch("ID",&m_ID);
76  m_tree->Branch("diskLayer",&m_diskLayer);
77 
78  m_tree->Branch("candidate_barcodefrac",&m_candidate_barcodefrac);
79  m_tree->Branch("candidate_barcode",&m_candidate_barcode);
80  m_tree->Branch("candidate_eventindex",&m_candidate_eventindex);
81  m_tree->Branch("treeindex",&m_treeindex);
82  m_tree->Branch("subregion",&m_subregion);
83  m_tree->Branch("fakelabel",&m_fakelabel);
84  m_tree->Branch("passesOR",&m_passesOR);
85  m_tree->Branch("roadChi2",&m_roadChi2);
86  m_tree->Branch("roadChi2ndof",&m_roadChi2ndof);
87  m_tree->Branch("roadNCoords",&m_roadNCoords);
88  m_tree->Branch("nMissingHits",&m_nMissingHits);
89  m_tree->Branch("NTracksORMinusRoads",&m_NTracksORMinusRoads);
90 
91  m_treeindex = 0;
92 
93  std::string truthtree_str = "FPGATrackSimTruthTree_reg" + m_region.value();
94  m_truthtree = new TTree(truthtree_str.c_str(), truthtree_str.c_str());
95 
96  m_truthtree->Branch("truth_d0",&m_truth_d0);
97  m_truthtree->Branch("truth_z0",&m_truth_z0);
98  m_truthtree->Branch("truth_pt",&m_truth_pt);
99  m_truthtree->Branch("truth_eta",&m_truth_eta);
100  m_truthtree->Branch("truth_phi",&m_truth_phi);
101  m_truthtree->Branch("truth_q",&m_truth_q);
102  m_truthtree->Branch("truth_pdg",&m_truth_pdg);
103  m_truthtree->Branch("truth_barcode",&m_truth_barcode);
104  m_truthtree->Branch("truth_eventindex",&m_truth_eventindex);
105  m_truthtree->Branch("truth_track_hit_x",&m_track_hit_x);
106  m_truthtree->Branch("truth_track_hit_y",&m_track_hit_y);
107  m_truthtree->Branch("truth_track_hit_z",&m_track_hit_z);
108  m_truthtree->Branch("truth_track_hit_R",&m_track_hit_R);
109  m_truthtree->Branch("truth_track_hit_phi",&m_track_hit_phi);
110  m_truthtree->Branch("truth_track_hit_layer_disk",&m_track_hit_layer_disk);
111  m_truthtree->Branch("has_strip_nonspacepoint",&m_has_strip_nonspacepoint);
112  m_truthtree->Branch("truth_track_hit_isPixel", &m_track_hit_isPixel);
113  m_truthtree->Branch("truth_track_hit_isStrip", &m_track_hit_isStrip);
114  m_truthtree->Branch("truth_track_hit_isClustered", &m_track_hit_isClustered);
115  m_truthtree->Branch("truth_track_hit_isSpacepoint", &m_track_hit_isSpacepoint);
116  m_truthtree->Branch("truth_track_hit_barcode", &m_track_hit_barcode);
117  m_truthtree->Branch("truth_track_hit_barcodefrac", &m_track_hit_barcodefrac);
118  m_truthtree->Branch("truth_track_hit_zIdeal", &m_track_hit_zIdeal);
119  m_truthtree->Branch("truth_track_hit_gphiIdeal", &m_track_hit_gphiIdeal);
120  m_truthtree->Branch("truth_track_hit_fineID", &m_track_hit_fineID);
121  m_truthtree->Branch("truth_track_hit_volumeID", &m_track_hit_volumeID);
122  m_truthtree->Branch("truth_track_hit_isMapped", &m_track_hit_isMapped);
123 
124  std::string offltree_str = "FPGATrackSimOfflineTree_reg" + m_region.value();
125  m_offlinetree = new TTree(offltree_str.c_str(), offltree_str.c_str());
126 
127  m_offlinetree->Branch("offline_d0",&m_offline_d0);
128  m_offlinetree->Branch("offline_z0",&m_offline_z0);
129  m_offlinetree->Branch("offline_pt",&m_offline_pt);
130  m_offlinetree->Branch("offline_eta",&m_offline_eta);
131  m_offlinetree->Branch("offline_phi",&m_offline_phi);
132  m_offlinetree->Branch("offline_q",&m_offline_q);
133  m_offlinetree->Branch("offline_barcode",&m_offline_barcode);
134  m_offlinetree->Branch("offline_barcodefrac",&m_offline_barcodefrac);
135  m_offlinetree->Branch("offline_n_holes",&m_offline_n_holes);
136  m_offlinetree->Branch("offline_n_inertmaterial",&m_offline_n_inertmaterial);
137  m_offlinetree->Branch("offline_n_measurement",&m_offline_n_measurement);
138  m_offlinetree->Branch("offline_n_brempoint",&m_offline_n_brempoint);
139  m_offlinetree->Branch("offline_n_scatterer",&m_offline_n_scatterer);
140  m_offlinetree->Branch("offline_n_perigee",&m_offline_n_perigee);
141  m_offlinetree->Branch("offline_n_outlier",&m_offline_n_outlier);
142  m_offlinetree->Branch("offline_n_other",&m_offline_n_other);
143 
144  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_tree->GetName()), m_tree));
145  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_truthtree->GetName()), m_truthtree));
146  ATH_CHECK(m_tHistSvc->regTree(Form("/TRIGFPGATrackSimHOUGHOUTPUT/%s",m_offlinetree->GetName()), m_offlinetree));
147 
148  return StatusCode::SUCCESS;
149 }

◆ 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 152 of file FPGATrackSimHoughRootOutputTool.cxx.

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

◆ 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 542 of file FPGATrackSimHoughRootOutputTool.cxx.

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

◆ 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 614 of file FPGATrackSimHoughRootOutputTool.cxx.

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

◆ 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 120 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_eta

float FPGATrackSimHoughRootOutputTool::m_associated_truth_eta = 9999
private

Definition at line 124 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_phi

float FPGATrackSimHoughRootOutputTool::m_associated_truth_phi = 9999
private

Definition at line 125 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_pt

float FPGATrackSimHoughRootOutputTool::m_associated_truth_pt = 9999
private

Definition at line 122 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_q

float FPGATrackSimHoughRootOutputTool::m_associated_truth_q = 9999
private

Definition at line 123 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_associated_truth_z0

float FPGATrackSimHoughRootOutputTool::m_associated_truth_z0 = 9999
private

Definition at line 121 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 117 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_candidate_barcodefrac

float FPGATrackSimHoughRootOutputTool::m_candidate_barcodefrac = 0.0F
private

Definition at line 116 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_candidate_eventindex

float FPGATrackSimHoughRootOutputTool::m_candidate_eventindex = 0.0F
private

Definition at line 118 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 119 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 150 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 107 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_invpt

float FPGATrackSimHoughRootOutputTool::m_invpt = 0.0F
private

Definition at line 111 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_isSP

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

Definition at line 105 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 103 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 102 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_NTracksORMinusRoads

long FPGATrackSimHoughRootOutputTool::m_NTracksORMinusRoads = 0
private

Definition at line 113 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_barcode

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

Definition at line 187 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_barcodefrac

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

Definition at line 188 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_d0

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

Definition at line 181 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_eta

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

Definition at line 184 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_brempoint

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

Definition at line 175 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_holes

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

Definition at line 172 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_inertmaterial

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

Definition at line 174 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_measurement

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

Definition at line 173 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_other

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

Definition at line 179 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_outlier

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

Definition at line 178 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_perigee

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

Definition at line 177 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_n_scatterer

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

Definition at line 176 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_phi

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

Definition at line 185 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_pt

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

Definition at line 183 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_q

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

Definition at line 186 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offline_z0

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

Definition at line 182 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_offlinetree

TTree* FPGATrackSimHoughRootOutputTool::m_offlinetree = nullptr
private

Definition at line 171 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 110 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 104 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_roadChi2ndof

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

Definition at line 100 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_roadNCoords

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

Definition at line 101 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_roadnumber

int FPGATrackSimHoughRootOutputTool::m_roadnumber = 0
private

Definition at line 136 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_subregion

unsigned int FPGATrackSimHoughRootOutputTool::m_subregion = 0
private

Definition at line 112 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 163 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_barcodefrac

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

Definition at line 164 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_eta

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

Definition at line 155 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_fineID

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

Definition at line 167 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_gphiIdeal

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

Definition at line 166 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isClustered

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

Definition at line 160 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isMapped

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

Definition at line 162 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isPixel

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

Definition at line 158 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isSpacepoint

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

Definition at line 161 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_isStrip

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

Definition at line 159 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_layer_disk

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

Definition at line 157 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_phi

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

Definition at line 156 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_R

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

Definition at line 154 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_volumeID

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

Definition at line 168 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_x

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

Definition at line 151 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_y

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

Definition at line 152 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_z

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

Definition at line 153 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_track_hit_zIdeal

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

Definition at line 165 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_tracknumber

int FPGATrackSimHoughRootOutputTool::m_tracknumber = 0
private

Definition at line 130 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 133 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_barcode

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

Definition at line 148 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_d0

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

Definition at line 141 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_eta

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

Definition at line 144 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_eventindex

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

Definition at line 149 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_pdg

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

Definition at line 146 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_phi

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

Definition at line 145 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_pt

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

Definition at line 143 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_q

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

Definition at line 147 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truth_z0

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

Definition at line 142 of file FPGATrackSimHoughRootOutputTool.h.

◆ m_truthtree

TTree* FPGATrackSimHoughRootOutputTool::m_truthtree = nullptr
private

Definition at line 139 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:105
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:160
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:162
FPGATrackSimHoughRootOutputTool::m_track_hit_y
std::vector< std::vector< float > > m_track_hit_y
Definition: FPGATrackSimHoughRootOutputTool.h:152
FPGATrackSimHoughRootOutputTool::m_truth_phi
std::vector< float > m_truth_phi
Definition: FPGATrackSimHoughRootOutputTool.h:145
FPGATrackSimHoughRootOutputTool::m_offline_z0
std::vector< float > m_offline_z0
Definition: FPGATrackSimHoughRootOutputTool.h:182
getMenu.algname
algname
Definition: getMenu.py:54
FPGATrackSimHoughRootOutputTool::m_track_hit_gphiIdeal
std::vector< std::vector< float > > m_track_hit_gphiIdeal
Definition: FPGATrackSimHoughRootOutputTool.h:166
TRTCalib_Extractor.hits
hits
Definition: TRTCalib_Extractor.py:35
FPGATrackSimTrack::setBankID
void setBankID(int v)
Definition: FPGATrackSimTrack.h:86
FPGATrackSimHoughRootOutputTool::m_track_hit_barcode
std::vector< std::vector< int > > m_track_hit_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:163
FPGATrackSimHoughRootOutputTool::m_associated_truth_d0
float m_associated_truth_d0
Definition: FPGATrackSimHoughRootOutputTool.h:120
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:87
FPGATrackSimHoughRootOutputTool::m_track_hit_phi
std::vector< std::vector< float > > m_track_hit_phi
Definition: FPGATrackSimHoughRootOutputTool.h:156
OfflineHitType::InertMaterial
@ InertMaterial
FPGATrackSimTrack
Definition: FPGATrackSimTrack.h:18
FPGATrackSimHoughRootOutputTool::m_offline_phi
std::vector< float > m_offline_phi
Definition: FPGATrackSimHoughRootOutputTool.h:185
FPGATrackSimTrack::setPatternID
void setPatternID(int v)
Definition: FPGATrackSimTrack.h:87
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:165
runITkAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runITkAlign.py:62
FPGATrackSimHoughRootOutputTool::m_realHit
std::vector< bool > m_realHit
Definition: FPGATrackSimHoughRootOutputTool.h:104
FPGATrackSimHoughRootOutputTool::m_x
std::vector< float > m_x
Definition: FPGATrackSimHoughRootOutputTool.h:76
FPGATrackSimHoughRootOutputTool::m_offlinetree
TTree * m_offlinetree
Definition: FPGATrackSimHoughRootOutputTool.h:171
FPGATrackSimTrack::setNMissing
void setNMissing(int v)
Definition: FPGATrackSimTrack.h:103
ORAlgo::Normal
@ Normal
FPGATrackSimHoughRootOutputTool::m_offline_n_brempoint
std::vector< int > m_offline_n_brempoint
Definition: FPGATrackSimHoughRootOutputTool.h:175
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:50
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_roadChi2ndof
std::vector< float > m_roadChi2ndof
Definition: FPGATrackSimHoughRootOutputTool.h:100
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:133
FPGATrackSimHoughRootOutputTool::m_track_hit_R
std::vector< std::vector< float > > m_track_hit_R
Definition: FPGATrackSimHoughRootOutputTool.h:154
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:157
FPGATrackSimTrack::getSubRegion
int getSubRegion() const
Definition: FPGATrackSimTrack.h:49
FPGATrackSimTrack::passedOR
unsigned int passedOR() const
Definition: FPGATrackSimTrack.h:147
FPGATrackSimTrack::getHoughY
float getHoughY() const
Definition: FPGATrackSimTrack.h:35
FPGATrackSimHoughRootOutputTool::m_has_strip_nonspacepoint
std::vector< bool > m_has_strip_nonspacepoint
Definition: FPGATrackSimHoughRootOutputTool.h:150
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:90
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:110
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:42
FPGATrackSimTrack::setSecondSectorID
void setSecondSectorID(int v)
Definition: FPGATrackSimTrack.h:89
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:65
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:178
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:107
OfflineHitType::Perigee
@ Perigee
FPGATrackSimHoughRootOutputTool::m_subregion
unsigned int m_subregion
Definition: FPGATrackSimHoughRootOutputTool.h:112
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:167
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:142
FPGATrackSimHoughRootOutputTool::m_offline_d0
std::vector< float > m_offline_d0
Definition: FPGATrackSimHoughRootOutputTool.h:181
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:184
getFineID
long getFineID(const FPGATrackSimHit &hit)
Definition: FPGATrackSimHoughFunctions.cxx:624
TrackStage::FIRST
@ FIRST
FPGATrackSimTrack::setDoDeltaGPhis
void setDoDeltaGPhis(bool v)
Definition: FPGATrackSimTrack.h:85
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:173
FPGATrackSimHoughRootOutputTool::m_candidate_eventindex
float m_candidate_eventindex
Definition: FPGATrackSimHoughRootOutputTool.h:118
FPGATrackSimHoughRootOutputTool::m_candidate_barcodefrac
float m_candidate_barcodefrac
Definition: FPGATrackSimHoughRootOutputTool.h:116
FPGATrackSimHoughRootOutputTool::m_track_hit_z
std::vector< std::vector< float > > m_track_hit_z
Definition: FPGATrackSimHoughRootOutputTool.h:153
FPGATrackSimHoughRootOutputTool::m_invpt
float m_invpt
Definition: FPGATrackSimHoughRootOutputTool.h:111
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:149
TrackStage::SECOND
@ SECOND
FPGATrackSimHoughRootOutputTool::m_truthtree
TTree * m_truthtree
Definition: FPGATrackSimHoughRootOutputTool.h:139
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:186
FPGATrackSimHoughRootOutputTool::m_associated_truth_q
float m_associated_truth_q
Definition: FPGATrackSimHoughRootOutputTool.h:123
FPGATrackSimHoughRootOutputTool::ResetVectors
void ResetVectors()
Definition: FPGATrackSimHoughRootOutputTool.cxx:614
FPGATrackSimTrack::setTrackCorrType
void setTrackCorrType(TrackCorrType v)
Definition: FPGATrackSimTrack.h:83
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
FPGATrackSimHoughRootOutputTool::m_truth_d0
std::vector< float > m_truth_d0
Definition: FPGATrackSimHoughRootOutputTool.h:141
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:146
FPGATrackSimHoughRootOutputTool::m_offline_n_perigee
std::vector< int > m_offline_n_perigee
Definition: FPGATrackSimHoughRootOutputTool.h:177
FPGATrackSimTrack::setTrackStage
void setTrackStage(TrackStage v)
Definition: FPGATrackSimTrack.h:84
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:102
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:161
FPGATrackSimTrack::setHoughY
void setHoughY(float v)
Definition: FPGATrackSimTrack.h:93
FPGATrackSimHoughRootOutputTool::m_truth_eta
std::vector< float > m_truth_eta
Definition: FPGATrackSimHoughRootOutputTool.h:144
FPGATrackSimTrack::setQOverPt
void setQOverPt(float v)
Definition: FPGATrackSimTrack.h:94
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:542
FPGATrackSimHoughRootOutputTool::m_truth_q
std::vector< int > m_truth_q
Definition: FPGATrackSimHoughRootOutputTool.h:147
FPGATrackSimHoughRootOutputTool::m_offline_n_inertmaterial
std::vector< int > m_offline_n_inertmaterial
Definition: FPGATrackSimHoughRootOutputTool.h:174
FPGATrackSimRoad::getY
float getY() const
Definition: FPGATrackSimRoad.h:91
FPGATrackSimHoughRootOutputTool::m_algo
ORAlgo m_algo
Definition: FPGATrackSimHoughRootOutputTool.h:68
FPGATrackSimHoughRootOutputTool::m_tHistSvc
ServiceHandle< ITHistSvc > m_tHistSvc
Definition: FPGATrackSimHoughRootOutputTool.h:64
FPGATrackSimHoughRootOutputTool::m_roadNCoords
std::vector< float > m_roadNCoords
Definition: FPGATrackSimHoughRootOutputTool.h:101
FPGATrackSimHoughRootOutputTool::m_EvtSel
ServiceHandle< IFPGATrackSimEventSelectionSvc > m_EvtSel
Definition: FPGATrackSimHoughRootOutputTool.h:62
FPGATrackSimHoughRootOutputTool::m_roadnumber
int m_roadnumber
Definition: FPGATrackSimHoughRootOutputTool.h:136
ORAlgo::InvertGrouping
@ InvertGrouping
FPGATrackSimHoughRootOutputTool::m_barcode
std::vector< unsigned long > m_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:87
FPGATrackSimHoughRootOutputTool::m_track_hit_x
std::vector< std::vector< float > > m_track_hit_x
Definition: FPGATrackSimHoughRootOutputTool.h:151
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:121
FPGATrackSimHoughRootOutputTool::m_offline_barcode
std::vector< int > m_offline_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:187
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:176
FPGATrackSimHoughRootOutputTool::m_layerID
std::vector< int > m_layerID
Definition: FPGATrackSimHoughRootOutputTool.h:81
FPGATrackSimHoughRootOutputTool::m_fakelabel
unsigned int m_fakelabel
Definition: FPGATrackSimHoughRootOutputTool.h:119
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:117
FPGATrackSimHoughRootOutputTool::m_associated_truth_pt
float m_associated_truth_pt
Definition: FPGATrackSimHoughRootOutputTool.h:122
FPGATrackSimHoughRootOutputTool::m_offline_n_other
std::vector< int > m_offline_n_other
Definition: FPGATrackSimHoughRootOutputTool.h:179
FPGATrackSimHoughRootOutputTool::m_offline_n_holes
std::vector< int > m_offline_n_holes
Definition: FPGATrackSimHoughRootOutputTool.h:172
FPGATrackSimHoughRootOutputTool::m_associated_truth_eta
float m_associated_truth_eta
Definition: FPGATrackSimHoughRootOutputTool.h:124
FPGATrackSimHoughRootOutputTool::m_offline_pt
std::vector< float > m_offline_pt
Definition: FPGATrackSimHoughRootOutputTool.h:183
FPGATrackSimHoughRootOutputTool::m_tracknumber
int m_tracknumber
Definition: FPGATrackSimHoughRootOutputTool.h:130
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:164
FPGATrackSimRoad::getSector
sector_t getSector() const
Definition: FPGATrackSimRoad.h:95
FPGATrackSimHoughRootOutputTool::m_isSP
std::vector< bool > m_isSP
Definition: FPGATrackSimHoughRootOutputTool.h:105
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
FPGATrackSimHoughRootOutputTool::m_NTracksORMinusRoads
long m_NTracksORMinusRoads
Definition: FPGATrackSimHoughRootOutputTool.h:113
FPGATrackSimRoad::getPID
pid_t getPID() const
Definition: FPGATrackSimRoad.h:94
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:188
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:159
FPGATrackSimHoughRootOutputTool::m_truth_barcode
std::vector< int > m_truth_barcode
Definition: FPGATrackSimHoughRootOutputTool.h:148
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:158
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:143
FPGATrackSimHoughRootOutputTool::m_custom_layerID
std::vector< int > m_custom_layerID
Definition: FPGATrackSimHoughRootOutputTool.h:80
muCombUtil::getChi2
double getChi2(int &ndof, double ipt, double eta1, double seta1, double phi1, double sphi1, double ipt1, double sipt1, double eta2, double seta2, double phi2, double sphi2, double ipt2, double sipt2, bool useAbsPt)
Get OLD style (i.e. muFast time) Chi2.
Definition: muCombUtil.cxx:374
FPGATrackSimHoughRootOutputTool::m_associated_truth_phi
float m_associated_truth_phi
Definition: FPGATrackSimHoughRootOutputTool.h:125
FPGATrackSimTrack::setHoughX
void setHoughX(float v)
Definition: FPGATrackSimTrack.h:92
fitman.k
k
Definition: fitman.py:528
FPGATrackSimHoughRootOutputTool::m_track_hit_volumeID
std::vector< std::vector< int > > m_track_hit_volumeID
Definition: FPGATrackSimHoughRootOutputTool.h:168
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 Sun Nov 30 2025 21:33:15 for ATLAS Offline Software by   doxygen 1.8.18