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

#include <FPGATrackSimLogicalHitsProcessAlg.h>

Inheritance diagram for FPGATrackSimLogicalHitsProcessAlg:
Collaboration diagram for FPGATrackSimLogicalHitsProcessAlg:

Public Member Functions

 FPGATrackSimLogicalHitsProcessAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~FPGATrackSimLogicalHitsProcessAlg ()=default
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
virtual StatusCode finalize () override
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
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 sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

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 readInputs (bool &done)
 
StatusCode processInputs (SG::WriteHandle< FPGATrackSimHitCollection > &FPGAHitUnmapped_1st, SG::WriteHandle< FPGATrackSimClusterCollection > &FPGAClusters_1st, SG::WriteHandle< FPGATrackSimClusterCollection > &FPGAClustersFiltered_1st, SG::WriteHandle< FPGATrackSimClusterCollection > &FPGASpacePoints_1st)
 
StatusCode secondStageProcessing (std::vector< FPGATrackSimTrack > const &tracks_1st, std::vector< FPGATrackSimRoad * > &roads_2nd, std::vector< FPGATrackSimTrack > &tracks_2nd)
 
StatusCode writeOutputData (std::vector< FPGATrackSimRoad * > const &roads_1st, std::vector< FPGATrackSimTrack > const &tracks_1st, std::vector< FPGATrackSimRoad * > const &roads_2nd, std::vector< FPGATrackSimTrack > const &tracks_2nd, FPGATrackSimDataFlowInfo const *dataFlowInfo)
 
void printHitSubregions (std::vector< FPGATrackSimHit > const &hits)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::string m_description
 
int m_ev = 0
 
ToolHandle< IFPGATrackSimInputTool > m_hitSGInputTool {this, "SGInputTool", "", "Input tool from SG"}
 
ToolHandle< IFPGATrackSimEventInputHeaderTool > m_hitInputTool {this, "InputTool", "FPGATrackSimSGToRawHitsTool/FPGATrackSimSGToRawHitsTool", "Input Tool"}
 
ToolHandle< FPGATrackSimReadRawRandomHitsTool > m_hitInputTool2 {this, "InputTool2", "FPGATrackSimReadRawRandomHitsTool/FPGATrackSimReadRawRandomHitsTool", "Potential 2nd input Tool to load data from more than one source"}
 
ToolHandle< FPGATrackSimRawToLogicalHitsTool > m_hitMapTool {this, "RawToLogicalHitsTool", "FPGATrackSim_RawToLogicalHitsTool/FPGATrackSim_RawToLogicalHitsTool", "Raw To Logical Tool"}
 
ToolHandle< IFPGATrackSimHitFilteringTool > m_hitFilteringTool {this, "HitFilteringTool", "FPGATrackSimHitFilteringTool/FPGATrackSimHitFilteringTool", "Hit Filtering Tool"}
 
ToolHandle< FPGATrackSimClusteringToolI > m_clusteringTool {this, "ClusteringTool", "FPGATrackSimClusteringTool/FPGATrackSimClusteringTool", "Hit Clustering Tool"}
 
ToolHandle< FPGATrackSimSpacePointsToolI > m_spacepointsTool {this, "SpacePointTool", "FPGATrackSimSpacePointsTool/FPGATrackSimSpacePointsTool", "Space Points Tool"}
 
ToolHandle< IFPGATrackSimRoadFinderTool > m_roadFinderTool {this, "RoadFinder", "FPGATrackSimPatternMatchTool", "Road Finder Tool"}
 
ToolHandle< FPGATrackSimLLPRoadFilterTool > m_LRTRoadFilterTool {this, "LRTRoadFilter", "FPGATrackSimLLPRoadFilterTool/FPGATrackSimLLPRoadFilterTool", "LRT Road Filter Tool"}
 
ToolHandle< IFPGATrackSimRoadFinderTool > m_LRTRoadFinderTool {this, "LRTRoadFinder", "FPGATrackSimHoughTransform_d0phi0_Tool/FPGATrackSimHoughTransform_d0phi0_Tool", "LRT Road Finder Tool"}
 
ToolHandle< IFPGATrackSimRoadFilterTool > m_roadFilterTool {this, "RoadFilter", "FPGATrackSimEtaPatternFilterTool", "Road Filter Tool"}
 
ToolHandle< IFPGATrackSimRoadFilterTool > m_roadFilterTool2 {this, "RoadFilter2", "FPGATrackSimPhiRoadFilterTool", "Road Filter2 Tool"}
 
ToolHandle< IFPGATrackSimRoadFilterTool > m_spRoadFilterTool {this, "SPRoadFilterTool", "FPGATrackSimSpacepointRoadFilterTool", "Spacepoint Road Filter Tool"}
 
ToolHandle< FPGATrackSimNNTrackTool > m_NNTrackTool {this, "NNTrackTool", "FPGATrackSimNNTrackTool/FPGATrackSimNNTrackTool", "NN Track Tool"}
 
ToolHandle< FPGATrackSimHoughRootOutputTool > m_houghRootOutputTool {this, "HoughRootOutputTool", "FPGATrackSimHoughRootOutputTool/FPGATrackSimHoughRootOutputTool", "Hough ROOT Output Tool"}
 
ToolHandle< FPGATrackSimTrackFitterTool > m_trackFitterTool_1st {this, "TrackFitter_1st", "FPGATrackSimTrackFitterTool/FPGATrackSimTrackFitterTool_1st", "1st stage track fit tool"}
 
ToolHandle< FPGATrackSimTrackFitterTool > m_trackFitterTool_2nd {this, "TrackFitter_2nd", "FPGATrackSimTrackFitterTool/FPGATrackSimTrackFitterTool_2nd", "2nd stage track fit tool"}
 
ToolHandle< FPGATrackSimOverlapRemovalTool > m_overlapRemovalTool_1st {this, "OverlapRemoval_1st", "FPGATrackSimOverlapRemovalTool/FPGATrackSimOverlapRemovalTool_1st", "1st stage overlap removal tool"}
 
ToolHandle< FPGATrackSimOverlapRemovalTool > m_overlapRemovalTool_2nd {this, "OverlapRemoval_2nd", "FPGATrackSimOverlapRemovalTool/FPGATrackSimOverlapRemovalTool_2nd", "2nd stage overlap removal tool"}
 
ToolHandle< FPGATrackSimDataFlowTool > m_dataFlowTool {this, "DataFlowTool", "FPGATrackSimDataFlowTool/FPGATrackSimDataFlowTool", "Data Flow Tool"}
 
ToolHandle< IFPGATrackSimEventOutputHeaderTool > m_writeOutputTool {this, "OutputTool", "FPGATrackSimOutputHeaderTool/FPGATrackSimOutputHeaderTool", "Output tool"}
 
ServiceHandle< IFPGATrackSimMappingSvc > m_FPGATrackSimMapping {this, "FPGATrackSimMapping", "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"}
 
ServiceHandle< IFPGATrackSimEventSelectionSvc > m_evtSel {this, "eventSelector", "FPGATrackSimEventSelectionSvc", "Event selection Svc"}
 
Gaudi::Property< int > m_firstInputToolN {this, "FirstInputToolN", 1, "number of times to use event from first input tool"}
 
Gaudi::Property< int > m_secondInputToolN {this, "SecondInputToolN", 0, "number of times to use event from second input tool"}
 
Gaudi::Property< bool > m_doHitFiltering {this, "HitFiltering", false, "flag to enable hit/cluster filtering"}
 
Gaudi::Property< bool > m_clustering {this, "Clustering", false, "flag to enable the clustering"}
 
Gaudi::Property< bool > m_doSpacepoints {this, "Spacepoints", false, "flag to enable the spacepoint formation"}
 
Gaudi::Property< bool > m_doTracking {this, "tracking", false, "flag to enable the tracking"}
 
Gaudi::Property< bool > m_doMissingHitsChecks {this, "DoMissingHitsChecks", false}
 
Gaudi::Property< bool > m_filterRoads {this, "FilterRoads", false, "enable first road filter"}
 
Gaudi::Property< bool > m_filterRoads2 {this, "FilterRoads2", false, "enable second road filter"}
 
Gaudi::Property< bool > m_runSecondStage {this, "RunSecondStage", false, "flag to enable running the second stage fitting"}
 
Gaudi::Property< bool > m_doHoughRootOutput {this, "DoHoughRootOutput", false, "Dump output from the Hough Transform to flat ntuples"}
 
Gaudi::Property< bool > m_doNNTrack {this, "DoNNTrack", false, "Run NN track filtering"}
 
Gaudi::Property< bool > m_doLRT {this, "doLRT", false, "Enable Large Radius Tracking"}
 
Gaudi::Property< bool > m_doLRTHitFiltering {this, "LRTHitFiltering", false, "flag to enable hit/cluster filtering for LRT"}
 
Gaudi::Property< bool > m_writeOutputData {this, "writeOutputData", true,"write the output TTree"}
 
Gaudi::Property< bool > m_outputHitTxt {this, "outputHitTxt", false, "write out road hits to text file"}
 
Gaudi::Property< bool > m_doEvtSel {this, "doEvtSel", true, "do event selection"}
 
std::string m_outputHitTxtName = "outputRoadHits.txt"
 
std::ofstream m_outputHitTxtStream
 
FPGATrackSimEventInputHeader m_eventHeader
 
FPGATrackSimEventInputHeader m_firstInputHeader
 
FPGATrackSimLogicalEventInputHeader * m_logicEventHeader_1st = nullptr
 
FPGATrackSimLogicalEventInputHeader * m_logicEventHeader_2nd = nullptr
 
FPGATrackSimLogicalEventOutputHeader * m_logicEventOutputHeader = nullptr
 
std::vector< FPGATrackSimCluster > m_clusters_1st
 
std::vector< FPGATrackSimCluster > m_clusters_1st_original
 
std::vector< FPGATrackSimCluster > m_clusters_2nd
 
std::vector< FPGATrackSimCluster > m_spacepoints_1st
 
std::vector< FPGATrackSimCluster > m_spacepoints_2nd
 
std::vector< FPGATrackSimHit > m_hits_1st_miss
 
std::vector< FPGATrackSimHit > m_hits_2nd_miss
 
std::vector< FPGATrackSimTrack > m_tracks_1st_guessedcheck
 
std::vector< FPGATrackSimTrack > m_tracks_1st_nomiss
 
std::vector< FPGATrackSimTrack > m_tracks_2nd_guessedcheck
 
std::vector< FPGATrackSimTrack > m_tracks_2nd_nomiss
 
double m_evt = 0
 
long m_nRoadsTot = 0
 
long m_nTracksTot = 0
 
long m_nTracksChi2Tot = 0
 
long m_nTracksChi2OLRTot = 0
 
double m_evt_truth = 0
 
long m_nRoadsFound = 0
 
long m_nTracksFound = 0
 
long m_nTracksChi2Found = 0
 
long m_nTracksChi2OLRFound = 0
 
ToolHandle< GenericMonitoringTool > m_monTool {this,"MonTool", "", "Monitoring tool"}
 
SG::WriteHandleKeyArray< FPGATrackSimClusterCollection > m_FPGAClusterKey {this, "FPGATrackSimClusterKey",{"FPGAClusters_1st","FPGAClusters_2nd"},"FPGATrackSim Clusters key"}
 
