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

#include <FPGATrackSimSecondStageAlg.h>

Inheritance diagram for FPGATrackSimSecondStageAlg:
Collaboration diagram for FPGATrackSimSecondStageAlg:

Public Member Functions

 FPGATrackSimSecondStageAlg (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~FPGATrackSimSecondStageAlg ()=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, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode writeOutputData (const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads_2nd, std::vector< FPGATrackSimTrack > const &tracks_2nd, FPGATrackSimDataFlowInfo const *dataFlowInfo)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::string m_description
 
ToolHandle< IFPGATrackSimTrackExtensionToolm_trackExtensionTool {this, "TrackExtensionTool", "FPGATrackSimTrackExtensionTool", "Track extensoin tool"}
 
ToolHandle< FPGATrackSimHoughRootOutputToolm_houghRootOutputTool {this, "HoughRootOutputTool", "FPGATrackSimHoughRootOutputTool/FPGATrackSimHoughRootOutputTool", "Hough ROOT Output Tool"}
 
ToolHandle< FPGATrackSimNNTrackToolm_NNTrackTool {this, "NNTrackTool", "FPGATrackSimNNTrackTool/FPGATrackSimNNTrackTool_2nd", "NN Track Tool"}
 
ToolHandle< FPGATrackSimTrackFitterToolm_trackFitterTool {this, "TrackFitter_2nd", "FPGATrackSimTrackFitterTool/FPGATrackSimTrackFitterTool_2nd", "2nd stage track fit tool"}
 
ToolHandle< FPGATrackSimOverlapRemovalToolm_overlapRemovalTool {this, "OverlapRemoval_2nd", "FPGATrackSimOverlapRemovalTool/FPGATrackSimOverlapRemovalTool_2nd", "2nd stage overlap removal tool"}
 
ToolHandle< FPGATrackSimOutputHeaderToolm_writeOutputTool {this, "OutputTool", "FPGATrackSimOutputHeaderTool/FPGATrackSimOutputHeaderTool", "Output tool"}
 
ServiceHandle< IFPGATrackSimMappingSvcm_FPGATrackSimMapping {this, "FPGATrackSimMapping", "FPGATrackSimMappingSvc", "FPGATrackSimMappingSvc"}
 
ServiceHandle< IFPGATrackSimEventSelectionSvcm_evtSel {this, "eventSelector", "", "Event selection Svc"}
 
ServiceHandle< IChronoStatSvc > m_chrono {this,"ChronoStatSvc","ChronoStatSvc"}
 
Gaudi::Property< int > m_SetTruthParametersForTracks {this, "SetTruthParametersForTracks", -1, "flag to override track parameters and set them to the truth values"}
 
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_doHoughRootOutput2nd {this, "DoHoughRootOutput2nd", false, "Dump output from the Hough Transform to flat ntuples"}
 
Gaudi::Property< bool > m_doNNTrack_2nd {this, "DoNNTrack_2nd", false, "Run NN track filtering for 2nd Stage"}
 
Gaudi::Property< bool > m_writeOutputData {this, "writeOutputData", true,"write the output TTree"}
 
Gaudi::Property< float > m_trackScoreCut {this, "TrackScoreCut", 25.0, "Minimum track score (e.g. chi2 or NN)." }
 
Gaudi::Property< bool > m_writeOutNonSPStripHits {this, "writeOutNonSPStripHits", true, "Write tracks to RootOutput if they have strip hits which are not SPs"}
 
Gaudi::Property< int > m_NumOfHitPerGrouping { this, "NumOfHitPerGrouping", 5, "Number of minimum overlapping hits for a track candidate to be removed in the HoughRootOutputTool"}
 
Gaudi::Property< bool > m_passLowestChi2TrackOnly {this, "passLowestChi2TrackOnly", false}
 
Gaudi::Property< bool > m_doNNPathFinder {this, "doNNPathFinder", 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< std::string > m_sliceBranch {this, "SliceBranchName", "LogicalEventSlicedHeader", "Name of the branch for slied hits in output ROOT file." }
 
Gaudi::Property< std::string > m_outputBranch {this, "outputBranchName", "LogicalEventOutputHeader", "Name of the branch for output data in output ROOT file." }
 
FPGATrackSimLogicalEventInputHeaderm_slicedHitHeader = nullptr
 
FPGATrackSimLogicalEventOutputHeaderm_logicEventOutputHeader = nullptr
 
long m_evt = 0
 
long m_nRoadsTot = 0
 
long m_nTracksTot = 0
 
long m_nTracksChi2Tot = 0
 
long m_nTracksChi2OLRTot = 0
 
long m_evt_truth = 0
 
long m_nRoadsFound = 0
 
long m_nTracksFound = 0
 
long m_nTracksChi2Found = 0
 
long m_nTracksChi2OLRFound = 0
 
unsigned long m_maxNRoadsFound = 0
 
unsigned long m_maxNTracksTot = 0
 
unsigned long m_maxNTracksChi2Tot = 0
 
unsigned long m_maxNTracksChi2OLRTot = 0
 
ToolHandle< GenericMonitoringToolm_monTool {this,"MonTool", "", "Monitoring tool"}
 
SG::ReadHandleKey< FPGATrackSimHitCollectionm_FPGAHitKey {this, "FPGATrackSimHitKey", "FPGAHits_2nd", "FPGATrackSim Hits key"}
 
SG::ReadHandleKey< FPGATrackSimTrackCollectionm_FPGAInputTrackKey {this, "FPGATrackSimTrack1stKey", "FPGATracks_1st", "FPGATrackSim tracks 1st stage key"}
 
SG::WriteHandleKey< FPGATrackSimHitContainerm_FPGAHitInRoadsKey {this, "FPGATrackSimHitInRoads2ndKey","FPGAHitsInRoads_2nd","FPGATrackSim Hits in 1st stage roads key"}
 
SG::WriteHandleKey< FPGATrackSimRoadCollectionm_FPGARoadKey {this, "FPGATrackSimRoad2ndKey","FPGARoads_2nd","FPGATrackSim Roads 2nd stage key"}
 
SG::WriteHandleKey< FPGATrackSimTrackCollectionm_FPGATrackKey {this, "FPGATrackSimTrack2ndKey","FPGATracks_2nd","FPGATrackSim Tracks 2nd stage key"}
 
SG::ReadHandleKey< FPGATrackSimTruthTrackCollectionm_FPGATruthTrackKey {this, "FPGATrackSimTruthTrackKey", "FPGATruthTracks", "FPGATrackSim truth tracks"}
 
SG::ReadHandleKey< FPGATrackSimOfflineTrackCollectionm_FPGAOfflineTrackKey {this, "FPGATrackSimOfflineTrackKey", "FPGAOfflineTracks", "FPGATrackSim offline tracks"}
 
SG::ReadHandleKey< FPGATrackSimEventInfom_FPGAEventInfoKey {this, "FPGATrackSimEventInfoKey", "FPGAEventInfo", "FPGATrackSim event info"}
 
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 46 of file FPGATrackSimSecondStageAlg.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

◆ FPGATrackSimSecondStageAlg()

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

Definition at line 43 of file FPGATrackSimSecondStageAlg.cxx.

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

◆ ~FPGATrackSimSecondStageAlg()

virtual FPGATrackSimSecondStageAlg::~FPGATrackSimSecondStageAlg ( )
virtualdefault

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< 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, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< 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 FPGATrackSimSecondStageAlg::execute ( )
overridevirtual

Definition at line 103 of file FPGATrackSimSecondStageAlg.cxx.

104 {
105  const EventContext& ctx = getContext();
106  // Get reference to hits from StoreGate.
107  // Hits have been procesed by the DataPrep algorithm. Now, we need to read them.
108  // If they aren't passed, assume this means we are done.
110  if (!FPGAHits.isValid()) {
111  if (m_evt == 0) {
112  ATH_MSG_WARNING("Didn't receive FPGAHits_2nd on first event; assuming no input events.");
113  }
114  SmartIF<IEventProcessor> appMgr{service("ApplicationMgr")};
115  if (!appMgr) {
116  ATH_MSG_ERROR("Failed to retrieve ApplicationMgr as IEventProcessor");
117  return StatusCode::FAILURE;
118  }
119  return appMgr->stopRun();
120  }
121 
123  if (!FPGAInputTracks.isValid()) {
124  SmartIF<IEventProcessor> appMgr{service("ApplicationMgr")};
125  if (!appMgr) {
126  ATH_MSG_ERROR("Failed to retrieve ApplicationMgr as IEventProcessor");
127  return StatusCode::FAILURE;
128  }
129  return appMgr->stopRun();
130  }
131 
132  // Set up write handles.
135 
136  ATH_CHECK( FPGARoads_2nd.record (std::make_unique<FPGATrackSimRoadCollection>()));
137  ATH_CHECK( FPGAHitsInRoads_2nd.record (std::make_unique<FPGATrackSimHitContainer>()));
138 
140  ATH_CHECK(FPGATracks_2ndHandle.record (std::make_unique<FPGATrackSimTrackCollection>()));
141  if constexpr (enableBenchmark) m_chrono->chronoStart("2nd Stage: EventSelection");
142  // Query the event selection service to make sure this event passed cuts.
143  if (!m_evtSel->getSelectedEvent()) {
144  ATH_MSG_DEBUG("Event skipped by: " << m_evtSel->name());
145  return StatusCode::SUCCESS;
146  }
147 
148  // Event passes cuts, count it. technically, DataPrep does this now.
149  m_evt++;
150  if constexpr (enableBenchmark) m_chrono->chronoStop("2nd Stage: EventSelection");
151 
152  // If we get here, FPGAHits_2nd is valid, copy it over.
153  std::vector<std::shared_ptr<const FPGATrackSimHit>> phits_2nd;
154  phits_2nd.reserve(FPGAHits->size());
155  for (const auto& hit : *FPGAHits) {
156  phits_2nd.push_back(std::make_shared<const FPGATrackSimHit>(hit));
157  }
158 
159  std::vector<std::shared_ptr<const FPGATrackSimTrack>> tracks_1st;
160  tracks_1st.reserve(FPGAInputTracks->size());
161  for (const auto& track : *FPGAInputTracks) {
162  tracks_1st.push_back(std::make_shared<const FPGATrackSimTrack>(track));
163  }
164  ATH_MSG_DEBUG("Retrieved " << phits_2nd.size() << " hits and " << tracks_1st.size() << " tracks from storegate");
165 
166  // Get truth tracks from DataPrep as well.
168  if (!FPGATruthTracks.isValid()) {
169  ATH_MSG_ERROR("Could not find FPGA Truth Track Collection with key " << FPGATruthTracks.key());
170  return StatusCode::FAILURE;
171  }
172 
173  // Same for offline tracks.
175  if (!FPGAOfflineTracks.isValid()) {
176  ATH_MSG_ERROR("Could not find FPGA Offline Track Collection with key " << FPGAOfflineTracks.key());
177  return StatusCode::FAILURE;
178  }
179 
180  // Same for event info structure. all we need this for is to propagate to our event info structures.
182  if (!FPGAEventInfo.isValid()) {
183  ATH_MSG_ERROR("Could not find FPGA Event Info with key " << FPGAEventInfo.key());
184  return StatusCode::FAILURE;
185  }
186  FPGATrackSimEventInfo eventInfo = *FPGAEventInfo.cptr();
187  m_slicedHitHeader->newEvent(eventInfo);
188 
189  // Get second stage roads from tracks.
190  std::vector<std::shared_ptr<const FPGATrackSimRoad>> prefilter_roads;
191  std::vector<std::shared_ptr<const FPGATrackSimRoad>> roads = std::move(prefilter_roads);
192 
193  if constexpr (enableBenchmark) m_chrono->chronoStart("2nd Stage: TrackExtension");
194  // Use the track extension tool to actually produce a new set of roads.
195  ATH_CHECK(m_trackExtensionTool->extendTracks(phits_2nd, tracks_1st, roads));
196 
197  for (auto const &road : roads) {
198  std::vector<FPGATrackSimHit> road_hits;
199  ATH_MSG_DEBUG("Hough Road X Y: " << road->getX() << " " << road->getY());
200  for (size_t l = 0; l < road->getNLayers(); ++l) {
201  for (const auto &layerH : road->getHits(l)) {
202  road_hits.push_back(*layerH);
203  }
204  }
205  FPGAHitsInRoads_2nd->push_back(road_hits);
206  FPGARoads_2nd->push_back(*road);
207  }
208 
209  if constexpr (enableBenchmark) m_chrono->chronoStop("2nd Stage: TrackExtension");
210  auto mon_nroads = Monitored::Scalar<unsigned>("nroads_2nd", roads.size());
211  unsigned bitmask_best(0);
212  unsigned nhit_best(0);
213  for (auto const &road : roads) {
214  unsigned bitmask = road->getHitLayers();
215  if (road->getNHitLayers() > nhit_best) {
216  nhit_best = road->getNHitLayers();
217  bitmask_best = bitmask;
218  }
219  for (size_t l = 0; l < m_FPGATrackSimMapping->PlaneMap_2nd(0)->getNLogiLayers(); l++) {
220  if (bitmask & (1 << l)) {
221  auto mon_layerIDs = Monitored::Scalar<unsigned>("layerIDs_2nd",l);
222  Monitored::Group(m_monTool,mon_layerIDs);
223  }
224  }
225  }
226 
227  for (size_t l = 0; l < m_FPGATrackSimMapping->PlaneMap_2nd(0)->getNLogiLayers(); l++) {
228  if (bitmask_best & (1 << l)) {
229  auto mon_layerIDs_best = Monitored::Scalar<unsigned>("layerIDs_2nd_best",l);
230  Monitored::Group(m_monTool,mon_layerIDs_best);
231  }
232  }
233  Monitored::Group(m_monTool, mon_nroads);
234 
235  // NOTE: for now we don't support road filtering again in the second stage.
236  auto mon_nroads_postfilter = Monitored::Scalar<unsigned>("nroads_2nd_postfilter", roads.size());
237  Monitored::Group(m_monTool, mon_nroads_postfilter);
238 
239  // Get tracks, again, after extrapolation.
240  // All of this code is effectively copied from LogicalHitsProcessAlg, except we use 2nd stage now.
241  if constexpr (enableBenchmark) m_chrono->chronoStart("2nd Stage: Track Extraction");
242  std::vector<FPGATrackSimTrack> tracks;
243  if (m_doTracking) {
244  if (m_doNNTrack_2nd) {
245  ATH_MSG_DEBUG("Performing NN tracking");
246  ATH_CHECK(m_NNTrackTool->getTracks_2nd(roads, tracks));
247  } else {
248  ATH_MSG_DEBUG("Performing Linear tracking");
249 
250  if (m_passLowestChi2TrackOnly) { // Pass only the lowest chi2 track per road
251  std::vector<FPGATrackSimTrack> filteredTracks;
252 
253  for (const auto& road : roads) {
254  // Collect tracks for the current road
255  std::vector<FPGATrackSimTrack> tracksForCurrentRoad;
256  std::vector<std::shared_ptr<const FPGATrackSimRoad>> roadVec = {road};
257  ATH_CHECK(m_trackFitterTool->getTracks(roadVec, tracksForCurrentRoad, m_evtSel->getMin(), m_evtSel->getMax()));
258 
259  // Find and keep the best track (lowest chi2) for this road
260  if (!tracksForCurrentRoad.empty()) {
261  auto bestTrackIter = std::min_element(
262  tracksForCurrentRoad.begin(), tracksForCurrentRoad.end(),
263  [](const FPGATrackSimTrack& a, const FPGATrackSimTrack& b) {
264  return a.getChi2ndof() < b.getChi2ndof();
265  });
266 
267  if (bestTrackIter != tracksForCurrentRoad.end() && bestTrackIter->getChi2ndof() < 1.e15) {
268  filteredTracks.push_back(*bestTrackIter);
269 
270  // Monitor chi2 of the best track
271  auto mon_chi2 = Monitored::Scalar<float>("chi2_2nd_all", bestTrackIter->getChi2ndof());
272  Monitored::Group(m_monTool, mon_chi2);
273  }
274  }
275  }
276 
277  // Update tracks with filtered tracks
278  tracks = std::move(filteredTracks);
279 
280  // Monitor the best chi2 across all roads
281  if (!tracks.empty()) {
282  float bestChi2Overall = std::min_element(
283  tracks.begin(), tracks.end(),
284  [](const FPGATrackSimTrack& a, const FPGATrackSimTrack& b) {
285  return a.getChi2ndof() < b.getChi2ndof();
286  })->getChi2ndof();
287 
288  auto mon_best_chi2 = Monitored::Scalar<float>("best_chi2_2nd", bestChi2Overall);
289  Monitored::Group(m_monTool, mon_best_chi2);
290  }
291  } else { // Pass all tracks with chi2 < 1e15
292  ATH_CHECK(m_trackFitterTool->getTracks(roads, tracks, m_evtSel->getMin(), m_evtSel->getMax()));
293  float bestchi2 = 1.e15;
294  for (const FPGATrackSimTrack& track : tracks) {
295  float chi2 = track.getChi2ndof();
296  if (chi2 < bestchi2) bestchi2 = chi2;
297  auto mon_chi2 = Monitored::Scalar<float>("chi2_2nd_all", chi2);
298  Monitored::Group(m_monTool, mon_chi2);
299  }
300  auto mon_best_chi2 = Monitored::Scalar<float>("best_chi2_2nd", bestchi2);
301  Monitored::Group(m_monTool, mon_best_chi2);
302  }
303  }
304  } else {
305  // No tracking; just run road to track
306  roadsToTrack(roads, tracks, m_FPGATrackSimMapping->PlaneMap_2nd(0));
307  }
308  if constexpr (enableBenchmark) m_chrono->chronoStop("2nd Stage: Track Extraction");
309  auto mon_ntracks = Monitored::Scalar<unsigned>("ntrack_2nd", tracks.size());
310  Monitored::Group(m_monTool,mon_ntracks);
311 
312  // Overlap removal
313  if constexpr (enableBenchmark) m_chrono->chronoStart("2nd Stage: Overlap Removal");
314  ATH_CHECK(m_overlapRemovalTool->runOverlapRemoval(tracks));
315 
316  // If running NN Track tool, now we get the track parameters (it's slow so we only do it for tracks passing OLR)
317  if (m_doTracking && m_doNNTrack_2nd) {
318  ATH_CHECK(m_NNTrackTool->setTrackParameters(tracks,false,m_evtSel->getMin(), m_evtSel->getMax()));
319  }
320 
321  std::vector<FPGATrackSimTruthTrack> truthtracks = *FPGATruthTracks;
322  std::vector<FPGATrackSimOfflineTrack> offlineTracks = *FPGAOfflineTracks;
323  // Optionally loop over tracks and set track parameters to truth
324  //Loop over tracks and set the region for all of them, also optionally set track parameters to truth
325  if (m_SetTruthParametersForTracks >= 0 && truthtracks.size() > 0) {
326  for (auto track : tracks) {
327 
329  track.setQOverPt(truthtracks.front().getQOverPt());
330  else if (m_SetTruthParametersForTracks != 1)
331  track.setD0(truthtracks.front().getD0());
332  else if (m_SetTruthParametersForTracks != 2)
333  track.setPhi(truthtracks.front().getPhi());
334  else if (m_SetTruthParametersForTracks != 3)
335  track.setZ0(truthtracks.front().getZ0());
336  else if (m_SetTruthParametersForTracks != 4)
337  track.setEta(truthtracks.front().getEta());
338  }
339  }
340 
341  unsigned ntrackOLRChi2 = 0;
342  for (const FPGATrackSimTrack& track : tracks) {
343  if (track.getChi2ndof() < m_trackScoreCut.value()) {
345  if (track.passedOR()) {
346  ntrackOLRChi2++;
348 
349  // For tracks passing overlap removal-- record the chi2 so we can figure out the right cut.
350  float chi2olr = track.getChi2ndof();
351  auto mon_chi2_or = Monitored::Scalar<float>("chi2_2nd_afterOLR", chi2olr);
352  Monitored::Group(m_monTool, mon_chi2_or);
353  }
354  }
355  }
356  if constexpr (enableBenchmark) m_chrono->chronoStop("2nd Stage: Overlap Removal");
357  auto mon_ntracks_olr = Monitored::Scalar<unsigned>("ntrack_2nd_afterOLR", ntrackOLRChi2);
358  Monitored::Group(m_monTool,mon_ntracks_olr);
359 
360  m_nRoadsTot += roads.size();
361  m_nTracksTot += tracks.size();
362 
363  // Do some simple monitoring of efficiencies. okay, we need truth tracks here.
364  if (truthtracks.size() > 0) {
365  m_evt_truth++;
366  auto passroad = Monitored::Scalar<bool>("eff_road_2nd",(roads.size() > 0));
367  auto passtrack = Monitored::Scalar<bool>("eff_track_2nd",(tracks.size() > 0));
368  auto truthpT_zoom = Monitored::Scalar<float>("pT_zoom",truthtracks.front().getPt()*0.001);
369  auto truthpT = Monitored::Scalar<float>("pT",truthtracks.front().getPt()*0.001);
370  auto trutheta = Monitored::Scalar<float>("eta",truthtracks.front().getEta());
371  auto truthphi= Monitored::Scalar<float>("phi",truthtracks.front().getPhi());
372  auto truthd0= Monitored::Scalar<float>("d0",truthtracks.front().getD0());
373  auto truthz0= Monitored::Scalar<float>("z0",truthtracks.front().getZ0());
374  if (roads.size() > 0) m_nRoadsFound++;
375  if (roads.size() > m_maxNRoadsFound) m_maxNRoadsFound = roads.size();
376 
377  unsigned npasschi2(0);
378  unsigned npasschi2OLR(0);
379 
380  if (tracks.size() > 0) {
381  m_nTracksFound++;
382  if (tracks.size() > m_maxNTracksTot) m_maxNTracksTot = tracks.size();
383  for (const auto& track : tracks) {
384  if (track.getChi2ndof() < m_trackScoreCut.value()) {
385  npasschi2++;
386  if (track.passedOR()) {
387  npasschi2OLR++;
388  }
389  }
390  }
391  }
392  if (npasschi2 > m_maxNTracksChi2Tot) m_maxNTracksChi2Tot = npasschi2;
393  if (npasschi2OLR > m_maxNTracksChi2OLRTot) m_maxNTracksChi2OLRTot = npasschi2OLR;
394  if (npasschi2 > 0) m_nTracksChi2Found++;
395  if (npasschi2OLR > 0) m_nTracksChi2OLRFound++;
396 
397  auto passtrackchi2 = Monitored::Scalar<bool>("eff_track_chi2_2nd",(npasschi2 > 0));
398  Monitored::Group(m_monTool,passroad,passtrack,truthpT_zoom,truthpT,trutheta,truthphi,truthd0,truthz0,passtrackchi2);
399  }
400 
401  for (const FPGATrackSimTrack& track : tracks) FPGATracks_2ndHandle->push_back(track);
402 
403  // Write the output and reset
404  if (m_writeOutputData) {
405  auto dataFlowInfo = std::make_unique<FPGATrackSimDataFlowInfo>();
406  ATH_CHECK(writeOutputData(roads, tracks, dataFlowInfo.get()));
407  }
408 
409 
411  ATH_MSG_DEBUG("Running HoughRootOutputTool in 2nd stage.");
412  ATH_CHECK(m_houghRootOutputTool->fillTree(roads, truthtracks, offlineTracks, phits_2nd, m_writeOutNonSPStripHits, m_trackScoreCut.value(), m_NumOfHitPerGrouping, true));
413  }
414 
415  // Reset data pointers
418 
419  return StatusCode::SUCCESS;
420 }

◆ 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()) {
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode FPGATrackSimSecondStageAlg::finalize ( )
overridevirtual

Definition at line 453 of file FPGATrackSimSecondStageAlg.cxx.

454 {
455  ATH_MSG_INFO("PRINTING FPGATRACKSIM SIMPLE STATS: SECOND STAGE");
456  ATH_MSG_INFO("========================================================================================");
457  ATH_MSG_INFO("Ran on events = " << m_evt);
458  ATH_MSG_INFO("Inclusive efficiency to find a road = " << (m_evt_truth == 0 ? "NAN" : std::to_string(m_nRoadsFound/(float)m_evt_truth)));
459  ATH_MSG_INFO("Inclusive efficiency to find a track = " << (m_evt_truth == 0 ? "NAN" : std::to_string(m_nTracksFound/(float)m_evt_truth)));
460  ATH_MSG_INFO("Inclusive efficiency to find a track passing chi2 = " << (m_evt_truth == 0 ? "NAN" : std::to_string(m_nTracksChi2Found/(float)m_evt_truth)));
461  ATH_MSG_INFO("Inclusive efficiency to find a track passing chi2 and OLR = " << (m_evt_truth == 0 ? "NAN" : std::to_string(m_nTracksChi2OLRFound/(float)m_evt_truth)));
462 
463 
464  ATH_MSG_INFO("Number of 2nd stage roads/event = " << (m_evt == 0 ? "NAN" : std::to_string(m_nRoadsTot/(float)m_evt)));
465  ATH_MSG_INFO("Number of 2nd stage track combinations/event = " << (m_evt == 0 ? "NAN" : std::to_string(m_nTracksTot/(float)m_evt)));
466  ATH_MSG_INFO("Number of 2nd stage tracks passing chi2/event = " << (m_evt == 0 ? "NAN" : std::to_string(m_nTracksChi2Tot/(float)m_evt)));
467  ATH_MSG_INFO("Number of 2nd stage tracks passing chi2 and OLR/event = " << (m_evt == 0 ? "NAN" : std::to_string(m_nTracksChi2OLRTot/(float)m_evt)));
468  ATH_MSG_INFO("========================================================================================");
469 
470  ATH_MSG_INFO("Max number of 2nd stage roads in an event = " << m_maxNRoadsFound);
471  ATH_MSG_INFO("Max number of 2nd stage track combinations in an event = " << m_maxNTracksTot);
472  ATH_MSG_INFO("Max number of 2nd stage tracks passing chi2 in an event = " << m_maxNTracksChi2Tot);
473  ATH_MSG_INFO("Max number of 2nd stage tracks passing chi2 and OLR in an event = " << m_maxNTracksChi2OLRTot);
474  ATH_MSG_INFO("========================================================================================");
475  return StatusCode::SUCCESS;
476 }

◆ initialize()

StatusCode FPGATrackSimSecondStageAlg::initialize ( )
overridevirtual

Definition at line 49 of file FPGATrackSimSecondStageAlg.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  ATH_CHECK(m_houghRootOutputTool.retrieve(EnableTool{m_doHoughRootOutput2nd}));
61  ATH_CHECK(m_NNTrackTool.retrieve(EnableTool{m_doNNTrack_2nd}));
62 
63  ATH_CHECK(m_trackFitterTool.retrieve(EnableTool{m_doTracking}));
64  ATH_CHECK(m_overlapRemovalTool.retrieve());
65  ATH_CHECK(m_writeOutputTool.retrieve());
66  ATH_CHECK(m_FPGATrackSimMapping.retrieve());
67  ATH_CHECK(m_trackExtensionTool.retrieve());
68 
69  ATH_MSG_DEBUG("initialize() Instantiating root objects");
70 
71  // This file should only need to generate one input and output branch.
72  m_slicedHitHeader = m_writeOutputTool->addInputBranch(m_sliceBranch.value(), true);
73  m_logicEventOutputHeader = m_writeOutputTool->addOutputBranch(m_outputBranch.value(), true);
74 
75  // Connect the sliced hit tool accordingly. This may need to be a separate flag.
77 
78  ATH_MSG_DEBUG("initialize() Setting branch");
79 
80  if (!m_monTool.empty())
81  ATH_CHECK(m_monTool.retrieve());
82 
91 
92  ATH_CHECK( m_chrono.retrieve() );
93  ATH_MSG_DEBUG("initialize() Finished");
94 
95  return StatusCode::SUCCESS;
96 }

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

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