SG::WriteHandleKey< FPGATrackSimClusterCollection > m_FPGAClusterFilteredKey {this, "FPGATrackSimClusterFilteredKey","FPGAClustersFiltered_1st","FPGATrackSim Filtered Clusters key"}
 
SG::WriteHandleKeyArray< FPGATrackSimClusterCollection > m_FPGASpacePointsKey {this, "FPGATrackSimSpacePoints1stKey",{"FPGASpacePoints_1st","FPGASpacePoints_1st"},"FPGATrackSim SpacePoints key"}
 
SG::WriteHandleKeyArray< FPGATrackSimHitCollection > m_FPGAHitKey {this, "FPGATrackSimHitKey",{"FPGAHits_1st","FPGAHits_2nd"},"FPGATrackSim Hits key"}
 
SG::WriteHandleKey< FPGATrackSimHitCollection > m_FPGAHitUnmappedKey {this, "FPGATrackSimHitUnmappedKey","FPGAHitsUnmapped_1st","FPGATrackSim Unmapped Hits 1st stage key"}
 
SG::WriteHandleKey< FPGATrackSimHitCollection > m_FPGAHitFilteredKey {this, "FPGATrackSimHitFiltered1stKey","FPGAHitsFiltered_1st","FPGATrackSim Filtered Hits 1st stage key"}
 
SG::WriteHandleKey< FPGATrackSimHitContainer > m_FPGAHitInRoadsKey {this, "FPGATrackSimHitInRoads1stKey","FPGAHitsInRoads_1st","FPGATrackSim Hits in 1st stage roads key"}
 
SG::WriteHandleKey< FPGATrackSimRoadCollection > m_FPGARoadKey {this, "FPGATrackSimRoad1stKey","FPGARoads_1st","FPGATrackSim Roads 1st stage key"}
 
SG::WriteHandleKey< FPGATrackSimTrackCollection > m_FPGATrackKey {this, "FPGATrackSimTrack1stKey","FPGATracks_1st","FPGATrackSim Tracks 1st stage key"}
 
DataObjIDColl m_extendedExtraObjects
 
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 58 of file FPGATrackSimLogicalHitsProcessAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ FPGATrackSimLogicalHitsProcessAlg()

FPGATrackSimLogicalHitsProcessAlg::FPGATrackSimLogicalHitsProcessAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 43 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

43  :
44  AthAlgorithm(name, pSvcLocator)
45 {
46 }

◆ ~FPGATrackSimLogicalHitsProcessAlg()

virtual FPGATrackSimLogicalHitsProcessAlg::~FPGATrackSimLogicalHitsProcessAlg ( )
virtualdefault

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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; }

◆ execute()

StatusCode FPGATrackSimLogicalHitsProcessAlg::execute ( )
overridevirtual

Definition at line 127 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

128 {
129 #ifdef BENCHMARK_LOGICALHITSALG
130  std::chrono::time_point<std::chrono::steady_clock> t_0, t_1;
131  t_0 = std::chrono::steady_clock::now();
132 #endif
133 
134  const EventContext& ctx = getContext();
135  // Read inputs
136  bool done = false;
137  ATH_CHECK(readInputs(done));
138 
139  if (done) {
140  IEventProcessor* appMgr = nullptr;
141  ATH_CHECK(service("ApplicationMgr",appMgr));
142  if (!appMgr) {
143  ATH_MSG_ERROR("Failed to retrieve ApplicationMgr as IEventProcessor");
144  return StatusCode::FAILURE;
145  }
146  return appMgr->stopRun();
147  }
148 
149  SG::WriteHandle<FPGATrackSimRoadCollection> FPGARoads_1st (m_FPGARoadKey, ctx);
150  SG::WriteHandle<FPGATrackSimHitContainer> FPGAHitsInRoads_1st (m_FPGAHitInRoadsKey, ctx);
151 
152  ATH_CHECK( FPGARoads_1st.record (std::make_unique<FPGATrackSimRoadCollection>()));
153  ATH_CHECK( FPGAHitsInRoads_1st.record (std::make_unique<FPGATrackSimHitContainer>()));
154 
155  SG::WriteHandle<FPGATrackSimTrackCollection> FPGATracks_1stHandle (m_FPGATrackKey, ctx);
156  ATH_CHECK(FPGATracks_1stHandle.record (std::make_unique<FPGATrackSimTrackCollection>()));
157 
158  SG::WriteHandle<FPGATrackSimHitCollection> FPGAHits_1st (m_FPGAHitKey.at(0), ctx);
159  ATH_CHECK( FPGAHits_1st.record (std::make_unique<FPGATrackSimHitCollection>()));
160 
161  SG::WriteHandle<FPGATrackSimHitCollection> FPGAHitsFiltered_1st (m_FPGAHitFilteredKey, ctx);
162  ATH_CHECK( FPGAHitsFiltered_1st.record (std::make_unique<FPGATrackSimHitCollection>()));
163 
164  SG::WriteHandle<FPGATrackSimHitCollection> FPGAHitUnmapped_1st (m_FPGAHitUnmappedKey, ctx);
165  ATH_CHECK( FPGAHitUnmapped_1st.record (std::make_unique<FPGATrackSimHitCollection>()));
166 
167  SG::WriteHandle<FPGATrackSimClusterCollection> FPGAClusters_1st (m_FPGAClusterKey.at(0), ctx);
168  ATH_CHECK( FPGAClusters_1st.record (std::make_unique<FPGATrackSimClusterCollection>()));
169 
170  SG::WriteHandle<FPGATrackSimClusterCollection> FPGAClustersFiltered_1st (m_FPGAClusterFilteredKey, ctx);
171  ATH_CHECK( FPGAClustersFiltered_1st.record (std::make_unique<FPGATrackSimClusterCollection>()));
172 
173  SG::WriteHandle<FPGATrackSimClusterCollection> FPGASpacePoints_1st (m_FPGASpacePointsKey.at(0), ctx);
174  ATH_CHECK( FPGASpacePoints_1st.record (std::make_unique<FPGATrackSimClusterCollection>()));
175 
176  // Apply truth track cuts
177  if ( m_doEvtSel ){
178  if (!m_evtSel->selectEvent(&m_eventHeader))
179  {
180  ATH_MSG_DEBUG("Event skipped by: " << m_evtSel->name());
181  return StatusCode::SUCCESS;
182  }
183  ATH_MSG_DEBUG("Event accepted by: " << m_evtSel->name());
184  } else {
185  ATH_MSG_DEBUG("No Event Election applied");
186  }
187  TIME(m_tread);
188 
189  // Event passes cuts, count it
190  m_evt++;
191 
192  // Map, cluster, and filter hits
193  ATH_CHECK(processInputs(FPGAHitUnmapped_1st, FPGAClusters_1st, FPGAClustersFiltered_1st, FPGASpacePoints_1st));
194  // Get reference to hits
195  unsigned regionID = m_evtSel->getRegionID();
196  // Recording Data
197  auto mon_regionID = Monitored::Scalar<unsigned>("regionID", regionID);
198  Monitored::Group(m_monTool, mon_regionID);
199 
200  TIME(m_tprocess);
201 
202  // Get roads
203  std::vector<FPGATrackSimRoad*> prefilter_roads;
204  std::vector<FPGATrackSimRoad*>& roads_1st = prefilter_roads;
205  std::vector<const FPGATrackSimHit*> phits_1st;
206 
207  // If and when we set up code to run over more than one region/tower at a time this will need to be updated
208  std::vector<FPGATrackSimHit> const & hits_1st = m_logicEventHeader_1st->towers().at(0).hits();
209 
210  for (FPGATrackSimHit const& h : hits_1st) {
211  if (h.isReal()) phits_1st.push_back(&h);
212  }
213 
214  for (const FPGATrackSimHit* Hit : phits_1st) FPGAHits_1st->push_back(*Hit);
215 
216  auto mon_nhits_1st = Monitored::Scalar<unsigned>("nHits_1st", hits_1st.size());
217  auto mon_nhits_1st_unmapped = Monitored::Scalar<unsigned>("nHits_1st_unmapped", m_hits_1st_miss.size());
218  Monitored::Group(m_monTool, mon_nhits_1st, mon_nhits_1st_unmapped);
219  ATH_CHECK(m_roadFinderTool->getRoads(phits_1st, roads_1st));
220 
221 ;
222  for (const FPGATrackSimRoad *road:roads_1st){
223  std::vector<FPGATrackSimHit> road_hits;
224  ATH_MSG_DEBUG("Hough Road X Y: " << road->getX() << " " << road->getY());
225  for (size_t l = 0; l < road->getNLayers(); ++l) {
226  for (const FPGATrackSimHit* layerH : road->getHits(l)) {
227  road_hits.push_back(*layerH);
228  }
229  }
230  FPGAHitsInRoads_1st->push_back(road_hits);
231  FPGARoads_1st->push_back(*road);
232  }
233 
234  auto mon_nroads_1st = Monitored::Scalar<unsigned>("nroads_1st", roads_1st.size());
235  for (FPGATrackSimRoad *road : roads_1st) {
236  unsigned bitmask = road->getHitLayers();
237  for (size_t l = 0; l < m_FPGATrackSimMapping->PlaneMap_1st()->getNLogiLayers(); l++) {
238  if (bitmask & (1 << l)) {
239  auto mon_layerIDs_1st = Monitored::Scalar<unsigned>("layerIDs_1st",l);
240  Monitored::Group(m_monTool,mon_layerIDs_1st);
241  }
242  }
243  }
244  Monitored::Group(m_monTool, mon_nroads_1st);
245 
246  TIME(m_troads);
247  // Standard road Filter
248  std::vector<FPGATrackSimRoad*> postfilter_roads;
249  if (m_filterRoads)
250  {
251  ATH_CHECK(m_roadFilterTool->filterRoads(roads_1st, postfilter_roads));
252  roads_1st = postfilter_roads;
253  }
254  ATH_CHECK(m_overlapRemovalTool_1st->runOverlapRemoval(roads_1st));
255  // Road Filter2
256  std::vector<FPGATrackSimRoad*> postfilter2_roads;
257  if (m_filterRoads2) {
258  ATH_CHECK(m_roadFilterTool2->filterRoads(roads_1st, postfilter2_roads));
259  roads_1st = postfilter2_roads;
260  }
261  // Spacepoint road filter tool. Needed when fitting to spacepoints.
262  std::vector<FPGATrackSimRoad*> postfilter3_roads;
263  if (m_doSpacepoints) {
264  ATH_CHECK(m_spRoadFilterTool->filterRoads(roads_1st, postfilter3_roads));
265  roads_1st = postfilter3_roads;
266  }
267  auto mon_nroads_1st_postfilter = Monitored::Scalar<unsigned>("nroads_1st_postfilter", roads_1st.size());
268  Monitored::Group(m_monTool, mon_nroads_1st_postfilter);
269 
270 
271 
272  TIME(m_troad_filter);
273  // Get tracks
274  std::vector<FPGATrackSimTrack> tracks_1st;
275  if (m_doTracking) {
276  if (m_doNNTrack) {
277  ATH_MSG_DEBUG("Performing NN tracking");
278  const FPGATrackSimNNMap* nnMap = m_FPGATrackSimMapping->NNMap();
279  ATH_CHECK(m_NNTrackTool->getTracks(roads_1st, tracks_1st, nnMap));
280  }
281  else {
282  ATH_CHECK(m_trackFitterTool_1st->getTracks(roads_1st, tracks_1st));
283  float bestchi2 = 1.e15;
284  for (const FPGATrackSimTrack& track : tracks_1st) {
285  float chi2 = track.getChi2ndof();
286  if (chi2 < bestchi2) bestchi2 = chi2;
287  auto mon_chi2_1st = Monitored::Scalar<float>("chi2_1st_all",chi2);
288  Monitored::Group(m_monTool,mon_chi2_1st);
289  }
290  auto mon_best_chi2_1st = Monitored::Scalar<float>("best_chi2_1st",bestchi2);
291  Monitored::Group(m_monTool,mon_best_chi2_1st);
292  }
293  }
294  auto mon_ntracks_1st = Monitored::Scalar<unsigned>("ntrack_1st", tracks_1st.size());
295  Monitored::Group(m_monTool,mon_ntracks_1st);
296 
297  TIME(m_ttracks);
298 
299  // Overlap removal
300  ATH_CHECK(m_overlapRemovalTool_1st->runOverlapRemoval(tracks_1st));
301  unsigned ntrackOLRChi2 = 0;
302  for (auto track : tracks_1st) {
303  if (track.getChi2ndof() < 10) {
304  m_nTracksChi2Tot++;
305  if (track.passedOR()) {
306  ntrackOLRChi2++;
307  m_nTracksChi2OLRTot++;
308  }
309  }
310  }
311  auto mon_ntracks_1st_olr = Monitored::Scalar<unsigned>("ntrack_1st_afterOLR", ntrackOLRChi2);
312  Monitored::Group(m_monTool,mon_ntracks_1st_olr);
313 
314  m_nRoadsTot += roads_1st.size();
315  m_nTracksTot += tracks_1st.size();
316 
317  // Do some simple monitoring of efficiencies
318  std::vector<FPGATrackSimTruthTrack> const & truthtracks = m_logicEventHeader_1st->optional().getTruthTracks();
319  if (truthtracks.size() > 0) {
320  m_evt_truth++;
321  auto passroad = Monitored::Scalar<bool>("eff_road",(roads_1st.size() > 0));
322  auto passtrack = Monitored::Scalar<bool>("eff_track",(tracks_1st.size() > 0));
323  auto truthpT_zoom = Monitored::Scalar<float>("pT_zoom",truthtracks.front().getPt()*0.001);
324  auto truthpT = Monitored::Scalar<float>("pT",truthtracks.front().getPt()*0.001);
325  auto trutheta = Monitored::Scalar<float>("eta",truthtracks.front().getEta());
326  auto truthphi= Monitored::Scalar<float>("phi",truthtracks.front().getPhi());
327  auto truthd0= Monitored::Scalar<float>("d0",truthtracks.front().getD0());
328  auto truthz0= Monitored::Scalar<float>("z0",truthtracks.front().getZ0());
329  if (roads_1st.size() > 0) m_nRoadsFound++;
330  bool passchi2 = false;
331  bool passchi2OLR = false;
332  if (tracks_1st.size() > 0) {
333  m_nTracksFound++;
334  for (auto track : tracks_1st) {
335  if (track.getChi2ndof() < 10) {
336  passchi2 = true;
337  if (track.passedOR()) {
338  passchi2OLR = true;
339  break;
340  }
341  }
342  }
343  }
344  if (passchi2) m_nTracksChi2Found++;
345  if (passchi2OLR) m_nTracksChi2OLRFound++;
346  auto passtrackchi2 = Monitored::Scalar<bool>("eff_track_chi2",passchi2);
347  Monitored::Group(m_monTool,passroad,passtrack,truthpT_zoom,truthpT,trutheta,truthphi,truthd0,truthz0,passtrackchi2);
348  }
349 
350  for (const FPGATrackSimTrack& track : tracks_1st) FPGATracks_1stHandle->push_back(track);
351 
352  TIME(m_tOR);
353 
354  // Now, we may want to do large-radius tracking on the hits not used by the first stage tracking.
355  // This follows overlap removal.
356  std::vector<FPGATrackSimRoad*> roadsLRT;
357  std::vector<FPGATrackSimTrack> tracksLRT; // currently empty
358  if (m_doLRT) {
359  // Filter out hits that are on successful first-stage tracks
360  std::vector<const FPGATrackSimHit*> remainingHits;
361 
362  if (m_doLRTHitFiltering) {
363  ATH_MSG_DEBUG("Doing hit filtering based on prompt tracks.");
364  ATH_CHECK(m_LRTRoadFilterTool->filterUsedHits(tracks_1st, phits_1st, remainingHits));
365 
366  for (const FPGATrackSimHit* Hit : remainingHits) FPGAHitsFiltered_1st->push_back(*Hit);
367 
368  } else {
369  ATH_MSG_DEBUG("No hit filtering requested; using all hits for LRT.");
370  remainingHits = phits_1st;
371  }
372 
373  // Get LRT roads with remaining hits
374  ATH_MSG_DEBUG("Finding LRT roads");
375  ATH_CHECK(m_LRTRoadFinderTool->getRoads( remainingHits, roadsLRT ));
376  }
377 
378  TIME(m_tlrt);
379 
380  auto dataFlowInfo = std::make_unique<FPGATrackSimDataFlowInfo>();
381 
382  // Second stage fitting
383  std::vector<FPGATrackSimRoad*> roads_2nd;
384  std::vector<FPGATrackSimTrack> tracks_2nd;
385  if (m_runSecondStage) {
386  ATH_CHECK(secondStageProcessing(tracks_1st, roads_2nd, tracks_2nd));
387  TIME(m_t2ndStage);
388  }
389 
390  // Calculate data flow quantities
391  if (m_writeOutputData) {
392  ATH_CHECK(m_dataFlowTool->calculateDataFlow(dataFlowInfo.get(), m_logicEventHeader_1st, m_clusters_1st, roads_1st, tracks_1st, roads_2nd, tracks_2nd));
393  }
394 
395  // Write the output and reset
396  ATH_CHECK(writeOutputData(roads_1st, tracks_1st, roads_2nd, tracks_2nd, dataFlowInfo.get()));
397 
398  if (m_doHoughRootOutput) {
399  ATH_CHECK(m_houghRootOutputTool->fillTree(roads_1st, m_logicEventHeader_1st->optional().getTruthTracks(), m_logicEventHeader_1st->optional().getOfflineTracks()));
400  }
401 
402  // dump hit identifiers per road/track to text file
403  if(m_outputHitTxt) {
404 
405  ATH_MSG_DEBUG("Dumping hits in roads to text file " << m_outputHitTxtName);
406  m_outputHitTxtStream << std::endl << "event " << m_ev << ", "
407  << roads_1st.size() << " roads"; // endl moved below to deal with trailing comma
408 
409  // m_clusters_original exists, we just need to know which ones to access
410  // FPGATrackSimRoad::getHits returns a vector of FPGATrackSimHit, but each of them is actually a cluster
411  // m_parentageMask has been co-opted to store the cluster index (set in clustering tool)
412  // this lets us get hold of the actual FPGATrackSimCluster via m_clusters_original[index]
413 
414  int roadCount = 0;
415  for(auto &road : roads_1st) {
416  // to avoid empty entries if a layer has no hits in a road, save the hits to vector first
417  std::vector< std::vector<FPGATrackSimHit> > clusters_in_road;
418  for(int layer = 0; layer < int(road->getNLayers()); layer ++) {
419  for(auto &cluster_as_hit : road->getHits(layer)) {
420  unsigned clusterIndex = (unsigned)cluster_as_hit->getParentageMask();
421  FPGATrackSimCluster thisCluster = m_clusters_1st_original.at(clusterIndex);
422 
423  // check that they match (might slow things down unnecessarily - remove later perhaps)
424  if( (cluster_as_hit->getR() != thisCluster.getClusterEquiv().getR()) ||
425  (cluster_as_hit->getZ() != thisCluster.getClusterEquiv().getZ()) ||
426  (cluster_as_hit->getGPhi() != thisCluster.getClusterEquiv().getGPhi()) ){
427  ATH_MSG_ERROR("cluster retrieved from index seems not to match");
428  ATH_MSG_DEBUG("road ID " << road->getRoadID() << ", layer " << layer
429  << ", cluster index " << clusterIndex << "road.getHits(layer): " << cluster_as_hit->getR() << " "
430  << cluster_as_hit->getZ() << " " << cluster_as_hit->getGPhi());
431  ATH_MSG_DEBUG("m_cluster[index]: " << thisCluster.getClusterEquiv().getR() << " "
432  << thisCluster.getClusterEquiv().getZ() << " "
433  << thisCluster.getClusterEquiv().getGPhi());
434  }
435  clusters_in_road.push_back(thisCluster.getHitList());
436  }
437  }
438 
439  if(roadCount != 0) m_outputHitTxtStream << ",";
440  m_outputHitTxtStream << std::endl << "[ ";
441  bool firstCluster = true;
442  for(auto &clusterHits : clusters_in_road) {
443  if(firstCluster) firstCluster = false;
444  else m_outputHitTxtStream << ", ";
445  bool firstHit = true;
446  m_outputHitTxtStream << "[ ";
447  for(auto &hit : clusterHits) {
448  if(firstHit) firstHit = false;
449  else m_outputHitTxtStream << ", ";
450 
451  m_outputHitTxtStream << "[" << hit.isStrip() << ", " << hit.getIdentifierHash() << ", "
452  << hit.getEtaIndex() << ", " << hit.getPhiIndex() << "]";
453  }
454  m_outputHitTxtStream << " ]";
455  }
456  m_outputHitTxtStream << " ]";
457  roadCount++;
458  }
459  }
460 
461 
462  // Reset data pointers
463  m_eventHeader.reset();
464  m_logicEventHeader_1st->reset();
465  m_logicEventOutputHeader->reset();
466  if (m_runSecondStage) m_logicEventHeader_2nd->reset();
467 
468  TIME(m_tfin);
469 
470  return StatusCode::SUCCESS;
471 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode FPGATrackSimLogicalHitsProcessAlg::finalize ( )
overridevirtual

Definition at line 683 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

684 {
685 #ifdef BENCHMARK_LOGICALHITSALG
686  ATH_MSG_INFO("Timings:" <<
687  "\nread input: " << std::setw(10) << m_tread <<
688  "\nprocess hits: " << std::setw(10) << m_tprocess <<
689  "\nroads: " << std::setw(10) << m_troads <<
690  "\nroad filter: " << std::setw(10) << m_troad_filter <<
691  "\nllp: " << std::setw(10) << m_tlrt <<
692  "\ntracks: " << std::setw(10) << m_ttracks <<
693  "\nOR: " << std::setw(10) << m_tOR <<
694  (m_runSecondStage ? : ("\n2ndStage: " << std::setw(10) << m_t2ndStage) : "") <<
695  "\nmon: " << std::setw(10) << m_tmon <<
696  "\nfin: " << std::setw(10) << m_tfin
697  );
698 #endif
699 
700 
701  if (m_outputHitTxt) m_outputHitTxtStream.close();
702 
703  ATH_MSG_INFO("PRINTING FPGATRACKSIM SIMPLE STATS");
704  ATH_MSG_INFO("========================================================================================");
705  ATH_MSG_INFO("Inclusive efficiency to find a road = " << m_nRoadsFound/m_evt_truth);
706  ATH_MSG_INFO("Inclusive efficiency to find a track = " << m_nTracksFound/m_evt_truth);
707  ATH_MSG_INFO("Inclusive efficiency to find a track passing chi2 = " << m_nTracksChi2Found/m_evt_truth);
708  ATH_MSG_INFO("Inclusive efficiency to find a track passing chi2 and OLR = " << m_nTracksChi2OLRFound/m_evt_truth);
709 
710 
711  ATH_MSG_INFO("Number of 1st stage roads/event = " << m_nRoadsTot/m_evt);
712  ATH_MSG_INFO("Number of 1st stage track combinations/event = " << m_nTracksTot/m_evt);
713  ATH_MSG_INFO("Number of 1st stage tracks passing chi2/event = " << m_nTracksChi2Tot/m_evt);
714  ATH_MSG_INFO("Number of 1st stage tracks passing chi2 and OLR/event = " << m_nTracksChi2OLRTot/m_evt);
715  ATH_MSG_INFO("========================================================================================");
716 
717  return StatusCode::SUCCESS;
718 }

◆ initialize()

StatusCode FPGATrackSimLogicalHitsProcessAlg::initialize ( )
overridevirtual

Definition at line 49 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

50 {
51  std::stringstream ss(m_description);
52  std::string line;
53  ATH_MSG_INFO("Tag config:");
54  if (!m_description.empty()) {
55  while (std::getline(ss, line, '\n')) {
56  ATH_MSG_INFO('\t' << line);
57  }
58  }
59 
60 
61  ATH_CHECK(m_hitSGInputTool.retrieve(EnableTool{!m_hitSGInputTool.empty()}));
62 
63  ATH_CHECK(m_hitInputTool.retrieve(EnableTool{!m_hitInputTool.empty()}));
64  ATH_CHECK(m_hitInputTool2.retrieve(EnableTool{m_secondInputToolN > 0 && !m_hitInputTool2.empty()}));
65  ATH_CHECK(m_hitMapTool.retrieve());
66  ATH_CHECK(m_hitFilteringTool.retrieve(EnableTool{m_doHitFiltering}));
67  ATH_CHECK(m_clusteringTool.retrieve(EnableTool{m_clustering}));
68  ATH_CHECK(m_spacepointsTool.retrieve(EnableTool{m_doSpacepoints}));
69  ATH_CHECK(m_roadFinderTool.retrieve());
70 
71 
72  ATH_CHECK(m_LRTRoadFilterTool.retrieve(EnableTool{m_doLRT}));
73  ATH_CHECK(m_LRTRoadFinderTool.retrieve(EnableTool{m_doLRT}));
74  ATH_CHECK(m_houghRootOutputTool.retrieve(EnableTool{m_doHoughRootOutput}));
75  ATH_CHECK(m_NNTrackTool.retrieve(EnableTool{m_doNNTrack}));
76  ATH_CHECK(m_roadFilterTool.retrieve(EnableTool{m_filterRoads}));
77  ATH_CHECK(m_roadFilterTool2.retrieve(EnableTool{m_filterRoads2}));
78  if (m_doSpacepoints) ATH_CHECK(m_spRoadFilterTool.retrieve(EnableTool{m_spRoadFilterTool}));
79  ATH_CHECK(m_trackFitterTool_1st.retrieve(EnableTool{m_doTracking}));
80  ATH_CHECK(m_overlapRemovalTool_1st.retrieve());
81  ATH_CHECK(m_trackFitterTool_2nd.retrieve(EnableTool{m_runSecondStage && m_doTracking}));
82  ATH_CHECK(m_overlapRemovalTool_2nd.retrieve(EnableTool{m_runSecondStage}));
83  ATH_CHECK(m_dataFlowTool.retrieve());
84  ATH_CHECK(m_writeOutputTool.retrieve());
85  ATH_CHECK(m_FPGATrackSimMapping.retrieve());
86  if ( m_doEvtSel ) {
87  ATH_CHECK(m_evtSel.retrieve());
88  }
89 
90  ATH_MSG_DEBUG("initialize() Instantiating root objects");
91  m_logicEventHeader_1st = m_writeOutputTool->getLogicalEventInputHeader_1st();
92 
93 
94  m_logicEventOutputHeader = m_writeOutputTool->getLogicalEventOutputHeader();
95  if (m_runSecondStage) m_logicEventHeader_2nd = m_writeOutputTool->getLogicalEventInputHeader_2nd();
96 
97  ATH_MSG_DEBUG("initialize() Setting branch");
98  if (m_outputHitTxt) {
99  ATH_MSG_INFO("writing road hits to " << m_outputHitTxtName);
100  m_outputHitTxtStream.open(m_outputHitTxtName);
101  }
102 
103  if (!m_monTool.empty())
104  ATH_CHECK(m_monTool.retrieve());
105 
106  ATH_CHECK( m_FPGAClusterKey.initialize() );
107  ATH_CHECK( m_FPGAClusterFilteredKey.initialize() );
108  ATH_CHECK( m_FPGAHitKey.initialize() );
109  ATH_CHECK( m_FPGAHitInRoadsKey.initialize() );
110  ATH_CHECK( m_FPGAHitFilteredKey.initialize() );
111  ATH_CHECK( m_FPGASpacePointsKey.initialize() );
112  ATH_CHECK( m_FPGAHitUnmappedKey.initialize() );
113  ATH_CHECK( m_FPGARoadKey.initialize() );
114  ATH_CHECK( m_FPGATrackKey.initialize() );
115 
116  ATH_MSG_DEBUG("initialize() Finished");
117 
118 
119  return StatusCode::SUCCESS;
120 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::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< Algorithm >::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< Algorithm > >::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.

◆ printHitSubregions()

void FPGATrackSimLogicalHitsProcessAlg::printHitSubregions ( std::vector< FPGATrackSimHit > const &  hits)
private

Definition at line 724 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

725 {
726  ATH_MSG_WARNING("Hit regions:");
727  for (auto hit : hits)
728  {
729  std::vector<uint32_t> regions = m_FPGATrackSimMapping->SubRegionMap()->getRegions(hit);
730  std::stringstream ss;
731  for (auto r : regions)
732  ss << r << ",";
733  ATH_MSG_WARNING("\t[" << ss.str() << "]");
734  }
735 }

◆ processInputs()

StatusCode FPGATrackSimLogicalHitsProcessAlg::processInputs ( SG::WriteHandle< FPGATrackSimHitCollection > &  FPGAHitUnmapped_1st,
SG::WriteHandle< FPGATrackSimClusterCollection > &  FPGAClusters_1st,
SG::WriteHandle< FPGATrackSimClusterCollection > &  FPGAClustersFiltered_1st,
SG::WriteHandle< FPGATrackSimClusterCollection > &  FPGASpacePoints_1st 
)
private

Definition at line 519 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

523 {
524  m_clusters_1st.clear();
525  m_spacepoints_1st.clear();
526  m_hits_1st_miss.clear();
527 
528  // Map hits
529  ATH_MSG_DEBUG("Running hits conversion");
530  m_logicEventHeader_1st->reset();
531  ATH_CHECK(m_hitMapTool->convert(1, m_eventHeader, *m_logicEventHeader_1st));
532  if (!m_runSecondStage) m_eventHeader.clearHits();
533 
534  ATH_CHECK(m_hitMapTool->getUnmapped(m_hits_1st_miss));
535  for (const FPGATrackSimHit& hit : m_hits_1st_miss) FPGAHitUnmapped_1st->push_back(hit);
536 
537 
538 
539  ATH_MSG_DEBUG("Hits conversion done");
540  // Random removal of hits
541  if (m_doHitFiltering) {
542  ATH_MSG_DEBUG("Running hits filtering");
543  ATH_CHECK(m_hitFilteringTool->DoRandomRemoval(*m_logicEventHeader_1st, true));
544  }
545 
546  // Clustering
547  if (m_clustering)
548  {
549  ATH_MSG_DEBUG("Running clustering");
550  ATH_CHECK(m_clusteringTool->DoClustering(*m_logicEventHeader_1st, m_clusters_1st));
551  m_clusters_1st_original = m_clusters_1st;
552 
553  // I think I also want to pass m_clusters to random removal (but won't work currently)
554  if (m_doHitFiltering) ATH_CHECK(m_hitFilteringTool->DoRandomRemoval(*m_logicEventHeader_1st, false));
555  for (const FPGATrackSimCluster& cluster : m_clusters_1st_original) FPGAClusters_1st->push_back(cluster);
556 
557  }
558 
559  // Filter hits/clusters (untested for hits, ie with m_clustering = false)
560  if (m_doHitFiltering)
561  {
562  // get the sets of layers that we want to filter hits from
563  std::vector<int> filter_pixel_physLayers, filter_strip_physLayers;
564  const FPGATrackSimPlaneMap *planeMap_1st = m_FPGATrackSimMapping->PlaneMap_1st();
565  ATH_CHECK(m_hitFilteringTool->GetPairedStripPhysLayers(planeMap_1st, filter_strip_physLayers));
566  m_clusters_1st.clear();
567  ATH_CHECK(m_hitFilteringTool->DoHitFiltering(*m_logicEventHeader_1st, filter_pixel_physLayers, filter_strip_physLayers, m_clusters_1st));
568  for (const FPGATrackSimCluster &cluster : m_clusters_1st) FPGAClustersFiltered_1st->push_back(cluster);
569 
570  }
571 
572  // Space points
573  if (m_doSpacepoints) {
574  ATH_CHECK(m_spacepointsTool->DoSpacePoints(*m_logicEventHeader_1st, m_spacepoints_1st));
575  for (const FPGATrackSimCluster& cluster : m_spacepoints_1st) FPGASpacePoints_1st->push_back(cluster);
576  }
577 
578  return StatusCode::SUCCESS;
579 }

◆ readInputs()

StatusCode FPGATrackSimLogicalHitsProcessAlg::readInputs ( bool &  done)
private

Definition at line 478 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

479 {
480 
481  if ( !m_hitSGInputTool.empty()) {
482  ATH_CHECK(m_hitSGInputTool->readData(&m_eventHeader, Gaudi::Hive::currentContext()));
483  ATH_MSG_DEBUG("Loaded " << m_eventHeader.nHits() << " hits in event header from SG");
484 
485  return StatusCode::SUCCESS;
486  }
487 
488  if (m_ev % m_firstInputToolN == 0)
489  {
490  // Read primary input
491  ATH_CHECK(m_hitInputTool->readData(&m_firstInputHeader, done));
492  if (done)
493  {
494  ATH_MSG_INFO("Cannot read more events from file, returning");
495  return StatusCode::SUCCESS; // end of loop over events
496  }
497  }
498 
499  m_eventHeader = m_firstInputHeader;
500 
501  // Read secondary input
502  for (int i = 0; i < m_secondInputToolN; i++)
503  {
504  ATH_CHECK(m_hitInputTool2->readData(&m_eventHeader, done, false));
505  if (done)
506  {
507  ATH_MSG_INFO("Cannot read more events from file, returning");
508  return StatusCode::SUCCESS;
509  }
510  }
511 
512  m_ev++;
513 
514  return StatusCode::SUCCESS;
515 }

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

◆ secondStageProcessing()

StatusCode FPGATrackSimLogicalHitsProcessAlg::secondStageProcessing ( std::vector< FPGATrackSimTrack > const &  tracks_1st,
std::vector< FPGATrackSimRoad * > &  roads_2nd,
std::vector< FPGATrackSimTrack > &  tracks_2nd 
)
private

Definition at line 582 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

584 {
585  m_clusters_2nd.clear();
586  m_spacepoints_2nd.clear();
587  m_hits_2nd_miss.clear();
588 
589 
590  const EventContext& ctx = getContext();
591 
592  // Map hits
593  m_logicEventHeader_2nd->reset();
594  ATH_CHECK(m_hitMapTool->convert(2, m_eventHeader, *m_logicEventHeader_2nd));
595  m_eventHeader.clearHits();
596 
597  if (m_clustering) ATH_CHECK(m_clusteringTool->DoClustering(*m_logicEventHeader_2nd, m_clusters_2nd));
598 
599  SG::WriteHandle<FPGATrackSimClusterCollection> FPGAClusters_2nd (m_FPGAClusterKey.at(1), ctx);
600  ATH_CHECK( FPGAClusters_2nd.record (std::make_unique<FPGATrackSimClusterCollection>()));
601  for (const FPGATrackSimCluster& cluster : m_clusters_2nd) FPGAClusters_2nd->push_back(cluster);
602 
603  // Space points
604  if (m_doSpacepoints) {
605  ATH_CHECK(m_spacepointsTool->DoSpacePoints(*m_logicEventHeader_2nd, m_spacepoints_2nd));
606 
607  SG::WriteHandle<FPGATrackSimClusterCollection> FPGASpacePoints_2nd (m_FPGASpacePointsKey.at(1), ctx);
608  ATH_CHECK( FPGASpacePoints_2nd.record (std::make_unique<FPGATrackSimClusterCollection>()));
609  for (const FPGATrackSimCluster& cluster : m_spacepoints_2nd) FPGASpacePoints_2nd->push_back(cluster);
610  }
611 
612  std::vector<FPGATrackSimHit> const & hits_2nd = m_logicEventHeader_2nd->towers().at(0).hits();
613 
614  ATH_MSG_DEBUG("Number of second stage hits = " << hits_2nd.size());
615 
616  std::vector<const FPGATrackSimHit*> phits_2nd;
617  for (FPGATrackSimHit const & h : hits_2nd) phits_2nd.push_back(&h);
618 
619  SG::WriteHandle<FPGATrackSimHitCollection> FPGAHits_2nd (m_FPGAHitKey.at(1), ctx);
620  ATH_CHECK( FPGAHits_2nd.record (std::make_unique<FPGATrackSimHitCollection>()));
621  for (const FPGATrackSimHit* Hit : phits_2nd) FPGAHits_2nd->push_back(*Hit);
622 
623  // Get the first stage tracks after OR
624  std::vector<FPGATrackSimTrack> tracks_1st_OR;
625  for (auto track : tracks_1st) {
626  if (track.passedOR() == 1) tracks_1st_OR.push_back(track);
627  }
628 
629  ATH_MSG_DEBUG("Number of roads for second stage fitting " << roads_2nd.size());
630 
631  // Get second stage tracks
632  if (m_doTracking) ATH_CHECK(m_trackFitterTool_2nd->getTracks(roads_2nd, tracks_2nd));
633 
634  ATH_MSG_DEBUG("Number of tracks from the second stage fitting = " << tracks_2nd.size() << " and truth tracks = " << m_logicEventHeader_1st->optional().getTruthTracks().size());
635 
636  // Overlap removal
637  ATH_CHECK(m_overlapRemovalTool_2nd->runOverlapRemoval(tracks_2nd));
638 
639  return StatusCode::SUCCESS;
640 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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  }

◆ writeOutputData()

StatusCode FPGATrackSimLogicalHitsProcessAlg::writeOutputData ( std::vector< FPGATrackSimRoad * > const &  roads_1st,
std::vector< FPGATrackSimTrack > const &  tracks_1st,
std::vector< FPGATrackSimRoad * > const &  roads_2nd,
std::vector< FPGATrackSimTrack > const &  tracks_2nd,
FPGATrackSimDataFlowInfo const *  dataFlowInfo 
)
private

Definition at line 642 of file FPGATrackSimLogicalHitsProcessAlg.cxx.

645 {
646  m_logicEventOutputHeader->reset();
647 
648  ATH_MSG_DEBUG("NFPGATrackSimRoads_1st = " << roads_1st.size() << ", NFPGATrackSimTracks_1st = " << tracks_1st.size() << ", NFPGATrackSimRoads_2nd = " << roads_2nd.size() << ", NFPGATrackSimTracks_2nd = " << tracks_2nd.size());
649 
650  if (!m_writeOutputData) return StatusCode::SUCCESS;
651  m_logicEventOutputHeader->reserveFPGATrackSimRoads_1st(roads_1st.size());
652  m_logicEventOutputHeader->addFPGATrackSimRoads_1st(roads_1st);
653  if (m_doTracking) {
654  m_logicEventOutputHeader->reserveFPGATrackSimTracks_1st(tracks_1st.size());
655  m_logicEventOutputHeader->addFPGATrackSimTracks_1st(tracks_1st);
656  }
657 
658 
659  if (m_runSecondStage) {
660  m_logicEventOutputHeader->reserveFPGATrackSimRoads_2nd(roads_2nd.size());
661  m_logicEventOutputHeader->reserveFPGATrackSimTracks_2nd(tracks_2nd.size());
662 
663  m_logicEventOutputHeader->addFPGATrackSimRoads_2nd(roads_2nd);
664  m_logicEventOutputHeader->addFPGATrackSimTracks_2nd(tracks_2nd);
665  }
666 
667  m_logicEventOutputHeader->setDataFlowInfo(*dataFlowInfo);
668  ATH_MSG_DEBUG(m_logicEventOutputHeader->getDataFlowInfo());
669 
670  ATH_CHECK(m_writeOutputTool->writeData(m_logicEventHeader_1st, m_logicEventHeader_2nd, m_logicEventOutputHeader));
671 
672 
673 
674  return StatusCode::SUCCESS;
675 }

Member Data Documentation

◆ m_clustering

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_clustering {this, "Clustering", false, "flag to enable the clustering"}
private

Definition at line 102 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_clusteringTool

ToolHandle<FPGATrackSimClusteringToolI> FPGATrackSimLogicalHitsProcessAlg::m_clusteringTool {this, "ClusteringTool", "FPGATrackSimClusteringTool/FPGATrackSimClusteringTool", "Hit Clustering Tool"}
private

Definition at line 79 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_clusters_1st

std::vector<FPGATrackSimCluster> FPGATrackSimLogicalHitsProcessAlg::m_clusters_1st
private

Definition at line 128 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_clusters_1st_original

std::vector<FPGATrackSimCluster> FPGATrackSimLogicalHitsProcessAlg::m_clusters_1st_original
private

Definition at line 128 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_clusters_2nd

std::vector<FPGATrackSimCluster> FPGATrackSimLogicalHitsProcessAlg::m_clusters_2nd
private

Definition at line 128 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_dataFlowTool

ToolHandle<FPGATrackSimDataFlowTool> FPGATrackSimLogicalHitsProcessAlg::m_dataFlowTool {this, "DataFlowTool", "FPGATrackSimDataFlowTool/FPGATrackSimDataFlowTool", "Data Flow Tool"}
private

Definition at line 93 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_description

std::string FPGATrackSimLogicalHitsProcessAlg::m_description
private

Definition at line 70 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doEvtSel

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doEvtSel {this, "doEvtSel", true, "do event selection"}
private

Definition at line 115 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_doHitFiltering

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doHitFiltering {this, "HitFiltering", false, "flag to enable hit/cluster filtering"}
private

Definition at line 101 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_doHoughRootOutput

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doHoughRootOutput {this, "DoHoughRootOutput", false, "Dump output from the Hough Transform to flat ntuples"}
private

Definition at line 109 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_doLRT

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doLRT {this, "doLRT", false, "Enable Large Radius Tracking"}
private

Definition at line 111 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_doLRTHitFiltering

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doLRTHitFiltering {this, "LRTHitFiltering", false, "flag to enable hit/cluster filtering for LRT"}
private

Definition at line 112 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_doMissingHitsChecks

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doMissingHitsChecks {this, "DoMissingHitsChecks", false}
private

Definition at line 105 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_doNNTrack

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doNNTrack {this, "DoNNTrack", false, "Run NN track filtering"}
private

Definition at line 110 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_doSpacepoints

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doSpacepoints {this, "Spacepoints", false, "flag to enable the spacepoint formation"}
private

Definition at line 103 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_doTracking

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_doTracking {this, "tracking", false, "flag to enable the tracking"}
private

Definition at line 104 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_ev

int FPGATrackSimLogicalHitsProcessAlg::m_ev = 0
private

Definition at line 71 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_eventHeader

FPGATrackSimEventInputHeader FPGATrackSimLogicalHitsProcessAlg::m_eventHeader
private

Definition at line 121 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_evt

double FPGATrackSimLogicalHitsProcessAlg::m_evt = 0
private

Definition at line 134 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_evt_truth

double FPGATrackSimLogicalHitsProcessAlg::m_evt_truth = 0
private

Definition at line 140 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_evtSel

ServiceHandle<IFPGATrackSimEventSelectionSvc> FPGATrackSimLogicalHitsProcessAlg::m_evtSel {this, "eventSelector", "FPGATrackSimEventSelectionSvc", "Event selection Svc"}
private

Definition at line 96 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_filterRoads

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_filterRoads {this, "FilterRoads", false, "enable first road filter"}
private

Definition at line 106 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_filterRoads2

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_filterRoads2 {this, "FilterRoads2", false, "enable second road filter"}
private

Definition at line 107 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_firstInputHeader

FPGATrackSimEventInputHeader FPGATrackSimLogicalHitsProcessAlg::m_firstInputHeader
private

Definition at line 122 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_firstInputToolN

Gaudi::Property<int> FPGATrackSimLogicalHitsProcessAlg::m_firstInputToolN {this, "FirstInputToolN", 1, "number of times to use event from first input tool"}
private

Definition at line 99 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGAClusterFilteredKey

SG::WriteHandleKey<FPGATrackSimClusterCollection> FPGATrackSimLogicalHitsProcessAlg::m_FPGAClusterFilteredKey {this, "FPGATrackSimClusterFilteredKey","FPGAClustersFiltered_1st","FPGATrackSim Filtered Clusters key"}
private

Definition at line 165 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGAClusterKey

SG::WriteHandleKeyArray<FPGATrackSimClusterCollection> FPGATrackSimLogicalHitsProcessAlg::m_FPGAClusterKey {this, "FPGATrackSimClusterKey",{"FPGAClusters_1st","FPGAClusters_2nd"},"FPGATrackSim Clusters key"}
private

Definition at line 164 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGAHitFilteredKey

SG::WriteHandleKey<FPGATrackSimHitCollection> FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitFilteredKey {this, "FPGATrackSimHitFiltered1stKey","FPGAHitsFiltered_1st","FPGATrackSim Filtered Hits 1st stage key"}
private

Definition at line 169 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGAHitInRoadsKey

SG::WriteHandleKey<FPGATrackSimHitContainer> FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitInRoadsKey {this, "FPGATrackSimHitInRoads1stKey","FPGAHitsInRoads_1st","FPGATrackSim Hits in 1st stage roads key"}
private

Definition at line 170 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGAHitKey

SG::WriteHandleKeyArray<FPGATrackSimHitCollection> FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitKey {this, "FPGATrackSimHitKey",{"FPGAHits_1st","FPGAHits_2nd"},"FPGATrackSim Hits key"}
private

Definition at line 167 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGAHitUnmappedKey

SG::WriteHandleKey<FPGATrackSimHitCollection> FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitUnmappedKey {this, "FPGATrackSimHitUnmappedKey","FPGAHitsUnmapped_1st","FPGATrackSim Unmapped Hits 1st stage key"}
private

Definition at line 168 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGARoadKey

SG::WriteHandleKey<FPGATrackSimRoadCollection> FPGATrackSimLogicalHitsProcessAlg::m_FPGARoadKey {this, "FPGATrackSimRoad1stKey","FPGARoads_1st","FPGATrackSim Roads 1st stage key"}
private

Definition at line 171 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGASpacePointsKey

SG::WriteHandleKeyArray<FPGATrackSimClusterCollection> FPGATrackSimLogicalHitsProcessAlg::m_FPGASpacePointsKey {this, "FPGATrackSimSpacePoints1stKey",{"FPGASpacePoints_1st","FPGASpacePoints_1st"},"FPGATrackSim SpacePoints key"}
private

Definition at line 166 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGATrackKey

SG::WriteHandleKey<FPGATrackSimTrackCollection> FPGATrackSimLogicalHitsProcessAlg::m_FPGATrackKey {this, "FPGATrackSimTrack1stKey","FPGATracks_1st","FPGATrackSim Tracks 1st stage key"}
private

Definition at line 172 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_FPGATrackSimMapping

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

Definition at line 95 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_hitFilteringTool

ToolHandle<IFPGATrackSimHitFilteringTool> FPGATrackSimLogicalHitsProcessAlg::m_hitFilteringTool {this, "HitFilteringTool", "FPGATrackSimHitFilteringTool/FPGATrackSimHitFilteringTool", "Hit Filtering Tool"}
private

Definition at line 78 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_hitInputTool

ToolHandle<IFPGATrackSimEventInputHeaderTool> FPGATrackSimLogicalHitsProcessAlg::m_hitInputTool {this, "InputTool", "FPGATrackSimSGToRawHitsTool/FPGATrackSimSGToRawHitsTool", "Input Tool"}
private

Definition at line 75 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_hitInputTool2

ToolHandle<FPGATrackSimReadRawRandomHitsTool> FPGATrackSimLogicalHitsProcessAlg::m_hitInputTool2 {this, "InputTool2", "FPGATrackSimReadRawRandomHitsTool/FPGATrackSimReadRawRandomHitsTool", "Potential 2nd input Tool to load data from more than one source"}
private

Definition at line 76 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_hitMapTool

ToolHandle<FPGATrackSimRawToLogicalHitsTool> FPGATrackSimLogicalHitsProcessAlg::m_hitMapTool {this, "RawToLogicalHitsTool", "FPGATrackSim_RawToLogicalHitsTool/FPGATrackSim_RawToLogicalHitsTool", "Raw To Logical Tool"}
private

Definition at line 77 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_hits_1st_miss

std::vector<FPGATrackSimHit> FPGATrackSimLogicalHitsProcessAlg::m_hits_1st_miss
private

Definition at line 130 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_hits_2nd_miss

std::vector<FPGATrackSimHit> FPGATrackSimLogicalHitsProcessAlg::m_hits_2nd_miss
private

Definition at line 130 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_hitSGInputTool

ToolHandle<IFPGATrackSimInputTool> FPGATrackSimLogicalHitsProcessAlg::m_hitSGInputTool {this, "SGInputTool", "", "Input tool from SG"}
private

Definition at line 74 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_houghRootOutputTool

ToolHandle<FPGATrackSimHoughRootOutputTool> FPGATrackSimLogicalHitsProcessAlg::m_houghRootOutputTool {this, "HoughRootOutputTool", "FPGATrackSimHoughRootOutputTool/FPGATrackSimHoughRootOutputTool", "Hough ROOT Output Tool"}
private

Definition at line 88 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_logicEventHeader_1st

FPGATrackSimLogicalEventInputHeader* FPGATrackSimLogicalHitsProcessAlg::m_logicEventHeader_1st = nullptr
private

Definition at line 123 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_logicEventHeader_2nd

FPGATrackSimLogicalEventInputHeader* FPGATrackSimLogicalHitsProcessAlg::m_logicEventHeader_2nd = nullptr
private

Definition at line 124 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_logicEventOutputHeader

FPGATrackSimLogicalEventOutputHeader* FPGATrackSimLogicalHitsProcessAlg::m_logicEventOutputHeader = nullptr
private

Definition at line 125 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_LRTRoadFilterTool

ToolHandle<FPGATrackSimLLPRoadFilterTool> FPGATrackSimLogicalHitsProcessAlg::m_LRTRoadFilterTool {this, "LRTRoadFilter", "FPGATrackSimLLPRoadFilterTool/FPGATrackSimLLPRoadFilterTool", "LRT Road Filter Tool"}
private

Definition at line 82 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_LRTRoadFinderTool

ToolHandle<IFPGATrackSimRoadFinderTool> FPGATrackSimLogicalHitsProcessAlg::m_LRTRoadFinderTool {this, "LRTRoadFinder", "FPGATrackSimHoughTransform_d0phi0_Tool/FPGATrackSimHoughTransform_d0phi0_Tool", "LRT Road Finder Tool"}
private

Definition at line 83 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_monTool

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

Definition at line 162 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_NNTrackTool

ToolHandle<FPGATrackSimNNTrackTool> FPGATrackSimLogicalHitsProcessAlg::m_NNTrackTool {this, "NNTrackTool", "FPGATrackSimNNTrackTool/FPGATrackSimNNTrackTool", "NN Track Tool"}
private

Definition at line 87 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_nRoadsFound

long FPGATrackSimLogicalHitsProcessAlg::m_nRoadsFound = 0
private

Definition at line 141 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_nRoadsTot

long FPGATrackSimLogicalHitsProcessAlg::m_nRoadsTot = 0
private

Definition at line 135 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_nTracksChi2Found

long FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2Found = 0
private

Definition at line 143 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_nTracksChi2OLRFound

long FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2OLRFound = 0
private

Definition at line 144 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_nTracksChi2OLRTot

long FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2OLRTot = 0
private

Definition at line 138 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_nTracksChi2Tot

long FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2Tot = 0
private

Definition at line 137 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_nTracksFound

long FPGATrackSimLogicalHitsProcessAlg::m_nTracksFound = 0
private

Definition at line 142 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_nTracksTot

long FPGATrackSimLogicalHitsProcessAlg::m_nTracksTot = 0
private

Definition at line 136 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_outputHitTxt

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_outputHitTxt {this, "outputHitTxt", false, "write out road hits to text file"}
private

Definition at line 114 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_outputHitTxtName

std::string FPGATrackSimLogicalHitsProcessAlg::m_outputHitTxtName = "outputRoadHits.txt"
private

Definition at line 117 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_outputHitTxtStream

std::ofstream FPGATrackSimLogicalHitsProcessAlg::m_outputHitTxtStream
private

Definition at line 118 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_overlapRemovalTool_1st

ToolHandle<FPGATrackSimOverlapRemovalTool> FPGATrackSimLogicalHitsProcessAlg::m_overlapRemovalTool_1st {this, "OverlapRemoval_1st", "FPGATrackSimOverlapRemovalTool/FPGATrackSimOverlapRemovalTool_1st", "1st stage overlap removal tool"}
private

Definition at line 91 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_overlapRemovalTool_2nd

ToolHandle<FPGATrackSimOverlapRemovalTool> FPGATrackSimLogicalHitsProcessAlg::m_overlapRemovalTool_2nd {this, "OverlapRemoval_2nd", "FPGATrackSimOverlapRemovalTool/FPGATrackSimOverlapRemovalTool_2nd", "2nd stage overlap removal tool"}
private

Definition at line 92 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_roadFilterTool

ToolHandle<IFPGATrackSimRoadFilterTool> FPGATrackSimLogicalHitsProcessAlg::m_roadFilterTool {this, "RoadFilter", "FPGATrackSimEtaPatternFilterTool", "Road Filter Tool"}
private

Definition at line 84 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_roadFilterTool2

ToolHandle<IFPGATrackSimRoadFilterTool> FPGATrackSimLogicalHitsProcessAlg::m_roadFilterTool2 {this, "RoadFilter2", "FPGATrackSimPhiRoadFilterTool", "Road Filter2 Tool"}
private

Definition at line 85 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_roadFinderTool

ToolHandle<IFPGATrackSimRoadFinderTool> FPGATrackSimLogicalHitsProcessAlg::m_roadFinderTool {this, "RoadFinder", "FPGATrackSimPatternMatchTool", "Road Finder Tool"}
private

Definition at line 81 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_runSecondStage

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_runSecondStage {this, "RunSecondStage", false, "flag to enable running the second stage fitting"}
private

Definition at line 108 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_secondInputToolN

Gaudi::Property<int> FPGATrackSimLogicalHitsProcessAlg::m_secondInputToolN {this, "SecondInputToolN", 0, "number of times to use event from second input tool"}
private

Definition at line 100 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_spacepoints_1st

std::vector<FPGATrackSimCluster> FPGATrackSimLogicalHitsProcessAlg::m_spacepoints_1st
private

Definition at line 129 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_spacepoints_2nd

std::vector<FPGATrackSimCluster> FPGATrackSimLogicalHitsProcessAlg::m_spacepoints_2nd
private

Definition at line 129 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_spacepointsTool

ToolHandle<FPGATrackSimSpacePointsToolI> FPGATrackSimLogicalHitsProcessAlg::m_spacepointsTool {this, "SpacePointTool", "FPGATrackSimSpacePointsTool/FPGATrackSimSpacePointsTool", "Space Points Tool"}
private

Definition at line 80 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_spRoadFilterTool

ToolHandle<IFPGATrackSimRoadFilterTool> FPGATrackSimLogicalHitsProcessAlg::m_spRoadFilterTool {this, "SPRoadFilterTool", "FPGATrackSimSpacepointRoadFilterTool", "Spacepoint Road Filter Tool"}
private

Definition at line 86 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_trackFitterTool_1st

ToolHandle<FPGATrackSimTrackFitterTool> FPGATrackSimLogicalHitsProcessAlg::m_trackFitterTool_1st {this, "TrackFitter_1st", "FPGATrackSimTrackFitterTool/FPGATrackSimTrackFitterTool_1st", "1st stage track fit tool"}
private

Definition at line 89 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_trackFitterTool_2nd

ToolHandle<FPGATrackSimTrackFitterTool> FPGATrackSimLogicalHitsProcessAlg::m_trackFitterTool_2nd {this, "TrackFitter_2nd", "FPGATrackSimTrackFitterTool/FPGATrackSimTrackFitterTool_2nd", "2nd stage track fit tool"}
private

Definition at line 90 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_tracks_1st_guessedcheck

std::vector<FPGATrackSimTrack> FPGATrackSimLogicalHitsProcessAlg::m_tracks_1st_guessedcheck
private

Definition at line 131 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_tracks_1st_nomiss

std::vector<FPGATrackSimTrack> FPGATrackSimLogicalHitsProcessAlg::m_tracks_1st_nomiss
private

Definition at line 131 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_tracks_2nd_guessedcheck

std::vector<FPGATrackSimTrack> FPGATrackSimLogicalHitsProcessAlg::m_tracks_2nd_guessedcheck
private

Definition at line 131 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_tracks_2nd_nomiss

std::vector<FPGATrackSimTrack> FPGATrackSimLogicalHitsProcessAlg::m_tracks_2nd_nomiss
private

Definition at line 131 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_writeOutputData

Gaudi::Property<bool> FPGATrackSimLogicalHitsProcessAlg::m_writeOutputData {this, "writeOutputData", true,"write the output TTree"}
private

Definition at line 113 of file FPGATrackSimLogicalHitsProcessAlg.h.

◆ m_writeOutputTool

ToolHandle<IFPGATrackSimEventOutputHeaderTool> FPGATrackSimLogicalHitsProcessAlg::m_writeOutputTool {this, "OutputTool", "FPGATrackSimOutputHeaderTool/FPGATrackSimOutputHeaderTool", "Output tool"}
private

Definition at line 94 of file FPGATrackSimLogicalHitsProcessAlg.h.

The documentation for this class was generated from the following files:
FPGATrackSimLogicalHitsProcessAlg::m_hits_2nd_miss
std::vector< FPGATrackSimHit > m_hits_2nd_miss
Definition: FPGATrackSimLogicalHitsProcessAlg.h:130
FPGATrackSimLogicalHitsProcessAlg::m_doSpacepoints
Gaudi::Property< bool > m_doSpacepoints
Definition: FPGATrackSimLogicalHitsProcessAlg.h:103
FPGATrackSimLogicalHitsProcessAlg::m_filterRoads
Gaudi::Property< bool > m_filterRoads
Definition: FPGATrackSimLogicalHitsProcessAlg.h:106
FPGATrackSimLogicalHitsProcessAlg::m_clusters_2nd
std::vector< FPGATrackSimCluster > m_clusters_2nd
Definition: FPGATrackSimLogicalHitsProcessAlg.h:128
FPGATrackSimLogicalHitsProcessAlg::m_logicEventHeader_1st
FPGATrackSimLogicalEventInputHeader * m_logicEventHeader_1st
Definition: FPGATrackSimLogicalHitsProcessAlg.h:123
FPGATrackSimLogicalHitsProcessAlg::m_doEvtSel
Gaudi::Property< bool > m_doEvtSel
Definition: FPGATrackSimLogicalHitsProcessAlg.h:115
beamspotman.r
def r
Definition: beamspotman.py:676
FPGATrackSimLogicalHitsProcessAlg::m_outputHitTxtName
std::string m_outputHitTxtName
Definition: FPGATrackSimLogicalHitsProcessAlg.h:117
checkFileSG.line
line
Definition: checkFileSG.py:75
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
FPGATrackSimOptionalEventInfo::getOfflineTracks
const std::vector< FPGATrackSimOfflineTrack > & getOfflineTracks() const
Definition: FPGATrackSimOptionalEventInfo.h:32
FPGATrackSimLogicalHitsProcessAlg::m_LRTRoadFinderTool
ToolHandle< IFPGATrackSimRoadFinderTool > m_LRTRoadFinderTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:83
FPGATrackSimLogicalHitsProcessAlg::m_FPGAClusterKey
SG::WriteHandleKeyArray< FPGATrackSimClusterCollection > m_FPGAClusterKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:164
FPGATrackSimCluster::getHitList
hitVector const & getHitList() const
Definition: FPGATrackSimCluster.h:30
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
FPGATrackSimLogicalHitsProcessAlg::m_spacepointsTool
ToolHandle< FPGATrackSimSpacePointsToolI > m_spacepointsTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:80
FPGATrackSimLogicalHitsProcessAlg::m_description
std::string m_description
Definition: FPGATrackSimLogicalHitsProcessAlg.h:70
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
FPGATrackSimLogicalHitsProcessAlg::m_logicEventOutputHeader
FPGATrackSimLogicalEventOutputHeader * m_logicEventOutputHeader
Definition: FPGATrackSimLogicalHitsProcessAlg.h:125
FPGATrackSimLogicalHitsProcessAlg::m_FPGARoadKey
SG::WriteHandleKey< FPGATrackSimRoadCollection > m_FPGARoadKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:171
FPGATrackSimLogicalHitsProcessAlg::m_secondInputToolN
Gaudi::Property< int > m_secondInputToolN
Definition: FPGATrackSimLogicalHitsProcessAlg.h:100
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FPGATrackSimLogicalHitsProcessAlg::m_nTracksTot
long m_nTracksTot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:136
FPGATrackSimCluster
Definition: FPGATrackSimCluster.h:25
FPGATrackSimLogicalHitsProcessAlg::m_hits_1st_miss
std::vector< FPGATrackSimHit > m_hits_1st_miss
Definition: FPGATrackSimLogicalHitsProcessAlg.h:130
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitInRoadsKey
SG::WriteHandleKey< FPGATrackSimHitContainer > m_FPGAHitInRoadsKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:170
FPGATrackSimTrack
Definition: FPGATrackSimTrack.h:16
FPGATrackSimLogicalHitsProcessAlg::writeOutputData
StatusCode writeOutputData(std::vector< FPGATrackSimRoad * > const &roads_1st, std::vector< FPGATrackSimTrack > const &tracks_1st, std::vector< FPGATrackSimRoad * > const &roads_2nd, std::vector< FPGATrackSimTrack > const &tracks_2nd, FPGATrackSimDataFlowInfo const *dataFlowInfo)
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:642
FPGATrackSimLogicalHitsProcessAlg::m_spacepoints_1st
std::vector< FPGATrackSimCluster > m_spacepoints_1st
Definition: FPGATrackSimLogicalHitsProcessAlg.h:129
FPGATrackSimLogicalHitsProcessAlg::m_spacepoints_2nd
std::vector< FPGATrackSimCluster > m_spacepoints_2nd
Definition: FPGATrackSimLogicalHitsProcessAlg.h:129
FPGATrackSimLogicalHitsProcessAlg::m_dataFlowTool
ToolHandle< FPGATrackSimDataFlowTool > m_dataFlowTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:93
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
FPGATrackSimLogicalEventOutputHeader::reserveFPGATrackSimRoads_1st
void reserveFPGATrackSimRoads_1st(size_t size)
Definition: FPGATrackSimLogicalEventOutputHeader.h:23
FPGATrackSimLogicalHitsProcessAlg::m_LRTRoadFilterTool
ToolHandle< FPGATrackSimLLPRoadFilterTool > m_LRTRoadFilterTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:82
FPGATrackSimLogicalHitsProcessAlg::m_writeOutputTool
ToolHandle< IFPGATrackSimEventOutputHeaderTool > m_writeOutputTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:94
FPGATrackSimLogicalHitsProcessAlg::m_doTracking
Gaudi::Property< bool > m_doTracking
Definition: FPGATrackSimLogicalHitsProcessAlg.h:104
FPGATrackSimLogicalHitsProcessAlg::m_hitMapTool
ToolHandle< FPGATrackSimRawToLogicalHitsTool > m_hitMapTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:77
FPGATrackSimLogicalHitsProcessAlg::m_clusters_1st_original
std::vector< FPGATrackSimCluster > m_clusters_1st_original
Definition: FPGATrackSimLogicalHitsProcessAlg.h:128
FPGATrackSimLogicalHitsProcessAlg::m_clusters_1st
std::vector< FPGATrackSimCluster > m_clusters_1st
Definition: FPGATrackSimLogicalHitsProcessAlg.h:128
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
FPGATrackSimLogicalHitsProcessAlg::m_evtSel
ServiceHandle< IFPGATrackSimEventSelectionSvc > m_evtSel
Definition: FPGATrackSimLogicalHitsProcessAlg.h:96
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
FPGATrackSimLogicalEventOutputHeader::reset
void reset()
Definition: FPGATrackSimLogicalEventOutputHeader.cxx:13
FPGATrackSimLogicalHitsProcessAlg::m_writeOutputData
Gaudi::Property< bool > m_writeOutputData
Definition: FPGATrackSimLogicalHitsProcessAlg.h:113
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
FPGATrackSimLogicalHitsProcessAlg::m_overlapRemovalTool_1st
ToolHandle< FPGATrackSimOverlapRemovalTool > m_overlapRemovalTool_1st
Definition: FPGATrackSimLogicalHitsProcessAlg.h:91
FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitKey
SG::WriteHandleKeyArray< FPGATrackSimHitCollection > m_FPGAHitKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:167
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
FPGATrackSimLogicalHitsProcessAlg::m_hitInputTool2
ToolHandle< FPGATrackSimReadRawRandomHitsTool > m_hitInputTool2
Definition: FPGATrackSimLogicalHitsProcessAlg.h:76
FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitFilteredKey
SG::WriteHandleKey< FPGATrackSimHitCollection > m_FPGAHitFilteredKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:169
FPGATrackSimLogicalHitsProcessAlg::m_doNNTrack
Gaudi::Property< bool > m_doNNTrack
Definition: FPGATrackSimLogicalHitsProcessAlg.h:110
FPGATrackSimLogicalHitsProcessAlg::m_FPGATrackKey
SG::WriteHandleKey< FPGATrackSimTrackCollection > m_FPGATrackKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:172
FPGATrackSimLogicalHitsProcessAlg::m_evt_truth
double m_evt_truth
Definition: FPGATrackSimLogicalHitsProcessAlg.h:140
xAOD::unsigned
unsigned
Definition: RingSetConf_v1.cxx:662
FPGATrackSimLogicalHitsProcessAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:162
FPGATrackSimLogicalEventOutputHeader::getDataFlowInfo
FPGATrackSimDataFlowInfo const & getDataFlowInfo() const
Definition: FPGATrackSimLogicalEventOutputHeader.h:45
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
FPGATrackSimOptionalEventInfo::getTruthTracks
const std::vector< FPGATrackSimTruthTrack > & getTruthTracks() const
Definition: FPGATrackSimOptionalEventInfo.h:37
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
FPGATrackSimHit
Definition: FPGATrackSimHit.h:38
FPGATrackSimLogicalHitsProcessAlg::m_doHoughRootOutput
Gaudi::Property< bool > m_doHoughRootOutput
Definition: FPGATrackSimLogicalHitsProcessAlg.h:109
FPGATrackSimHit::getGPhi
float getGPhi() const
Definition: FPGATrackSimHit.h:129
FPGATrackSimLogicalHitsProcessAlg::m_evt
double m_evt
Definition: FPGATrackSimLogicalHitsProcessAlg.h:134
FPGATrackSimEventInputHeader::nHits
int nHits() const
Definition: FPGATrackSimEventInputHeader.h:37
FPGATrackSimLogicalHitsProcessAlg::m_doLRTHitFiltering
Gaudi::Property< bool > m_doLRTHitFiltering
Definition: FPGATrackSimLogicalHitsProcessAlg.h:112
FPGATrackSimLogicalHitsProcessAlg::m_logicEventHeader_2nd
FPGATrackSimLogicalEventInputHeader * m_logicEventHeader_2nd
Definition: FPGATrackSimLogicalHitsProcessAlg.h:124
FPGATrackSimLogicalHitsProcessAlg::m_doHitFiltering
Gaudi::Property< bool > m_doHitFiltering
Definition: FPGATrackSimLogicalHitsProcessAlg.h:101
FPGATrackSimLogicalHitsProcessAlg::m_firstInputToolN
Gaudi::Property< int > m_firstInputToolN
Definition: FPGATrackSimLogicalHitsProcessAlg.h:99
FPGATrackSimLogicalHitsProcessAlg::m_overlapRemovalTool_2nd
ToolHandle< FPGATrackSimOverlapRemovalTool > m_overlapRemovalTool_2nd
Definition: FPGATrackSimLogicalHitsProcessAlg.h:92
FPGATrackSimLogicalHitsProcessAlg::m_runSecondStage
Gaudi::Property< bool > m_runSecondStage
Definition: FPGATrackSimLogicalHitsProcessAlg.h:108
FPGATrackSimLogicalHitsProcessAlg::m_roadFilterTool2
ToolHandle< IFPGATrackSimRoadFilterTool > m_roadFilterTool2
Definition: FPGATrackSimLogicalHitsProcessAlg.h:85
FPGATrackSimLogicalHitsProcessAlg::m_outputHitTxt
Gaudi::Property< bool > m_outputHitTxt
Definition: FPGATrackSimLogicalHitsProcessAlg.h:114
Hit
Definition: Simulation/ISF/ISF_FastCaloSim/ISF_FastCaloGpu/ISF_FastCaloGpu/Hit.h:16
FPGATrackSimLogicalEventInputHeader::optional
FPGATrackSimOptionalEventInfo const & optional() const
Definition: FPGATrackSimLogicalEventInputHeader.h:32
FPGATrackSimLogicalEventOutputHeader::addFPGATrackSimTracks_2nd
void addFPGATrackSimTracks_2nd(std::vector< FPGATrackSimTrack > const &tracks_2nd)
Definition: FPGATrackSimLogicalEventOutputHeader.h:42
python.handimod.now
now
Definition: handimod.py:675
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
FPGATrackSimLogicalHitsProcessAlg::m_FPGASpacePointsKey
SG::WriteHandleKeyArray< FPGATrackSimClusterCollection > m_FPGASpacePointsKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:166
FPGATrackSimLogicalEventOutputHeader::reserveFPGATrackSimTracks_1st
void reserveFPGATrackSimTracks_1st(size_t size)
Definition: FPGATrackSimLogicalEventOutputHeader.h:35
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:92
FPGATrackSimLogicalHitsProcessAlg::m_roadFinderTool
ToolHandle< IFPGATrackSimRoadFinderTool > m_roadFinderTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:81
FPGATrackSimLogicalHitsProcessAlg::m_firstInputHeader
FPGATrackSimEventInputHeader m_firstInputHeader
Definition: FPGATrackSimLogicalHitsProcessAlg.h:122
FPGATrackSimLogicalHitsProcessAlg::m_ev
int m_ev
Definition: FPGATrackSimLogicalHitsProcessAlg.h:71
FPGATrackSimEventInputHeader::clearHits
void clearHits()
Definition: FPGATrackSimEventInputHeader.h:39
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArG4ShowerLibProcessing.hits
hits
Definition: LArG4ShowerLibProcessing.py:136
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
FPGATrackSimLogicalHitsProcessAlg::m_FPGAHitUnmappedKey
SG::WriteHandleKey< FPGATrackSimHitCollection > m_FPGAHitUnmappedKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:168
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimNNMap
Definition: FPGATrackSimNNMap.h:27
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
FPGATrackSimLogicalHitsProcessAlg::m_clusteringTool
ToolHandle< FPGATrackSimClusteringToolI > m_clusteringTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:79
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
FPGATrackSimLogicalEventOutputHeader::setDataFlowInfo
void setDataFlowInfo(FPGATrackSimDataFlowInfo const &info)
Definition: FPGATrackSimLogicalEventOutputHeader.h:46
FPGATrackSimLogicalEventInputHeader::reset
void reset()
FPGATrackSimLogicalHitsProcessAlg::m_clustering
Gaudi::Property< bool > m_clustering
Definition: FPGATrackSimLogicalHitsProcessAlg.h:102
FPGATrackSimLogicalHitsProcessAlg::m_nTracksFound
long m_nTracksFound
Definition: FPGATrackSimLogicalHitsProcessAlg.h:142
FPGATrackSimHit::getZ
float getZ() const
Definition: FPGATrackSimHit.h:127
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
FPGATrackSimPlaneMap
Definition: FPGATrackSimPlaneMap.h:62
FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2Tot
long m_nTracksChi2Tot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:137
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2OLRFound
long m_nTracksChi2OLRFound
Definition: FPGATrackSimLogicalHitsProcessAlg.h:144
FPGATrackSimLogicalHitsProcessAlg::readInputs
StatusCode readInputs(bool &done)
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:478
FPGATrackSimLogicalHitsProcessAlg::m_eventHeader
FPGATrackSimEventInputHeader m_eventHeader
Definition: FPGATrackSimLogicalHitsProcessAlg.h:121
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
FPGATrackSimCluster::getClusterEquiv
FPGATrackSimHit const & getClusterEquiv() const
Definition: FPGATrackSimCluster.h:31
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
FPGATrackSimLogicalHitsProcessAlg::m_spRoadFilterTool
ToolHandle< IFPGATrackSimRoadFilterTool > m_spRoadFilterTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:86
FPGATrackSimLogicalEventOutputHeader::addFPGATrackSimTracks_1st
void addFPGATrackSimTracks_1st(std::vector< FPGATrackSimTrack > const &tracks_1st)
Definition: FPGATrackSimLogicalEventOutputHeader.h:36
TIME
#define TIME(name)
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:36
FPGATrackSimLogicalHitsProcessAlg::processInputs
StatusCode processInputs(SG::WriteHandle< FPGATrackSimHitCollection > &FPGAHitUnmapped_1st, SG::WriteHandle< FPGATrackSimClusterCollection > &FPGAClusters_1st, SG::WriteHandle< FPGATrackSimClusterCollection > &FPGAClustersFiltered_1st, SG::WriteHandle< FPGATrackSimClusterCollection > &FPGASpacePoints_1st)
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:519
FPGATrackSimLogicalHitsProcessAlg::m_hitFilteringTool
ToolHandle< IFPGATrackSimHitFilteringTool > m_hitFilteringTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:78
FPGATrackSimLogicalHitsProcessAlg::m_trackFitterTool_1st
ToolHandle< FPGATrackSimTrackFitterTool > m_trackFitterTool_1st
Definition: FPGATrackSimLogicalHitsProcessAlg.h:89
FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2Found
long m_nTracksChi2Found
Definition: FPGATrackSimLogicalHitsProcessAlg.h:143
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
FPGATrackSimLogicalHitsProcessAlg::m_nRoadsTot
long m_nRoadsTot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:135
FPGATrackSimLogicalHitsProcessAlg::m_hitSGInputTool
ToolHandle< IFPGATrackSimInputTool > m_hitSGInputTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:74
FPGATrackSimLogicalHitsProcessAlg::m_nTracksChi2OLRTot
long m_nTracksChi2OLRTot
Definition: FPGATrackSimLogicalHitsProcessAlg.h:138
FPGATrackSimHit::getR
float getR() const
Definition: FPGATrackSimHit.h:128
FPGATrackSimLogicalEventOutputHeader::reserveFPGATrackSimTracks_2nd
void reserveFPGATrackSimTracks_2nd(size_t size)
Definition: FPGATrackSimLogicalEventOutputHeader.h:41
a
TList * a
Definition: liststreamerinfos.cxx:10
h
FPGATrackSimLogicalHitsProcessAlg::m_roadFilterTool
ToolHandle< IFPGATrackSimRoadFilterTool > m_roadFilterTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:84
FPGATrackSimLogicalHitsProcessAlg::secondStageProcessing
StatusCode secondStageProcessing(std::vector< FPGATrackSimTrack > const &tracks_1st, std::vector< FPGATrackSimRoad * > &roads_2nd, std::vector< FPGATrackSimTrack > &tracks_2nd)
Definition: FPGATrackSimLogicalHitsProcessAlg.cxx:582
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
FPGATrackSimLogicalHitsProcessAlg::m_trackFitterTool_2nd
ToolHandle< FPGATrackSimTrackFitterTool > m_trackFitterTool_2nd
Definition: FPGATrackSimLogicalHitsProcessAlg.h:90
FPGATrackSimLogicalHitsProcessAlg::m_outputHitTxtStream
std::ofstream m_outputHitTxtStream
Definition: FPGATrackSimLogicalHitsProcessAlg.h:118
FPGATrackSimLogicalHitsProcessAlg::m_doLRT
Gaudi::Property< bool > m_doLRT
Definition: FPGATrackSimLogicalHitsProcessAlg.h:111
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
FPGATrackSimLogicalEventInputHeader::towers
const std::vector< FPGATrackSimTowerInputHeader > & towers() const
Definition: FPGATrackSimLogicalEventInputHeader.h:36
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
FPGATrackSimLogicalHitsProcessAlg::m_FPGAClusterFilteredKey
SG::WriteHandleKey< FPGATrackSimClusterCollection > m_FPGAClusterFilteredKey
Definition: FPGATrackSimLogicalHitsProcessAlg.h:165
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
FPGATrackSimLogicalHitsProcessAlg::m_nRoadsFound
long m_nRoadsFound
Definition: FPGATrackSimLogicalHitsProcessAlg.h:141
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
FPGATrackSimLogicalEventOutputHeader::reserveFPGATrackSimRoads_2nd
void reserveFPGATrackSimRoads_2nd(size_t size)
Definition: FPGATrackSimLogicalEventOutputHeader.h:29
FPGATrackSimLogicalEventOutputHeader::addFPGATrackSimRoads_2nd
void addFPGATrackSimRoads_2nd(std::vector< FPGATrackSimRoad * > const &roads_2nd)
Definition: FPGATrackSimLogicalEventOutputHeader.h:30
FPGATrackSimLogicalHitsProcessAlg::m_filterRoads2
Gaudi::Property< bool > m_filterRoads2
Definition: FPGATrackSimLogicalHitsProcessAlg.h:107
FPGATrackSimEventInputHeader::reset
void reset()
Definition: FPGATrackSimEventInputHeader.cxx:15
FPGATrackSimLogicalHitsProcessAlg::m_NNTrackTool
ToolHandle< FPGATrackSimNNTrackTool > m_NNTrackTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:87
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
FPGATrackSimLogicalHitsProcessAlg::m_houghRootOutputTool
ToolHandle< FPGATrackSimHoughRootOutputTool > m_houghRootOutputTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:88
FPGATrackSimRoad
Definition: FPGATrackSimRoad.h:29
fitman.k
k
Definition: fitman.py:528
FPGATrackSimLogicalEventOutputHeader::addFPGATrackSimRoads_1st
void addFPGATrackSimRoads_1st(std::vector< FPGATrackSimRoad * > const &roads_1st)
Definition: FPGATrackSimLogicalEventOutputHeader.h:24
FPGATrackSimLogicalHitsProcessAlg::m_FPGATrackSimMapping
ServiceHandle< IFPGATrackSimMappingSvc > m_FPGATrackSimMapping
Definition: FPGATrackSimLogicalHitsProcessAlg.h:95
ServiceHandle< ICondSvc >
FPGATrackSimLogicalHitsProcessAlg::m_hitInputTool
ToolHandle< IFPGATrackSimEventInputHeaderTool > m_hitInputTool
Definition: FPGATrackSimLogicalHitsProcessAlg.h:75
Generated on Thu Jul 4 2024 21:45:42 for ATLAS Offline Software by   doxygen 1.8.18