◆ 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  {
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 FPGATrackSimSecondStageAlg::writeOutputData ( const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &  roads_2nd,
std::vector< FPGATrackSimTrack > const tracks_2nd,
FPGATrackSimDataFlowInfo const dataFlowInfo 
)
private

Definition at line 423 of file FPGATrackSimSecondStageAlg.cxx.

426 {
428 
429  ATH_MSG_DEBUG("NFPGATrackSimRoads_2nd = " << roads_2nd.size() << ", NFPGATrackSimTracks_2nd = " << tracks_2nd.size());
430 
431  if (!m_writeOutputData) return StatusCode::SUCCESS;
434  if (m_doTracking) {
437  }
438 
439 
442 
443  // It would be nice to rearrange this so both algorithms use one instance of this tool, I think.
444  // Which means that dataprep can't call writeData because that does Fill().
445  ATH_CHECK(m_writeOutputTool->writeData());
446 
447  return StatusCode::SUCCESS;
448 }

Member Data Documentation

◆ m_chrono

ServiceHandle<IChronoStatSvc> FPGATrackSimSecondStageAlg::m_chrono {this,"ChronoStatSvc","ChronoStatSvc"}
private

Definition at line 76 of file FPGATrackSimSecondStageAlg.h.

◆ m_description

std::string FPGATrackSimSecondStageAlg::m_description
private

Definition at line 58 of file FPGATrackSimSecondStageAlg.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_doHoughRootOutput2nd

Gaudi::Property<bool> FPGATrackSimSecondStageAlg::m_doHoughRootOutput2nd {this, "DoHoughRootOutput2nd", false, "Dump output from the Hough Transform to flat ntuples"}
private

Definition at line 83 of file FPGATrackSimSecondStageAlg.h.

◆ m_doMissingHitsChecks

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

Definition at line 82 of file FPGATrackSimSecondStageAlg.h.

◆ m_doNNPathFinder

Gaudi::Property<bool> FPGATrackSimSecondStageAlg::m_doNNPathFinder {this, "doNNPathFinder", false}
private

Definition at line 90 of file FPGATrackSimSecondStageAlg.h.

◆ m_doNNTrack_2nd

Gaudi::Property<bool> FPGATrackSimSecondStageAlg::m_doNNTrack_2nd {this, "DoNNTrack_2nd", false, "Run NN track filtering for 2nd Stage"}
private

Definition at line 84 of file FPGATrackSimSecondStageAlg.h.

◆ m_doSpacepoints

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

Definition at line 80 of file FPGATrackSimSecondStageAlg.h.

◆ m_doTracking

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

Definition at line 81 of file FPGATrackSimSecondStageAlg.h.

◆ m_evt

long FPGATrackSimSecondStageAlg::m_evt = 0
private

Definition at line 109 of file FPGATrackSimSecondStageAlg.h.

◆ m_evt_truth

long FPGATrackSimSecondStageAlg::m_evt_truth = 0
private

Definition at line 115 of file FPGATrackSimSecondStageAlg.h.

◆ m_evtSel

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

Definition at line 74 of file FPGATrackSimSecondStageAlg.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> FPGATrackSimSecondStageAlg::m_filterRoads {this, "FilterRoads", false, "enable first road filter"}
private

Definition at line 95 of file FPGATrackSimSecondStageAlg.h.

◆ m_filterRoads2

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

Definition at line 96 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGAEventInfoKey

SG::ReadHandleKey<FPGATrackSimEventInfo> FPGATrackSimSecondStageAlg::m_FPGAEventInfoKey {this, "FPGATrackSimEventInfoKey", "FPGAEventInfo", "FPGATrackSim event info"}
private

Definition at line 145 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGAHitInRoadsKey

SG::WriteHandleKey<FPGATrackSimHitContainer> FPGATrackSimSecondStageAlg::m_FPGAHitInRoadsKey {this, "FPGATrackSimHitInRoads2ndKey","FPGAHitsInRoads_2nd","FPGATrackSim Hits in 1st stage roads key"}
private

Definition at line 138 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGAHitKey

SG::ReadHandleKey<FPGATrackSimHitCollection> FPGATrackSimSecondStageAlg::m_FPGAHitKey {this, "FPGATrackSimHitKey", "FPGAHits_2nd", "FPGATrackSim Hits key"}
private

Definition at line 134 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGAInputTrackKey

SG::ReadHandleKey<FPGATrackSimTrackCollection> FPGATrackSimSecondStageAlg::m_FPGAInputTrackKey {this, "FPGATrackSimTrack1stKey", "FPGATracks_1st", "FPGATrackSim tracks 1st stage key"}
private

Definition at line 135 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGAOfflineTrackKey

SG::ReadHandleKey<FPGATrackSimOfflineTrackCollection> FPGATrackSimSecondStageAlg::m_FPGAOfflineTrackKey {this, "FPGATrackSimOfflineTrackKey", "FPGAOfflineTracks", "FPGATrackSim offline tracks"}
private

Definition at line 144 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGARoadKey

SG::WriteHandleKey<FPGATrackSimRoadCollection> FPGATrackSimSecondStageAlg::m_FPGARoadKey {this, "FPGATrackSimRoad2ndKey","FPGARoads_2nd","FPGATrackSim Roads 2nd stage key"}
private

Definition at line 139 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGATrackKey

SG::WriteHandleKey<FPGATrackSimTrackCollection> FPGATrackSimSecondStageAlg::m_FPGATrackKey {this, "FPGATrackSimTrack2ndKey","FPGATracks_2nd","FPGATrackSim Tracks 2nd stage key"}
private

Definition at line 140 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGATrackSimMapping

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

Definition at line 73 of file FPGATrackSimSecondStageAlg.h.

◆ m_FPGATruthTrackKey

SG::ReadHandleKey<FPGATrackSimTruthTrackCollection> FPGATrackSimSecondStageAlg::m_FPGATruthTrackKey {this, "FPGATrackSimTruthTrackKey", "FPGATruthTracks", "FPGATrackSim truth tracks"}
private

Definition at line 143 of file FPGATrackSimSecondStageAlg.h.

◆ m_houghRootOutputTool

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

Definition at line 64 of file FPGATrackSimSecondStageAlg.h.

◆ m_logicEventOutputHeader

FPGATrackSimLogicalEventOutputHeader* FPGATrackSimSecondStageAlg::m_logicEventOutputHeader = nullptr
private

Definition at line 104 of file FPGATrackSimSecondStageAlg.h.

◆ m_maxNRoadsFound

unsigned long FPGATrackSimSecondStageAlg::m_maxNRoadsFound = 0
private

Definition at line 121 of file FPGATrackSimSecondStageAlg.h.

◆ m_maxNTracksChi2OLRTot

unsigned long FPGATrackSimSecondStageAlg::m_maxNTracksChi2OLRTot = 0
private

Definition at line 124 of file FPGATrackSimSecondStageAlg.h.

◆ m_maxNTracksChi2Tot

unsigned long FPGATrackSimSecondStageAlg::m_maxNTracksChi2Tot = 0
private

Definition at line 123 of file FPGATrackSimSecondStageAlg.h.

◆ m_maxNTracksTot

unsigned long FPGATrackSimSecondStageAlg::m_maxNTracksTot = 0
private

Definition at line 122 of file FPGATrackSimSecondStageAlg.h.

◆ m_monTool

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

Definition at line 131 of file FPGATrackSimSecondStageAlg.h.

◆ m_NNTrackTool

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

Definition at line 67 of file FPGATrackSimSecondStageAlg.h.

◆ m_nRoadsFound

long FPGATrackSimSecondStageAlg::m_nRoadsFound = 0
private

Definition at line 116 of file FPGATrackSimSecondStageAlg.h.

◆ m_nRoadsTot

long FPGATrackSimSecondStageAlg::m_nRoadsTot = 0
private

Definition at line 110 of file FPGATrackSimSecondStageAlg.h.

◆ m_nTracksChi2Found

long FPGATrackSimSecondStageAlg::m_nTracksChi2Found = 0
private

Definition at line 118 of file FPGATrackSimSecondStageAlg.h.

◆ m_nTracksChi2OLRFound

long FPGATrackSimSecondStageAlg::m_nTracksChi2OLRFound = 0
private

Definition at line 119 of file FPGATrackSimSecondStageAlg.h.

◆ m_nTracksChi2OLRTot

long FPGATrackSimSecondStageAlg::m_nTracksChi2OLRTot = 0
private

Definition at line 113 of file FPGATrackSimSecondStageAlg.h.

◆ m_nTracksChi2Tot

long FPGATrackSimSecondStageAlg::m_nTracksChi2Tot = 0
private

Definition at line 112 of file FPGATrackSimSecondStageAlg.h.

◆ m_nTracksFound

long FPGATrackSimSecondStageAlg::m_nTracksFound = 0
private

Definition at line 117 of file FPGATrackSimSecondStageAlg.h.

◆ m_nTracksTot

long FPGATrackSimSecondStageAlg::m_nTracksTot = 0
private

Definition at line 111 of file FPGATrackSimSecondStageAlg.h.

◆ m_NumOfHitPerGrouping

Gaudi::Property<int> FPGATrackSimSecondStageAlg::m_NumOfHitPerGrouping { this, "NumOfHitPerGrouping", 5, "Number of minimum overlapping hits for a track candidate to be removed in the HoughRootOutputTool"}
private

Definition at line 88 of file FPGATrackSimSecondStageAlg.h.

◆ m_outputBranch

Gaudi::Property<std::string> FPGATrackSimSecondStageAlg::m_outputBranch {this, "outputBranchName", "LogicalEventOutputHeader", "Name of the branch for output data in output ROOT file." }
private

Definition at line 100 of file FPGATrackSimSecondStageAlg.h.

◆ m_overlapRemovalTool

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

Definition at line 69 of file FPGATrackSimSecondStageAlg.h.

◆ m_passLowestChi2TrackOnly

Gaudi::Property<bool> FPGATrackSimSecondStageAlg::m_passLowestChi2TrackOnly {this, "passLowestChi2TrackOnly", false}
private

Definition at line 89 of file FPGATrackSimSecondStageAlg.h.

◆ m_SetTruthParametersForTracks

Gaudi::Property<int> FPGATrackSimSecondStageAlg::m_SetTruthParametersForTracks {this, "SetTruthParametersForTracks", -1, "flag to override track parameters and set them to the truth values"}
private

Definition at line 79 of file FPGATrackSimSecondStageAlg.h.

◆ m_sliceBranch

Gaudi::Property<std::string> FPGATrackSimSecondStageAlg::m_sliceBranch {this, "SliceBranchName", "LogicalEventSlicedHeader", "Name of the branch for slied hits in output ROOT file." }
private

Definition at line 99 of file FPGATrackSimSecondStageAlg.h.

◆ m_slicedHitHeader

FPGATrackSimLogicalEventInputHeader* FPGATrackSimSecondStageAlg::m_slicedHitHeader = nullptr
private

Definition at line 103 of file FPGATrackSimSecondStageAlg.h.

◆ m_trackExtensionTool

ToolHandle<IFPGATrackSimTrackExtensionTool> FPGATrackSimSecondStageAlg::m_trackExtensionTool {this, "TrackExtensionTool", "FPGATrackSimTrackExtensionTool", "Track extensoin tool"}
private

Definition at line 61 of file FPGATrackSimSecondStageAlg.h.

◆ m_trackFitterTool

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

Definition at line 68 of file FPGATrackSimSecondStageAlg.h.

◆ m_trackScoreCut

Gaudi::Property<float> FPGATrackSimSecondStageAlg::m_trackScoreCut {this, "TrackScoreCut", 25.0, "Minimum track score (e.g. chi2 or NN)." }
private

Definition at line 86 of file FPGATrackSimSecondStageAlg.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_writeOutNonSPStripHits

Gaudi::Property<bool> FPGATrackSimSecondStageAlg::m_writeOutNonSPStripHits {this, "writeOutNonSPStripHits", true, "Write tracks to RootOutput if they have strip hits which are not SPs"}
private

Definition at line 87 of file FPGATrackSimSecondStageAlg.h.

◆ m_writeOutputData

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

Definition at line 85 of file FPGATrackSimSecondStageAlg.h.

◆ m_writeOutputTool

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

Definition at line 72 of file FPGATrackSimSecondStageAlg.h.


The documentation for this class was generated from the following files:
FPGATrackSimSecondStageAlg::m_trackFitterTool
ToolHandle< FPGATrackSimTrackFitterTool > m_trackFitterTool
Definition: FPGATrackSimSecondStageAlg.h:68
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
FPGATrackSimSecondStageAlg::m_nRoadsFound
long m_nRoadsFound
Definition: FPGATrackSimSecondStageAlg.h:116
FPGATrackSimSecondStageAlg::m_FPGAHitKey
SG::ReadHandleKey< FPGATrackSimHitCollection > m_FPGAHitKey
Definition: FPGATrackSimSecondStageAlg.h:134
FPGATrackSimSecondStageAlg::m_SetTruthParametersForTracks
Gaudi::Property< int > m_SetTruthParametersForTracks
Definition: FPGATrackSimSecondStageAlg.h:79
FPGATrackSimSecondStageAlg::m_maxNRoadsFound
unsigned long m_maxNRoadsFound
Definition: FPGATrackSimSecondStageAlg.h:121
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
FPGATrackSimSecondStageAlg::m_FPGATrackKey
SG::WriteHandleKey< FPGATrackSimTrackCollection > m_FPGATrackKey
Definition: FPGATrackSimSecondStageAlg.h:140
FPGATrackSimSecondStageAlg::m_FPGAInputTrackKey
SG::ReadHandleKey< FPGATrackSimTrackCollection > m_FPGAInputTrackKey
Definition: FPGATrackSimSecondStageAlg.h:135
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FPGATrackSimSecondStageAlg::m_trackScoreCut
Gaudi::Property< float > m_trackScoreCut
Definition: FPGATrackSimSecondStageAlg.h:86
FPGATrackSimSecondStageAlg::m_chrono
ServiceHandle< IChronoStatSvc > m_chrono
Definition: FPGATrackSimSecondStageAlg.h:76
FPGATrackSimSecondStageAlg::m_maxNTracksTot
unsigned long m_maxNTracksTot
Definition: FPGATrackSimSecondStageAlg.h:122
FPGATrackSimSecondStageAlg::m_slicedHitHeader
FPGATrackSimLogicalEventInputHeader * m_slicedHitHeader
Definition: FPGATrackSimSecondStageAlg.h:103
FPGATrackSimTrack
Definition: FPGATrackSimTrack.h:18
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
FPGATrackSimSecondStageAlg::m_NumOfHitPerGrouping
Gaudi::Property< int > m_NumOfHitPerGrouping
Definition: FPGATrackSimSecondStageAlg.h:88
FPGATrackSimSecondStageAlg::m_houghRootOutputTool
ToolHandle< FPGATrackSimHoughRootOutputTool > m_houghRootOutputTool
Definition: FPGATrackSimSecondStageAlg.h:64
FPGATrackSimSecondStageAlg::m_logicEventOutputHeader
FPGATrackSimLogicalEventOutputHeader * m_logicEventOutputHeader
Definition: FPGATrackSimSecondStageAlg.h:104
FPGATrackSimSecondStageAlg::m_sliceBranch
Gaudi::Property< std::string > m_sliceBranch
Definition: FPGATrackSimSecondStageAlg.h:99
enableBenchmark
constexpr bool enableBenchmark
Definition: FPGATrackSimSecondStageAlg.cxx:33
FPGATrackSimSecondStageAlg::m_FPGARoadKey
SG::WriteHandleKey< FPGATrackSimRoadCollection > m_FPGARoadKey
Definition: FPGATrackSimSecondStageAlg.h:139
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
FPGATrackSimLogicalEventOutputHeader::reset
void reset()
Definition: FPGATrackSimLogicalEventOutputHeader.cxx:12
FPGATrackSimSecondStageAlg::m_trackExtensionTool
ToolHandle< IFPGATrackSimTrackExtensionTool > m_trackExtensionTool
Definition: FPGATrackSimSecondStageAlg.h:61
FPGATrackSimSecondStageAlg::m_FPGATrackSimMapping
ServiceHandle< IFPGATrackSimMappingSvc > m_FPGATrackSimMapping
Definition: FPGATrackSimSecondStageAlg.h:73
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:157
FPGATrackSimSecondStageAlg::writeOutputData
StatusCode writeOutputData(const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads_2nd, std::vector< FPGATrackSimTrack > const &tracks_2nd, FPGATrackSimDataFlowInfo const *dataFlowInfo)
Definition: FPGATrackSimSecondStageAlg.cxx:423
FPGATrackSimSecondStageAlg::m_evt_truth
long m_evt_truth
Definition: FPGATrackSimSecondStageAlg.h:115
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
FPGATrackSimSecondStageAlg::m_nTracksChi2Tot
long m_nTracksChi2Tot
Definition: FPGATrackSimSecondStageAlg.h:112
FPGATrackSimSecondStageAlg::m_FPGAEventInfoKey
SG::ReadHandleKey< FPGATrackSimEventInfo > m_FPGAEventInfoKey
Definition: FPGATrackSimSecondStageAlg.h:145
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
FPGATrackSimLogicalEventOutputHeader::getDataFlowInfo
FPGATrackSimDataFlowInfo const & getDataFlowInfo() const
Definition: FPGATrackSimLogicalEventOutputHeader.h:47
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
FPGATrackSimSecondStageAlg::m_evtSel
ServiceHandle< IFPGATrackSimEventSelectionSvc > m_evtSel
Definition: FPGATrackSimSecondStageAlg.h:74
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
FPGATrackSimSecondStageAlg::m_nTracksChi2OLRFound
long m_nTracksChi2OLRFound
Definition: FPGATrackSimSecondStageAlg.h:119
FPGATrackSimSecondStageAlg::m_doNNTrack_2nd
Gaudi::Property< bool > m_doNNTrack_2nd
Definition: FPGATrackSimSecondStageAlg.h:84
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
FPGATrackSimEventInfo
Definition: FPGATrackSimEventInfo.h:14
FPGATrackSimLogicalEventOutputHeader::addFPGATrackSimTracks_2nd
void addFPGATrackSimTracks_2nd(std::vector< FPGATrackSimTrack > const &tracks_2nd)
Definition: FPGATrackSimLogicalEventOutputHeader.h:44
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
roadsToTrack
void roadsToTrack(std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads, std::vector< FPGATrackSimTrack > &track_cands, const FPGATrackSimPlaneMap *pmap)
Definition: FPGATrackSimHoughFunctions.cxx:674
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
FPGATrackSimSecondStageAlg::m_FPGATruthTrackKey
SG::ReadHandleKey< FPGATrackSimTruthTrackCollection > m_FPGATruthTrackKey
Definition: FPGATrackSimSecondStageAlg.h:143
FPGATrackSimSecondStageAlg::m_writeOutNonSPStripHits
Gaudi::Property< bool > m_writeOutNonSPStripHits
Definition: FPGATrackSimSecondStageAlg.h:87
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:525
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
FPGATrackSimSecondStageAlg::m_FPGAOfflineTrackKey
SG::ReadHandleKey< FPGATrackSimOfflineTrackCollection > m_FPGAOfflineTrackKey
Definition: FPGATrackSimSecondStageAlg.h:144
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
FPGATrackSimLogicalEventInputHeader::newEvent
void newEvent(FPGATrackSimEventInfo &event)
Definition: FPGATrackSimLogicalEventInputHeader.h:29
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
FPGATrackSimSecondStageAlg::m_outputBranch
Gaudi::Property< std::string > m_outputBranch
Definition: FPGATrackSimSecondStageAlg.h:100
FPGATrackSimSecondStageAlg::m_writeOutputTool
ToolHandle< FPGATrackSimOutputHeaderTool > m_writeOutputTool
Definition: FPGATrackSimSecondStageAlg.h:72
FPGATrackSimLogicalEventOutputHeader::setDataFlowInfo
void setDataFlowInfo(FPGATrackSimDataFlowInfo const &info)
Definition: FPGATrackSimLogicalEventOutputHeader.h:48
FPGATrackSimLogicalEventInputHeader::reset
void reset()
Definition: FPGATrackSimLogicalEventInputHeader.cxx:10
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
FPGATrackSimSecondStageAlg::m_maxNTracksChi2Tot
unsigned long m_maxNTracksChi2Tot
Definition: FPGATrackSimSecondStageAlg.h:123
FPGATrackSimSecondStageAlg::m_maxNTracksChi2OLRTot
unsigned long m_maxNTracksChi2OLRTot
Definition: FPGATrackSimSecondStageAlg.h:124
FPGATrackSimSecondStageAlg::m_NNTrackTool
ToolHandle< FPGATrackSimNNTrackTool > m_NNTrackTool
Definition: FPGATrackSimSecondStageAlg.h:67
FPGATrackSimSecondStageAlg::m_writeOutputData
Gaudi::Property< bool > m_writeOutputData
Definition: FPGATrackSimSecondStageAlg.h:85
FPGATrackSimSecondStageAlg::m_overlapRemovalTool
ToolHandle< FPGATrackSimOverlapRemovalTool > m_overlapRemovalTool
Definition: FPGATrackSimSecondStageAlg.h:69
FPGATrackSimSecondStageAlg::m_doHoughRootOutput2nd
Gaudi::Property< bool > m_doHoughRootOutput2nd
Definition: FPGATrackSimSecondStageAlg.h:83
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:73
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
FPGATrackSimLogicalEventOutputHeader::reserveFPGATrackSimTracks_2nd
void reserveFPGATrackSimTracks_2nd(size_t size)
Definition: FPGATrackSimLogicalEventOutputHeader.h:43
a
TList * a
Definition: liststreamerinfos.cxx:10
h
FPGATrackSimSecondStageAlg::m_nRoadsTot
long m_nRoadsTot
Definition: FPGATrackSimSecondStageAlg.h:110
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
FPGATrackSimSecondStageAlg::m_nTracksFound
long m_nTracksFound
Definition: FPGATrackSimSecondStageAlg.h:117
FPGATrackSimSecondStageAlg::m_nTracksChi2OLRTot
long m_nTracksChi2OLRTot
Definition: FPGATrackSimSecondStageAlg.h:113
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
FPGATrackSimSecondStageAlg::m_passLowestChi2TrackOnly
Gaudi::Property< bool > m_passLowestChi2TrackOnly
Definition: FPGATrackSimSecondStageAlg.h:89
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
FPGATrackSimSecondStageAlg::m_doTracking
Gaudi::Property< bool > m_doTracking
Definition: FPGATrackSimSecondStageAlg.h:81
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
FPGATrackSimSecondStageAlg::m_FPGAHitInRoadsKey
SG::WriteHandleKey< FPGATrackSimHitContainer > m_FPGAHitInRoadsKey
Definition: FPGATrackSimSecondStageAlg.h:138
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
FPGATrackSimSecondStageAlg::m_evt
long m_evt
Definition: FPGATrackSimSecondStageAlg.h:109
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
FPGATrackSimLogicalEventOutputHeader::reserveFPGATrackSimRoads_2nd
void reserveFPGATrackSimRoads_2nd(size_t size)
Definition: FPGATrackSimLogicalEventOutputHeader.h:31
FPGATrackSimSecondStageAlg::m_monTool
ToolHandle< GenericMonitoringTool > m_monTool
Definition: FPGATrackSimSecondStageAlg.h:131
FPGATrackSimLogicalEventOutputHeader::addFPGATrackSimRoads_2nd
void addFPGATrackSimRoads_2nd(const std::vector< std::shared_ptr< const FPGATrackSimRoad >> &roads_2nd)
Definition: FPGATrackSimLogicalEventOutputHeader.h:32
FPGATrackSimSecondStageAlg::m_description
std::string m_description
Definition: FPGATrackSimSecondStageAlg.h:58
FPGATrackSimSecondStageAlg::m_nTracksTot
long m_nTracksTot
Definition: FPGATrackSimSecondStageAlg.h:111
FPGATrackSimSecondStageAlg::m_nTracksChi2Found
long m_nTracksChi2Found
Definition: FPGATrackSimSecondStageAlg.h:118
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >