ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
ITk::PixelRDOAnalysis Class Reference

#include <ITkPixelRDOAnalysis.h>

Inheritance diagram for ITk::PixelRDOAnalysis:

Public Member Functions

 ~PixelRDOAnalysis ()=default
virtual StatusCode initialize () override final
virtual StatusCode execute (const EventContext &ctx) override final
 Execute method.
 AthHistogramAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 Constructor with parameters:
virtual StatusCode sysInitialize ()
 Initialization method invoked by the framework.
const ServiceHandle< ITHistSvc > & histSvc () const
 The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a pointer to the THistSvc.
virtual bool isClonable () const override
 Specify if the algorithm is clonable.
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm.
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
virtual bool filterPassed (const EventContext &ctx) const
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Protected Member Functions

virtual bool isReEntrant () const override final
 Legacy algorithms are not thread-safe.
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
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.
StatusCode configAthHistogramming (const ServiceHandle< ITHistSvc > &histSvc, const std::string &prefix, const std::string &rootDir, const std::string &histNamePrefix, const std::string &histNamePostfix, const std::string &histTitlePrefix, const std::string &histTitlePostfix)
 To be called to fill the internal configuration.
TH1 * bookGetPointer (const TH1 &hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 *hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 &histRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TTree * bookGetPointer (const TTree &treeRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
TGraph * bookGetPointer (const TGraph &graphRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
TEfficiency * bookGetPointer (const TEfficiency &eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency *eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency &effRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (const TH1 &hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 *hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 &histRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (const TTree &treeRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
StatusCode book (const TGraph &graphRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
StatusCode book (const TEfficiency &eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency *eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency &effRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TH1 * hist (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered histograms of any type.
TH2 * hist2d (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered 2-d histograms.
TH3 * hist3d (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered 3-d histograms.
TTree * tree (std::string_view treeName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TTrees.
TGraph * graph (std::string_view graphName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TGraphs.
TEfficiency * efficiency (std::string_view effName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TEfficiency.

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
typedef uint32_t hash_t
 typedef for the internal hash
typedef std::map< const hash_t, TH1 * > HistMap_t
 Typedef for convenience.
typedef std::map< const hash_t, TEfficiency * > EffMap_t
 Typedef for convenience.
typedef std::map< const hash_t, TTree * > TreeMap_t
 Typedef for convenience.
typedef std::map< const hash_t, TGraph * > GraphMap_t
 Typedef for convenience.

Private Member Functions

Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>
std::string buildBookingString (std::string_view histName, std::string_view tDir, std::string_view stream, bool usePrefixPostfix=false) const
 Method to build individual booking string.
hash_t hash (std::string_view histName) const
 Method to calculate a 32-bit hash from a string.

Private Attributes

SG::ReadHandleKey< PixelRDO_Container > m_inputKey {this, "CollectionName", "ITkPixelRDOs", "Input ITk Pixel RDO collection name"}
SG::ReadHandleKey< InDetSimDataCollection > m_inputTruthKey {this, "SDOCollectionName", "ITkPixelSDO_Map", "Input ITk Pixel SDO collection name"}
SG::ReadHandleKey< McEventCollection > m_inputMcEventCollectionKey {this, "McEventCollectionName", "TruthEvent", "Input McEventCollection name"}
const PixelID * m_pixelID {}
const InDetDD::PixelDetectorManager * m_pixelManager {}
Gaudi::Property< std::string > m_detectorName {this, "DetectorName", "ITkPixel", "Pixel detector name"}
Gaudi::Property< std::string > m_pixelIDName {this, "PixelIDName", "PixelID", "Pixel ID name"}
Gaudi::Property< std::string > m_histPath {this, "HistPath", "/RDOAnalysis/ITkPixel/", ""}
Gaudi::Property< std::string > m_sharedHistPath {this, "SharedHistPath", "/RDOAnalysis/histos/", ""}
Gaudi::Property< std::string > m_ntuplePath {this, "NtuplePath", "/RDOAnalysis/ntuples/", ""}
Gaudi::Property< std::string > m_ntupleName {this, "NtupleName", "ITkPixel", ""}
Gaudi::Property< bool > m_doPosition {this, "DoPosition", true, ""}
std::vector< unsigned long long > * m_rdoID {}
std::vector< unsigned int > * m_rdoWord {}
std::vector< int > * m_barrelEndcap {}
std::vector< int > * m_layerDisk {}
std::vector< int > * m_phiModule {}
std::vector< int > * m_etaModule {}
std::vector< int > * m_phiIndex {}
std::vector< int > * m_etaIndex {}
std::vector< int > * m_isInnermost {}
std::vector< int > * m_isNextToInnermost {}
std::vector< int > * m_ToT {}
std::vector< int > * m_BCID {}
std::vector< int > * m_LVL1A {}
std::vector< int > * m_LVL1ID {}
std::vector< double > * m_globalX {}
std::vector< double > * m_globalY {}
std::vector< double > * m_globalZ {}
std::vector< double > * m_localX {}
std::vector< double > * m_localY {}
std::vector< double > * m_localZ {}
std::vector< unsigned long long > * m_sdoID {}
std::vector< int > * m_sdoWord {}
std::vector< int > * m_barrelEndcap_sdo {}
std::vector< int > * m_layerDisk_sdo {}
std::vector< int > * m_phiModule_sdo {}
std::vector< int > * m_etaModule_sdo {}
std::vector< int > * m_phiIndex_sdo {}
std::vector< int > * m_etaIndex_sdo {}
std::vector< bool > * m_noise {}
std::vector< bool > * m_belowThresh {}
std::vector< bool > * m_disabled {}
std::vector< bool > * m_badTOT {}
std::vector< int > * m_barcode {}
std::vector< int > * m_eventIndex {}
std::vector< int > * m_charge {}
std::vector< std::vector< int > > * m_barcode_vec {}
std::vector< std::vector< int > > * m_eventIndex_vec {}
std::vector< std::vector< float > > * m_charge_vec {}
TH1 * m_h_rdoID {}
TH1 * m_h_rdoWord {}
TH1 * m_h_barrelEndcap {}
TH1 * m_h_layerDisk {}
TH1 * m_h_phiModule {}
TH1 * m_h_etaModule {}
TH1 * m_h_phiIndex {}
TH1 * m_h_etaIndex {}
TH1 * m_h_ToT {}
TH1 * m_h_BCID {}
TH1 * m_h_LVL1A {}
TH1 * m_h_LVL1ID {}
TH1 * m_h_brlLayer {}
TH1 * m_h_brlPhiMod {}
TH1 * m_h_brlEtaMod {}
TH1 * m_h_brlPhiIndex {}
TH1 * m_h_brlEtaIndex {}
TH1 * m_h_brlToT {}
TH1 * m_h_brlBCID {}
TH1 * m_h_brlLVL1A {}
TH1 * m_h_brlLVL1ID {}
TH1 * m_h_ecDisk {}
TH1 * m_h_ecPhiMod {}
TH1 * m_h_ecEtaMod {}
TH1 * m_h_ecPhiIndex {}
TH1 * m_h_ecEtaIndex {}
TH1 * m_h_ecToT {}
TH1 * m_h_ecBCID {}
TH1 * m_h_ecLVL1A {}
TH1 * m_h_ecLVL1ID {}
TH1 * m_h_sdoID {}
TH1 * m_h_sdoWord {}
TH1 * m_h_barrelEndcap_sdo {}
TH1 * m_h_layerDisk_sdo {}
TH1 * m_h_phiModule_sdo {}
TH1 * m_h_etaModule_sdo {}
TH1 * m_h_phiIndex_sdo {}
TH1 * m_h_etaIndex_sdo {}
TH1 * m_h_barcode {}
TH1 * m_h_eventIndex {}
TH1 * m_h_charge {}
TH1 * m_h_belowThresh_brl {}
TH1 * m_h_belowThresh_ec {}
TH1 * m_h_disabled_brl {}
TH1 * m_h_disabled_ec {}
std::vector< TH1 * > m_h_brlinclPhiIndex_perLayer
std::vector< TH1 * > m_h_brlinclEtaIndex_perLayer
std::vector< TH1 * > m_h_brlflatPhiIndex_perLayer
std::vector< TH1 * > m_h_brlflatEtaIndex_perLayer
std::vector< TH1 * > m_h_ecPhiIndex_perLayer
std::vector< TH1 * > m_h_ecEtaIndex_perLayer
TH1 * m_h_phiIndexInnermost {}
TH1 * m_h_etaIndexInnermost {}
TH1 * m_h_phiIndexNextToInnermost {}
TH1 * m_h_etaIndexNextToInnermost {}
TH2 * m_h_globalXY {}
TH2 * m_h_globalZR {}
LockedHandle< TH2 > m_h_globalXY_shared {}
LockedHandle< TH2 > m_h_globalZR_shared {}
TH1 * m_h_globalX {}
TH1 * m_h_globalY {}
TH1 * m_h_globalZ {}
TH1 * m_h_truthMatchedRDOs {}
TTree * m_tree {}
ServiceHandle< ITHistSvc > m_histSvc
 Default constructor: AthHistogramAlgorithm();.
std::string m_prefix
 Name of the ROOT output stream (file).
std::string m_rootDir
 Name of the ROOT directory.
std::string m_histNamePrefix
 The prefix for the histogram THx name.
std::string m_histNamePostfix
 The postfix for the histogram THx name.
std::string m_histTitlePrefix
 The prefix for the histogram THx title.
std::string m_histTitlePostfix
 The postfix for the histogram THx title.
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared
HistMap_t m_histMap
 The map of histogram names to their pointers.
EffMap_t m_effMap
 The map of histogram names to their pointers.
TreeMap_t m_treeMap
 The map of TTree names to their pointers.
GraphMap_t m_graphMap
 The map of TGraph names to their pointers.
std::string m_streamName
 Name of the ROOT output stream (file).
std::string m_name
 Instance name.
MsgStream m_msg
 Cached Message Stream.

Detailed Description

Definition at line 35 of file ITkPixelRDOAnalysis.h.

Member Typedef Documentation

◆ EffMap_t

typedef std::map< const hash_t, TEfficiency* > AthHistogramming::EffMap_t
privateinherited

Typedef for convenience.

Definition at line 199 of file AthHistogramming.h.

◆ GraphMap_t

typedef std::map< const hash_t, TGraph* > AthHistogramming::GraphMap_t
privateinherited

Typedef for convenience.

Definition at line 213 of file AthHistogramming.h.

◆ hash_t

typedef uint32_t AthHistogramming::hash_t
privateinherited

typedef for the internal hash

Definition at line 171 of file AthHistogramming.h.

◆ HistMap_t

typedef std::map< const hash_t, TH1* > AthHistogramming::HistMap_t
privateinherited

Typedef for convenience.

Definition at line 192 of file AthHistogramming.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ TreeMap_t

typedef std::map< const hash_t, TTree* > AthHistogramming::TreeMap_t
privateinherited

Typedef for convenience.

Definition at line 206 of file AthHistogramming.h.

Constructor & Destructor Documentation

◆ ~PixelRDOAnalysis()

ITk::PixelRDOAnalysis::~PixelRDOAnalysis ( )
default

Member Function Documentation

◆ AthHistogramAlgorithm()

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

Constructor with parameters:

Definition at line 40 of file AthHistogramAlgorithm.cxx.

32 :
33 ::AthAlgorithm( name, pSvcLocator ),
34 ::AthHistogramming( name ),
35 m_histSvc ( "THistSvc/THistSvc", name )
36{
37 //
38 // Property declaration
39 //
40 // The histogram service
41 declareProperty("THistSvc",
42 m_histSvc = ServiceHandle<ITHistSvc>("THistSvc/THistSvc", name),
43 "Handle to a THistSvc instance: it will be used to write "
44 "ROOT objects to ROOT files" );
45 // declareProperty("THistService", m_histSvc, "The THistSvc" );
46
47 declareProperty("RootStreamName", m_prefix = "/ANALYSIS", "Name of the output ROOT stream (file) that the THistSvc uses");
48 declareProperty("RootDirName", m_rootDir = "",
49 "Name of the ROOT directory inside the ROOT file where the histograms will go");
50
51 declareProperty( "HistNamePrefix", m_histNamePrefix = "", "The prefix for the histogram THx name" );
52 declareProperty( "HistNamePostfix", m_histNamePostfix = "", "The postfix for the histogram THx name" );
53
54 declareProperty( "HistTitlePrefix", m_histTitlePrefix = "", "The prefix for the histogram THx title" );
55 declareProperty( "HistTitlePostfix", m_histTitlePostfix = "", "The postfix for the histogram THx title" );
56}
AthAlgorithm::AthAlgorithm
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition AthAlgorithm.cxx:10
AthCommonAlgorithm< Gaudi::Algorithm >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
AthHistogramAlgorithm::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition AthHistogramAlgorithm.h:94
AthHistogramAlgorithm::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Default constructor: AthHistogramAlgorithm();.
Definition AthHistogramAlgorithm.h:83
AthHistogramAlgorithm::m_prefix
std::string m_prefix
Name of the ROOT output stream (file).
Definition AthHistogramAlgorithm.h:88
AthHistogramAlgorithm::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition AthHistogramAlgorithm.h:97
AthHistogramAlgorithm::m_histTitlePostfix
std::string m_histTitlePostfix
The postfix for the histogram THx title.
Definition AthHistogramAlgorithm.h:103
AthHistogramAlgorithm::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition AthHistogramAlgorithm.h:91
AthHistogramAlgorithm::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition AthHistogramAlgorithm.h:100
AthHistogramming::AthHistogramming
AthHistogramming(const std::string &name)
Constructor with parameters:
Definition AthHistogramming.cxx:39

◆ book() [1/8]

StatusCode AthHistogramming::book ( const TEfficiency & eff,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 329 of file AthHistogramming.h.

330{
331 // We need to create a non-const clone
332 TEfficiency* effClone = dynamic_cast< TEfficiency* >( eff.Clone() );
333 if ( !effClone ) {
334 m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone" << endmsg;
335 return StatusCode::FAILURE;
336 }
337 return this->book( *effClone, tDir, stream );
338}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:54
AthHistogramming::book
StatusCode book(const TH1 &hist, std::string_view tDir="", std::string_view stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition AthHistogramming.h:297
AthHistogramming::m_msg
MsgStream m_msg
Cached Message Stream.
Definition AthHistogramming.h:242
dqt_zlumi_alleff_HIST.eff
int eff
Definition dqt_zlumi_alleff_HIST.py:113

◆ book() [2/8]

StatusCode AthHistogramming::book ( const TGraph & graphRef,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TGraphs.

◆ book() [3/8]

StatusCode AthHistogramming::book ( const TH1 & hist,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 297 of file AthHistogramming.h.

298{
299 // We need to create a non-const clone
300 TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
301 if ( !histClone ) {
302 m_msg << MSG::ERROR << "Couldn't create a TH1 clone" << endmsg;
303 return StatusCode::FAILURE;
304 }
305 return this->book( *histClone, tDir, stream );
306}
AthHistogramming::hist
TH1 * hist(std::string_view histName, std::string_view tDir="", std::string_view stream="")
Simplify the retrieval of registered histograms of any type.
Definition AthHistogramming.cxx:182

◆ book() [4/8]

StatusCode AthHistogramming::book ( const TTree & treeRef,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TTrees.

Definition at line 397 of file AthHistogramming.h.

398{
399 // Call the other Book method and see if it returns a valid pointer
400 TTree* treePointer = this->bookGetPointer( treeRef, tDir, stream );
401 if ( treePointer )
402 {
403 return StatusCode::SUCCESS;
404 }
405 else
406 {
407 return StatusCode::FAILURE;
408 }
409}
AthHistogramming::bookGetPointer
TH1 * bookGetPointer(const TH1 &hist, std::string_view tDir="", std::string_view stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition AthHistogramming.h:254

◆ book() [5/8]

StatusCode AthHistogramming::book ( TEfficiency & effRef,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 350 of file AthHistogramming.h.

351{
352 // Call the other Book method and see if it returns a valid pointer
353 TEfficiency* effPointer = this->bookGetPointer( effRef, tDir, stream );
354 if ( !effPointer ) {
355 m_msg << MSG::ERROR << "Couldn't book a TEfficiency" << endmsg;
356 return StatusCode::FAILURE;
357 }
358 return StatusCode::SUCCESS;
359}

◆ book() [6/8]

StatusCode AthHistogramming::book ( TEfficiency * eff,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 340 of file AthHistogramming.h.

341{
342 if ( !eff ) {
343 m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency" << endmsg;
344 return StatusCode::FAILURE;
345 }
346 return this->book( *eff, tDir, stream );
347}

◆ book() [7/8]

StatusCode AthHistogramming::book ( TH1 & histRef,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 318 of file AthHistogramming.h.

319{
320 // Call the other Book method and see if it returns a valid pointer
321 TH1* histPointer = this->bookGetPointer( histRef, tDir, stream );
322 if ( !histPointer ) {
323 m_msg << MSG::ERROR << "Couldn't book a TH1" << endmsg;
324 return StatusCode::FAILURE;
325 }
326 return StatusCode::SUCCESS;
327}

◆ book() [8/8]

StatusCode AthHistogramming::book ( TH1 * hist,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 308 of file AthHistogramming.h.

309{
310 if ( !hist ) {
311 m_msg << MSG::ERROR << "Got a zero pointer to a TH1" << endmsg;
312 return StatusCode::FAILURE;
313 }
314 return this->book( *hist, tDir, stream );
315}

◆ bookGetPointer() [1/8]

TEfficiency * AthHistogramming::bookGetPointer ( const TEfficiency & eff,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 275 of file AthHistogramming.h.

276{
277 // We need to create a non-const clone
278 TEfficiency* histClone = dynamic_cast< TEfficiency* >( hist.Clone() );
279 if ( !histClone ) {
280 m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone in bookGetPointer" << endmsg;
281 return 0;
282 }
283 return this->bookGetPointer( *histClone, tDir, stream );
284
285}

◆ bookGetPointer() [2/8]

TGraph * AthHistogramming::bookGetPointer ( const TGraph & graphRef,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the booking and registering (into THistSvc) of TGraphs.

Definition at line 374 of file AthHistogramming.cxx.

375{
376 // Get a pointer
377 const TGraph* graphPointer = &graphRef;
378
379 // Check that we got a valid pointer
380 if ( !graphPointer )
381 {
382 m_msg << MSG::WARNING
383 << "We got an invalid TGraph pointer in the BookGetPointer(TGraph*) method of the class" << m_name
384 << "!" << endmsg;
385 return NULL;
386 }
387
388 // Modify the name and title according to the prefixes of this classes instance
389 std::string graphName = graphPointer->GetName();
390 const std::string graphTitle = graphPointer->GetTitle();
391
392 // Check if the hash for this graphName already exists, i.e., if we have a hash collision
393 const hash_t graphHash = this->hash(graphName);
394 GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
395 if ( it != m_graphMap.end() ) // It does exist!
396 {
397 m_msg << MSG::WARNING
398 << "Detected a hash collision. The hash for the TGraph with name=" << graphName
399 << " already exists and points to a TGraph with name=" << it->second->GetName()
400 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
401 return NULL;
402 }
403
404 // Create a clone that has the new name
405 TGraph* graphClone = dynamic_cast< TGraph* >( graphPointer->Clone((m_histNamePrefix+graphName+m_histNamePostfix).c_str()) );
406 if( !graphClone )
407 {
408 m_msg << MSG::WARNING
409 << "We couldn't clone the TGraph in the BookGetPointer(TGraph&) method of the class" << m_name
410 << "!" << endmsg;
411 return NULL;
412 }
413 graphClone->SetTitle ((m_histTitlePrefix+graphTitle+m_histTitlePostfix).c_str());
414
415 // Massage the final string to book things
416 std::string bookingString = buildBookingString( graphName, tDir, stream );
417
418 // Register the TGraph into the THistSvc
419 if ( !((histSvc()->regGraph(bookingString, graphClone)).isSuccess()) )
420 {
421 m_msg << MSG::WARNING
422 << "Problem registering TGraph with name " << graphName
423 << ", title " << graphTitle
424 << " in " << m_name << "!" << endmsg;
425 return NULL;
426 }
427
428 // Also register it in the local map of string to pointer
429 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphClone ) );
430
431 return graphClone;
432}
AthHistogramming::histSvc
const ServiceHandle< ITHistSvc > & histSvc() const
The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a...
Definition AthHistogramming.h:415
AthHistogramming::hash
hash_t hash(std::string_view histName) const
Method to calculate a 32-bit hash from a string.
Definition AthHistogramming.h:422
AthHistogramming::buildBookingString
std::string buildBookingString(std::string_view histName, std::string_view tDir, std::string_view stream, bool usePrefixPostfix=false) const
Method to build individual booking string.
Definition AthHistogramming.cxx:500
AthHistogramming::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition AthHistogramming.h:229
AthHistogramming::hash_t
uint32_t hash_t
typedef for the internal hash
Definition AthHistogramming.h:171
AthHistogramming::m_histTitlePostfix
std::string m_histTitlePostfix
The postfix for the histogram THx title.
Definition AthHistogramming.h:235
AthHistogramming::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition AthHistogramming.h:232
AthHistogramming::m_name
std::string m_name
Instance name.
Definition AthHistogramming.h:239
AthHistogramming::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition AthHistogramming.h:226
AthHistogramming::m_graphMap
GraphMap_t m_graphMap
The map of TGraph names to their pointers.
Definition AthHistogramming.h:216

◆ bookGetPointer() [3/8]

TH1 * AthHistogramming::bookGetPointer ( const TH1 & hist,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 254 of file AthHistogramming.h.

255{
256 // We need to create a non-const clone
257 TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
258 if ( !histClone ) {
259 m_msg << MSG::ERROR << "Couldn't create a TH1 clone in bookGetPointer" << endmsg;
260 return 0;
261 }
262 return this->bookGetPointer( *histClone, tDir, stream );
263
264}

◆ bookGetPointer() [4/8]

TTree * AthHistogramming::bookGetPointer ( const TTree & treeRef,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the booking and registering (into THistSvc) of TTrees.

Definition at line 268 of file AthHistogramming.cxx.

269{
270 // Get a pointer
271 const TTree* treePointer = &treeRef;
272
273 // Check that we got a valid pointer
274 if ( !treePointer )
275 {
276 m_msg << MSG::WARNING
277 << "We got an invalid TTree pointer in the BookGetPointer(TTree*) method of the class" << m_name
278 << "!" << endmsg;
279 return NULL;
280 }
281
282 // Modify the name and title according to the prefixes of this classes instance
283 std::string treeName = treePointer->GetName();
284 const std::string treeTitle = treePointer->GetTitle();
285
286 // Check if the hash for this treeName already exists, i.e., if we have a hash collision
287 const hash_t treeHash = this->hash(treeName);
288 TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
289 if ( it != m_treeMap.end() ) // It does exist!
290 {
291 m_msg << MSG::WARNING
292 << "Detected a hash collision. The hash for the TTree with name=" << treeName
293 << " already exists and points to a TTree with name=" << it->second->GetName()
294 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
295 return NULL;
296 }
297
298 // Create a clone that has the new name
299 TTree* treeClone = dynamic_cast< TTree* >( treePointer->Clone(treeName.c_str()) );
300 if( !treeClone )
301 {
302 m_msg << MSG::WARNING
303 << "We couldn't clone the TTree in the BookGetPointer(TTree&) method of the class" << m_name
304 << "!" << endmsg;
305 return NULL;
306 }
307 treeClone->SetTitle (treeTitle.c_str());
308
309 // Massage the final string to book things
310 std::string bookingString = buildBookingString( treeName, tDir, stream );
311
312 // Register the TTree into the THistSvc
313 if ( !((histSvc()->regTree(bookingString, treeClone)).isSuccess()) )
314 {
315 m_msg << MSG::WARNING
316 << "Problem registering TTree with name " << treeName
317 << ", title " << treeTitle
318 << " in " << m_name << "!" << endmsg;
319 return NULL;
320 }
321
322 // Also register it in the local map of string to pointer
323 m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treeClone ) );
324
325 return treeClone;
326}
AthHistogramming::m_treeMap
TreeMap_t m_treeMap
The map of TTree names to their pointers.
Definition AthHistogramming.h:209

◆ bookGetPointer() [5/8]

TEfficiency * AthHistogramming::bookGetPointer ( TEfficiency & effRef,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 139 of file AthHistogramming.cxx.

140{
141 std::string originalName{effRef.GetName()};
142 const auto effName = splitName(originalName).second;
143 const std::string effTitle(effRef.GetTitle());
144 std::string bookingString = buildBookingString(originalName, tDir, stream);
145 std::string finalEffName{m_histNamePrefix};
146 finalEffName += effName;
147 finalEffName += m_histNamePostfix;
148 effRef.SetTitle((m_histTitlePrefix + effTitle + m_histTitlePostfix).c_str());
149 effRef.SetName(finalEffName.c_str());
150
151 const hash_t effHash = this->hash(effName);
152 EffMap_t::const_iterator it = m_effMap.find(effHash);
153 if (it != m_effMap.end()) {
154 m_msg << MSG::WARNING
155 << "Detected a hash collision. The hash for the TEfficiency with name=" << effName
156 << " already exists and points to a TEfficiency with name=" << it->second->GetName()
157 << " NOT going to book the new TEfficiency and returning a NULL pointer!" << endmsg;
158 return nullptr;
159 }
160
161 if (!histSvc()->regEfficiency(bookingString, &effRef).isSuccess()) {
162 m_msg << MSG::WARNING
163 << "Problem registering TEfficiency with name " << effName
164 << ", name prefix " << m_histNamePrefix
165 << ", title " << effTitle
166 << ", title prefix " << m_histTitlePrefix
167 << ", and title postfix " << m_histTitlePostfix
168 << " in " << m_name << "!" << endmsg;
169 return nullptr;
170 }
171
172 m_effMap.insert(m_effMap.end(), std::pair<const hash_t, TEfficiency*>(effHash, &effRef));
173
174 return &effRef;
175}
AthHistogramming::m_effMap
EffMap_t m_effMap
The map of histogram names to their pointers.
Definition AthHistogramming.h:202

◆ bookGetPointer() [6/8]

TEfficiency * AthHistogramming::bookGetPointer ( TEfficiency * eff,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 287 of file AthHistogramming.h.

288{
289 if ( !hist ) {
290 m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency in bookGetPointer" << endmsg;
291 return 0;
292 }
293 return this->bookGetPointer( *hist, tDir, stream );
294}

◆ bookGetPointer() [7/8]

TH1 * AthHistogramming::bookGetPointer ( TH1 & histRef,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 97 of file AthHistogramming.cxx.

97 {
98
99 const std::string originalName{histRef.GetName()};
100 const auto histName = splitName(originalName).second;
101
102 const std::string histTitle(histRef.GetTitle());
103 std::string bookingString = buildBookingString(originalName, tDir, stream);
104
105 std::string finalHistName{m_histNamePrefix};
106 finalHistName += histName;
107 finalHistName += m_histNamePostfix;
108
109 histRef.SetTitle((m_histTitlePrefix + histTitle + m_histTitlePostfix).c_str());
110 histRef.SetName(finalHistName.c_str());
111
112 const hash_t histHash = this->hash(histName);
113 HistMap_t::const_iterator it = m_histMap.find(histHash);
114 if (it != m_histMap.end()) {
115 m_msg << MSG::WARNING
116 << "Detected a hash collision. The hash for the histogram with name=" << histName
117 << " already exists and points to a histogram with name=" << it->second->GetName()
118 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
119 return nullptr;
120 }
121
122 if (!histSvc()->regHist(bookingString, &histRef).isSuccess()) {
123 m_msg << MSG::WARNING
124 << "Problem registering histogram with name " << histName
125 << ", name prefix " << m_histNamePrefix
126 << ", title " << histTitle
127 << ", title prefix " << m_histTitlePrefix
128 << ", and title postfix " << m_histTitlePostfix
129 << " in " << m_name << "!" << endmsg;
130 return nullptr;
131 }
132
133 m_histMap.insert(m_histMap.end(), std::pair<const hash_t, TH1*>(histHash, &histRef));
134
135 return &histRef;
136}
AthHistogramming::m_histMap
HistMap_t m_histMap
The map of histogram names to their pointers.
Definition AthHistogramming.h:195

◆ bookGetPointer() [8/8]

TH1 * AthHistogramming::bookGetPointer ( TH1 * hist,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 266 of file AthHistogramming.h.

267{
268 if ( !hist ) {
269 m_msg << MSG::ERROR << "Got a zero pointer to a TH1 in bookGetPointer" << endmsg;
270 return 0;
271 }
272 return this->bookGetPointer( *hist, tDir, stream );
273}

◆ buildBookingString()

std::string AthHistogramming::buildBookingString ( std::string_view histName,
std::string_view tDir,
std::string_view stream,
bool usePrefixPostfix = false ) const
privateinherited

Method to build individual booking string.

Definition at line 500 of file AthHistogramming.cxx.

501 {
502 if (tDir.empty()) {
503 tDir = m_rootDir;
504 }
505 if (stream.empty()) {
506 stream = m_streamName;
507 }
508 const auto [histDir, baseName] = splitName(histName);
509 std::string bookingString{"/"};
510 bookingString += stream;
511 bookingString += '/';
512 bookingString += tDir;
513 if (!histDir.empty()) {
514 bookingString += '/';
515 bookingString += histDir;
516 }
517 bookingString += '/';
518 if (usePrefixPostfix) {
519 bookingString += m_histNamePrefix;
520 }
521 bookingString += baseName;
522 if (usePrefixPostfix) {
523 bookingString += m_histNamePostfix;
524 }
525 const auto tail = std::ranges::unique(
526 bookingString, [](char lhs, char rhs) { return lhs == '/' && rhs == '/'; });
527 bookingString.erase(tail.begin(), tail.end());
528 return bookingString;
529}
AthHistogramming::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition AthHistogramming.h:223
AthHistogramming::m_streamName
std::string m_streamName
Name of the ROOT output stream (file).
Definition AthHistogramming.h:220
tail
std::string tail(std::string s, const std::string &pattern)
tail of a string
Definition computils.cxx:461

◆ configAthHistogramming()

StatusCode AthHistogramming::configAthHistogramming ( const ServiceHandle< ITHistSvc > & histSvc,
const std::string & prefix,
const std::string & rootDir,
const std::string & histNamePrefix,
const std::string & histNamePostfix,
const std::string & histTitlePrefix,
const std::string & histTitlePostfix )
protectedinherited

To be called to fill the internal configuration.

Definition at line 64 of file AthHistogramming.cxx.

68{
69 m_histSvc = histSvc;
70 m_streamName = prefix;
71 m_rootDir = rootDir;
72 m_histNamePrefix = histNamePrefix;
73 m_histNamePostfix = histNamePostfix;
74 m_histTitlePrefix = histTitlePrefix;
75 m_histTitlePostfix = histTitlePostfix;
76
77 return StatusCode::SUCCESS;
78}
AthHistogramming::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Pointer to the THistSvc (event store by default).
Definition AthHistogramming.h:188

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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 }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
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

◆ detStore()

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

◆ efficiency()

TEfficiency * AthHistogramming::efficiency ( std::string_view effName,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the retrieval of registered TEfficiency.

Definition at line 214 of file AthHistogramming.cxx.

215{
216 // Build a 32 bit hash out of the name
217 const hash_t effHash = this->hash(effName);
218
219 // See if this entry exists in the map
220 EffMap_t::const_iterator it = m_effMap.find( effHash );
221 if ( it == m_effMap.end() ) // It doesn't exist!
222 { // Let's see into the THistSvc if somebody else has registered the TEfficiency...
223 // Massage the final string to book things
224 std::string bookingString = buildBookingString(effName, tDir, stream ,false);
225
226 TEfficiency* effPointer{};
227 if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
228 {
229 // Book things
230 std::string bookingString = buildBookingString( effName, tDir, stream, true );
231
232 if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
233 {
234 m_msg << MSG::WARNING
235 << "Problem retrieving the TEfficiency with name (including pre- and post-fixes) "
236 << bookingString
237 << " or with name " << effName
238 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
239 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
240 return NULL;
241 }
242 // If we get to here, we actually found the TEfficiency in the THistSvc.
243 // So let's add it to the local cache map and return its pointer
244 m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
245 return effPointer;
246 }
247 // If we get to here, we actually found the TEfficiency in the THistSvc.
248 // So let's add it to the local cache map and return its pointer
249 m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
250 return effPointer;
251 }
252
253 // Return the pointer to the TEfficiency that we got from the local cache map
254 return it->second;
255}
AthenaInternal::getEfficiency
std::pair< StatusCode, TEfficiency * > getEfficiency(ITHistSvc &svc, const std::string &name)
Definition AthenaPythonDict.h:59

◆ evtStore()

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

◆ execute()

StatusCode PixelRDOAnalysis::execute ( const EventContext & ctx)
finaloverridevirtual

Execute method.

Implements AthAlgorithm.

Definition at line 351 of file ITkPixelRDOAnalysis.cxx.

351 {
352 ATH_MSG_DEBUG(" In ITkPixelRDOAnalysis::execute()" );
353
354 m_rdoID->clear();
355 m_rdoWord->clear();
356 m_barrelEndcap->clear();
357 m_layerDisk->clear();
358 m_phiModule->clear();
359 m_etaModule->clear();
360 m_phiIndex->clear();
361 m_etaIndex->clear();
362 m_isInnermost->clear();
363 m_isNextToInnermost->clear();
364 m_ToT->clear();
365 m_BCID->clear();
366 m_LVL1A->clear();
367 m_LVL1ID->clear();
368 m_sdoID->clear();
369 m_sdoWord->clear();
370 m_barrelEndcap_sdo->clear();
371 m_layerDisk_sdo->clear();
372 m_phiModule_sdo->clear();
373 m_etaModule_sdo->clear();
374 m_phiIndex_sdo->clear();
375 m_etaIndex_sdo->clear();
376 m_noise->clear();
377 m_belowThresh->clear();
378 m_disabled->clear();
379 m_badTOT->clear();
380 m_barcode->clear();
381 m_eventIndex->clear();
382 m_charge->clear();
383 m_barcode_vec->clear();
384 m_eventIndex_vec->clear();
385 m_charge_vec->clear();
386 if (m_doPosition) {
387 m_globalX->clear();
388 m_globalY->clear();
389 m_globalZ->clear();
390 m_localX->clear();
391 m_localY->clear();
392 m_localZ->clear();
393 }
394 // Raw Data
395
396 const PixelRDO_Container* p_pixelRDO_cont{nullptr};
397 ATH_CHECK(SG::get(p_pixelRDO_cont, m_inputKey, ctx));
398 //Adding SimMap and McEvent here for added truthMatching checks
399 const InDetSimDataCollection* simDataMapPixel{nullptr};
400 ATH_CHECK(SG::get(simDataMapPixel, m_inputTruthKey, ctx));
401 const McEventCollection* mcEventCollection{nullptr};
402 ATH_CHECK(SG::get(mcEventCollection, m_inputMcEventCollectionKey, ctx));
403 bool doTruthMatching = true;
404 const HepMC::GenEvent* hardScatterEvent(nullptr);
405
406 if (mcEventCollection->size()==0){
407 ATH_MSG_WARNING("Failed to retrieve a nonzero sized truth event collection, disabling truthMatching");
408 doTruthMatching = false;
409 }
410 if(doTruthMatching) hardScatterEvent = mcEventCollection->at(0);
411
412 if(p_pixelRDO_cont) {
413 // loop over RDO container
414 PixelRDO_Container::const_iterator rdoCont_itr(p_pixelRDO_cont->begin());
415 const PixelRDO_Container::const_iterator rdoCont_end(p_pixelRDO_cont->end());
416 for ( ; rdoCont_itr != rdoCont_end; ++rdoCont_itr ) {
417 const PixelRDO_Collection* p_pixelRDO_coll(*rdoCont_itr);
418 PixelRDO_Collection::const_iterator rdo_itr(p_pixelRDO_coll->begin());
419 const PixelRDO_Collection::const_iterator rdo_end(p_pixelRDO_coll->end());
420
421 const Identifier rdoIDColl(p_pixelRDO_coll->identify());
422 const int pixBrlEc(m_pixelID->barrel_ec(rdoIDColl));
423 const int pixLayerDisk(m_pixelID->layer_disk(rdoIDColl));
424 const int pixPhiMod(m_pixelID->phi_module(rdoIDColl));
425 const int pixEtaMod(m_pixelID->eta_module(rdoIDColl));
426 const int pixIsInnermost(0);
427 const int pixIsNextToInnermost(0);
428 //These are not yet implemented! Need to
429 //const int pixIsInnermost(m_pixelID->is_innermost(rdoIDColl));
430 //const int pixIsNextToInnermost(m_pixelID->is_nexttoinnermost(rdoIDColl));
431
432 const InDetDD::SiDetectorElement *detEl = m_pixelManager->getDetectorElement(rdoIDColl);
433
434 for ( ; rdo_itr != rdo_end; ++rdo_itr ) {
435 if(doTruthMatching){
436 m_h_truthMatchedRDOs->Fill(1.5);
437 bool findMatch = false;
438 if(simDataMapPixel){
439 InDetSimDataCollection::const_iterator iter = (*simDataMapPixel).find((*rdo_itr)->identify());
440
441 if ( iter != (*simDataMapPixel).end() ) {
442 const InDetSimData& sdo = iter->second;
443 const std::vector< InDetSimData::Deposit >& deposits = sdo.getdeposits();
444 std::vector< InDetSimData::Deposit >::const_iterator nextdeposit = deposits.begin();
445 std::vector< InDetSimData::Deposit >::const_iterator lastdeposit = deposits.end();
446 for( ; nextdeposit!=lastdeposit; ++nextdeposit) {
447 const HepMcParticleLink& particleLink = nextdeposit->first;
448 if(particleLink.isValid() && !findMatch){
449 HepMC::ConstGenParticlePtr genPart(particleLink.cptr());
450 if(genPart->parent_event() == hardScatterEvent) m_h_truthMatchedRDOs->Fill(3.5);
451 m_h_truthMatchedRDOs->Fill(2.5);
452 findMatch = true;
453 }
454 }
455 }
456 }
457 if(!findMatch) m_h_truthMatchedRDOs->Fill(4.5);
458 }
459 const Identifier rdoID((*rdo_itr)->identify());
460 const unsigned int rdoWord((*rdo_itr)->getWord());
461 const int pixPhiIx(m_pixelID->phi_index(rdoID));
462 const int pixEtaIx(m_pixelID->eta_index(rdoID));
463 const int pixToT((*rdo_itr)->getToT());
464 const int pixBCID((*rdo_itr)->getBCID());
465 const int pixLVL1A((*rdo_itr)->getLVL1A());
466 const int pixLVL1ID((*rdo_itr)->getLVL1ID());
467
468 //NB This is the position without lorentz correction
469 //(ATLSWUPGR-103)
470 //NB rationlization as here should probably also be done in master
471 //https://gitlab.cern.ch/atlas/athena/-/merge_requests/33398
472 InDetDD::SiLocalPosition localPos = detEl->rawLocalPositionOfCell(rdoID);
473 Amg::Vector3D globalPos = detEl->globalPosition(localPos);
474 if (m_doPosition) {
475 m_globalX->push_back(globalPos[Amg::x]);
476 m_globalY->push_back(globalPos[Amg::y]);
477 m_globalZ->push_back(globalPos[Amg::z]);
478
479 m_localX->push_back(localPos.xPhi());
480 m_localY->push_back(localPos.xEta());
481 m_localZ->push_back(localPos.xDepth());
482 }
483 float pixelRadius = sqrt(globalPos[Amg::x]*globalPos[Amg::x]+globalPos[Amg::y]*globalPos[Amg::y]);
484 m_h_globalXY->Fill(globalPos[Amg::x],globalPos[Amg::y]);
485 m_h_globalXY_shared->Fill(globalPos[Amg::x],globalPos[Amg::y]);
486 m_h_globalZR->Fill(globalPos[Amg::z],pixelRadius);
487 m_h_globalZR_shared->Fill(globalPos[Amg::z],pixelRadius);
488 m_h_globalX->Fill(globalPos[Amg::x]);
489 m_h_globalY->Fill(globalPos[Amg::y]);
490 m_h_globalZ->Fill(globalPos[Amg::z]);
491 const unsigned long long rdoID_int = rdoID.get_compact();
492 m_rdoID->push_back(rdoID_int);
493 m_rdoWord->push_back(rdoWord);
494 m_barrelEndcap->push_back(pixBrlEc);
495 m_layerDisk->push_back(pixLayerDisk);
496 m_phiModule->push_back(pixPhiMod);
497 m_etaModule->push_back(pixEtaMod);
498 m_isInnermost->push_back(pixIsInnermost);
499 m_isNextToInnermost->push_back(pixIsNextToInnermost);
500 m_phiIndex->push_back(pixPhiIx);
501 m_etaIndex->push_back(pixEtaIx);
502 m_ToT->push_back(pixToT);
503 m_BCID->push_back(pixBCID);
504 m_LVL1A->push_back(pixLVL1A);
505 m_LVL1ID->push_back(pixLVL1ID);
506
507 m_h_rdoID->Fill(rdoID_int);
508 m_h_rdoWord->Fill(rdoWord);
509 m_h_barrelEndcap->Fill(pixBrlEc);
510 m_h_layerDisk->Fill(pixLayerDisk);
511 m_h_phiModule->Fill(pixPhiMod);
512 m_h_etaModule->Fill(pixEtaMod);
513 m_h_phiIndex->Fill(pixPhiIx);
514 m_h_etaIndex->Fill(pixEtaIx);
515 m_h_ToT->Fill(pixToT);
516 m_h_BCID->Fill(pixBCID);
517 m_h_LVL1A->Fill(pixLVL1A);
518 m_h_LVL1ID->Fill(pixLVL1ID);
519
520 if (pixIsInnermost) {
521 m_h_phiIndexInnermost->Fill(pixPhiIx);
522 m_h_etaIndexInnermost->Fill(pixEtaIx);
523 } else if (pixIsNextToInnermost) {
524 m_h_phiIndexNextToInnermost->Fill(pixPhiIx);
525 m_h_etaIndexNextToInnermost->Fill(pixEtaIx);
526 }
527
528 //isInclined not yet implemented
529 //if (detEl->isBarrel() || detEl->isInclined()) {
530 if (detEl->isBarrel()){
531 m_h_brlLayer->Fill(pixLayerDisk);
532 m_h_brlPhiMod->Fill(pixPhiMod);
533 m_h_brlEtaMod->Fill(pixEtaMod);
534 m_h_brlPhiIndex->Fill(pixPhiIx);
535 m_h_brlEtaIndex->Fill(pixEtaIx);
536 m_h_brlToT->Fill(pixToT);
537 m_h_brlBCID->Fill(pixBCID);
538 m_h_brlLVL1A->Fill(pixLVL1A);
539 m_h_brlLVL1ID->Fill(pixLVL1ID);
540
541 //if (detEl->isInclined()) {
542 // m_h_brlinclPhiIndex_perLayer[pixLayerDisk]->Fill(pixPhiIx);
543 // m_h_brlinclEtaIndex_perLayer[pixLayerDisk]->Fill(pixEtaIx);
544 //} else {
545 m_h_brlflatPhiIndex_perLayer[pixLayerDisk]->Fill(pixPhiIx);
546 m_h_brlflatEtaIndex_perLayer[pixLayerDisk]->Fill(pixEtaIx);
547 //}
548
549 }
550 else if (detEl->isEndcap()) {
551 m_h_ecDisk->Fill(pixLayerDisk);
552 m_h_ecPhiMod->Fill(pixPhiMod);
553 m_h_ecEtaMod->Fill(pixEtaMod);
554 m_h_ecPhiIndex->Fill(pixPhiIx);
555 m_h_ecEtaIndex->Fill(pixEtaIx);
556 m_h_ecToT->Fill(pixToT);
557 m_h_ecBCID->Fill(pixBCID);
558 m_h_ecLVL1A->Fill(pixLVL1A);
559 m_h_ecLVL1ID->Fill(pixLVL1ID);
560
561 m_h_ecPhiIndex_perLayer[pixLayerDisk]->Fill(pixPhiIx);
562 m_h_ecEtaIndex_perLayer[pixLayerDisk]->Fill(pixEtaIx);
563
564 }
565 }
566 }
567 }
568
569 // Sim Data
570 if(simDataMapPixel) {
571 // loop over SDO container
572 InDetSimDataCollection::const_iterator sdo_itr(simDataMapPixel->begin());
573 const InDetSimDataCollection::const_iterator sdo_end(simDataMapPixel->end());
574
575 std::vector<int> barcode_vec;
576 std::vector<int> eventIndex_vec;
577 std::vector<float> charge_vec;
578 for ( ; sdo_itr != sdo_end; ++sdo_itr ) {
579 const Identifier sdoID((*sdo_itr).first);
580 const InDetSimData& sdo((*sdo_itr).second);
581 const unsigned long long sdoID_int = sdoID.get_compact();
582 const int sdoWord(sdo.word());
583 const int pixBrlEc_sdo(m_pixelID->barrel_ec(sdoID));
584 const int pixLayerDisk_sdo(m_pixelID->layer_disk(sdoID));
585 const int pixPhiMod_sdo(m_pixelID->phi_module(sdoID));
586 const int pixEtaMod_sdo(m_pixelID->eta_module(sdoID));
587 const int pixPhiIx_sdo(m_pixelID->phi_index(sdoID));
588 const int pixEtaIx_sdo(m_pixelID->eta_index(sdoID));
589 const bool noise(PixelSimHelper::isNoise(sdo));
590 const bool belowThresh(PixelSimHelper::isBelowThreshold(sdo));
591 const bool disabled(PixelSimHelper::isDisabled(sdo));
592 const bool badTOT(PixelSimHelper::hasBadTOT(sdo));
593
594 m_sdoID->push_back(sdoID_int);
595 m_sdoWord->push_back(sdoWord);
596 m_barrelEndcap_sdo->push_back(pixBrlEc_sdo);
597 m_layerDisk_sdo->push_back(pixLayerDisk_sdo);
598 m_phiModule_sdo->push_back(pixPhiMod_sdo);
599 m_etaModule_sdo->push_back(pixEtaMod_sdo);
600 m_phiIndex_sdo->push_back(pixPhiIx_sdo);
601 m_etaIndex_sdo->push_back(pixEtaIx_sdo);
602 m_noise->push_back(noise);
603
604 m_belowThresh->push_back(belowThresh);
605 if (belowThresh) {
606 if (pixBrlEc_sdo==0)
607 m_h_belowThresh_brl->Fill(pixLayerDisk_sdo);
608 else if (abs(pixBrlEc_sdo)==2)
609 m_h_belowThresh_ec->Fill(pixLayerDisk_sdo);
610 }
611
612 m_disabled->push_back(disabled);
613 if (disabled) {
614 if (pixBrlEc_sdo==0)
615 m_h_disabled_brl->Fill(pixLayerDisk_sdo);
616 else if (abs(pixBrlEc_sdo)==2)
617 m_h_disabled_ec->Fill(pixLayerDisk_sdo);
618 }
619
620 m_badTOT->push_back(badTOT);
621
622 m_h_sdoID->Fill(sdoID_int);
623 m_h_sdoWord->Fill(sdoWord);
624 m_h_barrelEndcap_sdo->Fill(pixBrlEc_sdo);
625 m_h_layerDisk_sdo->Fill(pixLayerDisk_sdo);
626 m_h_phiModule_sdo->Fill(pixPhiMod_sdo);
627 m_h_etaModule_sdo->Fill(pixEtaMod_sdo);
628 m_h_phiIndex_sdo->Fill(pixPhiIx_sdo);
629 m_h_etaIndex_sdo->Fill(pixEtaIx_sdo);
630
631 // loop over deposits
632 const std::vector<InDetSimData::Deposit>& deposits = sdo.getdeposits();
633 std::vector<InDetSimData::Deposit>::const_iterator dep_itr(deposits.begin());
634 const std::vector<InDetSimData::Deposit>::const_iterator dep_end(deposits.end());
635 for ( ; dep_itr != dep_end; ++dep_itr ) {
636 const HepMcParticleLink& particleLink = (*dep_itr).first;
637 const int bar(HepMC::barcode(particleLink)); // FIXME barcode-based
638 const int eventIx(particleLink.eventIndex());
639 const int charge((*dep_itr).second);
640
641 m_barcode->push_back(bar);
642 m_eventIndex->push_back(eventIx);
643 m_charge->push_back(charge);
644
645 m_h_barcode->Fill(bar);
646 m_h_eventIndex->Fill(eventIx);
647 m_h_charge->Fill(charge);
648
649 barcode_vec.push_back(bar);
650 eventIndex_vec.push_back(eventIx);
651 charge_vec.push_back(charge);
652 }
653 m_barcode_vec->push_back(barcode_vec);
654 m_eventIndex_vec->push_back(eventIndex_vec);
655 m_charge_vec->push_back(charge_vec);
656 barcode_vec.clear();
657 eventIndex_vec.clear();
658 charge_vec.clear();
659 }
660 }
661
662 m_tree->Fill();
663
664 return StatusCode::SUCCESS;
665}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x,...)
Definition AthMsgStreamMacros.h:46
charge
double charge(const T &p)
Definition AtlasPID.h:1003
PixelRDO_Collection
InDetRawDataCollection< PixelRDORawData > PixelRDO_Collection
Definition PixelRDO_Collection.h:22
PixelRDO_Container
InDetRawDataContainer< InDetRawDataCollection< PixelRDORawData > > PixelRDO_Container
Definition PixelRDO_Container.h:25
InDetRawDataCollection< PixelRDORawData >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:861
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
ITk::PixelRDOAnalysis::m_inputTruthKey
SG::ReadHandleKey< InDetSimDataCollection > m_inputTruthKey
Definition ITkPixelRDOAnalysis.h:46
ITk::PixelRDOAnalysis::m_h_ecEtaIndex_perLayer
std::vector< TH1 * > m_h_ecEtaIndex_perLayer
Definition ITkPixelRDOAnalysis.h:168
ITk::PixelRDOAnalysis::m_globalZ
std::vector< double > * m_globalZ
Definition ITkPixelRDOAnalysis.h:81
ITk::PixelRDOAnalysis::m_sdoID
std::vector< unsigned long long > * m_sdoID
Definition ITkPixelRDOAnalysis.h:87
ITk::PixelRDOAnalysis::m_inputMcEventCollectionKey
SG::ReadHandleKey< McEventCollection > m_inputMcEventCollectionKey
Definition ITkPixelRDOAnalysis.h:47
ITk::PixelRDOAnalysis::m_etaIndex
std::vector< int > * m_etaIndex
Definition ITkPixelRDOAnalysis.h:70
ITk::PixelRDOAnalysis::m_barrelEndcap_sdo
std::vector< int > * m_barrelEndcap_sdo
Definition ITkPixelRDOAnalysis.h:90
ITk::PixelRDOAnalysis::m_pixelManager
const InDetDD::PixelDetectorManager * m_pixelManager
Definition ITkPixelRDOAnalysis.h:49
ITk::PixelRDOAnalysis::m_noise
std::vector< bool > * m_noise
Definition ITkPixelRDOAnalysis.h:97
ITk::PixelRDOAnalysis::m_phiIndex
std::vector< int > * m_phiIndex
Definition ITkPixelRDOAnalysis.h:69
ITk::PixelRDOAnalysis::m_rdoWord
std::vector< unsigned int > * m_rdoWord
Definition ITkPixelRDOAnalysis.h:63
ITk::PixelRDOAnalysis::m_localX
std::vector< double > * m_localX
Definition ITkPixelRDOAnalysis.h:82
ITk::PixelRDOAnalysis::m_localZ
std::vector< double > * m_localZ
Definition ITkPixelRDOAnalysis.h:84
ITk::PixelRDOAnalysis::m_LVL1A
std::vector< int > * m_LVL1A
Definition ITkPixelRDOAnalysis.h:76
ITk::PixelRDOAnalysis::m_charge
std::vector< int > * m_charge
Definition ITkPixelRDOAnalysis.h:104
ITk::PixelRDOAnalysis::m_h_ecPhiIndex_perLayer
std::vector< TH1 * > m_h_ecPhiIndex_perLayer
Definition ITkPixelRDOAnalysis.h:167
ITk::PixelRDOAnalysis::m_eventIndex
std::vector< int > * m_eventIndex
Definition ITkPixelRDOAnalysis.h:103
ITk::PixelRDOAnalysis::m_globalX
std::vector< double > * m_globalX
Definition ITkPixelRDOAnalysis.h:79
ITk::PixelRDOAnalysis::m_barrelEndcap
std::vector< int > * m_barrelEndcap
Definition ITkPixelRDOAnalysis.h:65
ITk::PixelRDOAnalysis::m_barcode
std::vector< int > * m_barcode
Definition ITkPixelRDOAnalysis.h:102
ITk::PixelRDOAnalysis::m_phiModule_sdo
std::vector< int > * m_phiModule_sdo
Definition ITkPixelRDOAnalysis.h:92
ITk::PixelRDOAnalysis::m_barcode_vec
std::vector< std::vector< int > > * m_barcode_vec
Definition ITkPixelRDOAnalysis.h:105
ITk::PixelRDOAnalysis::m_charge_vec
std::vector< std::vector< float > > * m_charge_vec
Definition ITkPixelRDOAnalysis.h:107
ITk::PixelRDOAnalysis::m_h_globalXY_shared
LockedHandle< TH2 > m_h_globalXY_shared
Definition ITkPixelRDOAnalysis.h:178
ITk::PixelRDOAnalysis::m_rdoID
std::vector< unsigned long long > * m_rdoID
Definition ITkPixelRDOAnalysis.h:62
ITk::PixelRDOAnalysis::m_layerDisk_sdo
std::vector< int > * m_layerDisk_sdo
Definition ITkPixelRDOAnalysis.h:91
ITk::PixelRDOAnalysis::m_sdoWord
std::vector< int > * m_sdoWord
Definition ITkPixelRDOAnalysis.h:88
ITk::PixelRDOAnalysis::m_ToT
std::vector< int > * m_ToT
Definition ITkPixelRDOAnalysis.h:74
ITk::PixelRDOAnalysis::m_h_globalZR_shared
LockedHandle< TH2 > m_h_globalZR_shared
Definition ITkPixelRDOAnalysis.h:179
ITk::PixelRDOAnalysis::m_localY
std::vector< double > * m_localY
Definition ITkPixelRDOAnalysis.h:83
ITk::PixelRDOAnalysis::m_BCID
std::vector< int > * m_BCID
Definition ITkPixelRDOAnalysis.h:75
ITk::PixelRDOAnalysis::m_eventIndex_vec
std::vector< std::vector< int > > * m_eventIndex_vec
Definition ITkPixelRDOAnalysis.h:106
ITk::PixelRDOAnalysis::m_globalY
std::vector< double > * m_globalY
Definition ITkPixelRDOAnalysis.h:80
ITk::PixelRDOAnalysis::m_phiModule
std::vector< int > * m_phiModule
Definition ITkPixelRDOAnalysis.h:67
ITk::PixelRDOAnalysis::m_doPosition
Gaudi::Property< bool > m_doPosition
Definition ITkPixelRDOAnalysis.h:59
ITk::PixelRDOAnalysis::m_layerDisk
std::vector< int > * m_layerDisk
Definition ITkPixelRDOAnalysis.h:66
ITk::PixelRDOAnalysis::m_belowThresh
std::vector< bool > * m_belowThresh
Definition ITkPixelRDOAnalysis.h:98
ITk::PixelRDOAnalysis::m_h_brlflatEtaIndex_perLayer
std::vector< TH1 * > m_h_brlflatEtaIndex_perLayer
Definition ITkPixelRDOAnalysis.h:165
ITk::PixelRDOAnalysis::m_phiIndex_sdo
std::vector< int > * m_phiIndex_sdo
Definition ITkPixelRDOAnalysis.h:94
ITk::PixelRDOAnalysis::m_etaIndex_sdo
std::vector< int > * m_etaIndex_sdo
Definition ITkPixelRDOAnalysis.h:95
ITk::PixelRDOAnalysis::m_LVL1ID
std::vector< int > * m_LVL1ID
Definition ITkPixelRDOAnalysis.h:77
ITk::PixelRDOAnalysis::m_isInnermost
std::vector< int > * m_isInnermost
Definition ITkPixelRDOAnalysis.h:71
ITk::PixelRDOAnalysis::m_etaModule
std::vector< int > * m_etaModule
Definition ITkPixelRDOAnalysis.h:68
ITk::PixelRDOAnalysis::m_disabled
std::vector< bool > * m_disabled
Definition ITkPixelRDOAnalysis.h:99
ITk::PixelRDOAnalysis::m_badTOT
std::vector< bool > * m_badTOT
Definition ITkPixelRDOAnalysis.h:100
ITk::PixelRDOAnalysis::m_isNextToInnermost
std::vector< int > * m_isNextToInnermost
Definition ITkPixelRDOAnalysis.h:72
ITk::PixelRDOAnalysis::m_h_brlflatPhiIndex_perLayer
std::vector< TH1 * > m_h_brlflatPhiIndex_perLayer
Definition ITkPixelRDOAnalysis.h:164
ITk::PixelRDOAnalysis::m_inputKey
SG::ReadHandleKey< PixelRDO_Container > m_inputKey
Definition ITkPixelRDOAnalysis.h:45
ITk::PixelRDOAnalysis::m_etaModule_sdo
std::vector< int > * m_etaModule_sdo
Definition ITkPixelRDOAnalysis.h:93
IdentifiableContainerMT::const_iterator
Definition IdentifiableContainerMT.h:81
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition IdentifiableContainerMT.h:247
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition IdentifiableContainerMT.h:241
InDetDD::SiLocalPosition::xDepth
double xDepth() const
position along depth direction:
Definition SiLocalPosition.h:128
InDetDD::SiLocalPosition::xPhi
double xPhi() const
position along phi direction:
Definition SiLocalPosition.h:123
InDetDD::SiLocalPosition::xEta
double xEta() const
position along eta direction:
Definition SiLocalPosition.h:118
InDetDD::SolidStateDetectorElementBase::globalPosition
HepGeom::Point3D< double > globalPosition(const HepGeom::Point3D< double > &localPos) const
transform a reconstruction local position into a global position (inline):
InDetDD::SolidStateDetectorElementBase::rawLocalPositionOfCell
Amg::Vector2D rawLocalPositionOfCell(const SiCellId &cellId) const
Returns position (center) of cell.
Definition SolidStateDetectorElementBase.cxx:230
InDetSimData::word
int word() const
Definition InDetSimData.h:69
InDetSimData::getdeposits
const std::vector< Deposit > & getdeposits() const
Definition InDetSimData.h:74
PixelSimHelper::isBelowThreshold
static bool isBelowThreshold(const InDetSimData &sdo)
Definition PixelSimHelper.h:114
PixelSimHelper::hasBadTOT
static bool hasBadTOT(const InDetSimData &sdo)
Definition PixelSimHelper.h:124
PixelSimHelper::isNoise
static bool isNoise(const InDetSimData &sdo)
Definition PixelSimHelper.h:109
PixelSimHelper::isDisabled
static bool isDisabled(const InDetSimData &sdo)
Definition PixelSimHelper.h:119
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:48
HepMC::barcode
int barcode(const T *p)
Definition Barcode.h:15
HepMC::ConstGenParticlePtr
HepMC3::ConstGenParticlePtr ConstGenParticlePtr
Definition GenParticle.h:20
HepMC::GenEvent
HepMC3::GenEvent GenEvent
Definition GenEvent.h:39
SCT_Monitoring::disabled
@ disabled
Definition SCT_MonitoringNumbers.h:60
SG::get
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
Definition ReadCondHandle.h:281

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
58 return m_extendedExtraObjects;
59 }
60 return BaseAlg::extraOutputDeps();
61}
AthCommonAlgorithm
Common base class for algorithms.
Definition AthCommonAlgorithm.h:38

◆ filterPassed()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx) const
inlinevirtualinherited

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
AthCommonAlgorithm::filterPassed
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:
Definition AthCommonAlgorithm.h:93

◆ graph()

TGraph * AthHistogramming::graph ( std::string_view graphName,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the retrieval of registered TGraphs.

Definition at line 438 of file AthHistogramming.cxx.

439{
440 // Build a 32 bit hash out of the name
441 const hash_t graphHash = this->hash(graphName);
442
443 // See if this entry exists in the map
444 GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
445 if ( it == m_graphMap.end() ) // It doesn't exist!
446 { // Let's see into the THistSvc if somebody else has registered the TGraph...
447
448 // Massage the final string to book things
449 std::string bookingString = buildBookingString( graphName, tDir, stream, false);
450
451 TGraph* graphPointer(nullptr);
452 if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
453 {
454 // Massage the final string to book things
455 std::string bookingString = buildBookingString( graphName, tDir, stream, true );
456
457 if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
458 {
459 m_msg << MSG::WARNING
460 << "Problem retrieving the TGraph with name (including pre- and post-fixes) "
461 << bookingString
462 << " or with name " << graphName
463 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
464 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
465 return nullptr;
466 }
467 // If we get to here, we actually found the TGraph in the THistSvc.
468 // So let's add it to the local cache map and return its pointer
469 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
470 return graphPointer;
471 }
472 // If we get to here, we actually found the TGraph in the THistSvc.
473 // So let's add it to the local cache map and return its pointer
474 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
475 return graphPointer;
476 }
477
478
479 // Return the pointer to the TGraph that we got from the local cache map
480 return it->second;
481}
AthenaInternal::getGraph
std::pair< StatusCode, TGraph * > getGraph(ITHistSvc &svc, const std::string &name)
Definition AthenaPythonDict.h:51

◆ hash()

AthHistogramming::hash_t AthHistogramming::hash ( std::string_view histName) const
inlineprivateinherited

Method to calculate a 32-bit hash from a string.

Definition at line 422 of file AthHistogramming.h.

423{
424 const uint64_t hash64 = CxxUtils::crc64( std::string{histName} );
425 return (hash_t)(hash64 & 0xFFFFFFFF);
426}
CxxUtils::crc64
uint64_t crc64(const CRCTable &table, const char *data, size_t data_len)
Find the CRC-64 of a string,.
Definition crc64.cxx:695
xxh3::hash64
std::uint64_t hash64(const void *data, std::size_t size)
Passthrough to XXH3_64bits.
Definition XXH.cxx:9

◆ hist()

TH1 * AthHistogramming::hist ( std::string_view histName,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the retrieval of registered histograms of any type.

Definition at line 182 of file AthHistogramming.cxx.

183 {
184
185 const auto histBaseName = splitName(histName).second;
186 std::string bookingString = buildBookingString(histName, tDir, stream, false);
187
188 const hash_t histHash = this->hash(histBaseName);
189
190 HistMap_t::const_iterator it = m_histMap.find(histHash);
191 if (it == m_histMap.end()) {
192 TH1* histPointer(nullptr);
193
194 if (!histSvc()->getHist(bookingString, histPointer).isSuccess()) {
195 std::string prefixedBookingString = buildBookingString(histName, tDir, stream, true);
196 if (!histSvc()->getHist(prefixedBookingString, histPointer).isSuccess()) {
197 m_msg << MSG::WARNING
198 << "Problem retrieving the histogram with name (including pre- and post-fixes) "
199 << prefixedBookingString
200 << " or with name " << histName
201 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
202 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
203 return nullptr;
204 }
205 }
206
207 m_histMap.insert(m_histMap.end(), std::pair<const hash_t, TH1*>(histHash, histPointer));
208 return histPointer;
209 }
210
211 return it->second;
212}
AthenaInternal::getHist
std::pair< StatusCode, TH1 * > getHist(ITHistSvc &svc, const std::string &name, size_t index=0)
Definition AthenaPythonDict.h:42

◆ hist2d()

TH2 * AthHistogramming::hist2d ( std::string_view histName,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the retrieval of registered 2-d histograms.

Definition at line 363 of file AthHistogramming.h.

364{
365 // Get the TH1 pointer
366 TH1* th1Pointer = this->hist(histName, tDir, stream);
367 if ( !th1Pointer )
368 {
369 m_msg << MSG::ERROR
370 << "Cannot get a 2-d histogram with name " << histName
371 << "... will probably seg-fault!" << endmsg;
372 return NULL;
373 }
374 // If the TH1 pointer is valid, simply return the dynamic_cast
375 return dynamic_cast<TH2*>( th1Pointer );
376}

◆ hist3d()

TH3 * AthHistogramming::hist3d ( std::string_view histName,
std::string_view tDir = "",
std::string_view stream = "" )
inlineprotectedinherited

Simplify the retrieval of registered 3-d histograms.

Definition at line 380 of file AthHistogramming.h.

381{
382 // Get the TH1 pointer
383 TH1* th1Pointer = this->hist(histName, tDir, stream);
384 if ( !th1Pointer )
385 {
386 m_msg << MSG::ERROR
387 << "Cannot get a 3-d histogram with name " << histName
388 << "... will probably seg-fault!" << endmsg;
389 return NULL;
390 }
391 // If the TH1 pointer is valid, simply return the dynamic_cast
392 return dynamic_cast<TH3*>( th1Pointer );
393}

◆ histSvc()

const ServiceHandle< ITHistSvc > & AthHistogramAlgorithm::histSvc ( ) const
inlineinherited

The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a pointer to the THistSvc.

Definition at line 113 of file AthHistogramAlgorithm.h.

114{
115 return m_histSvc;
116}

◆ initialize()

StatusCode PixelRDOAnalysis::initialize ( )
finaloverridevirtual

global histograms

brl histograms

global histograms

Definition at line 22 of file ITkPixelRDOAnalysis.cxx.

22 {
23 ATH_MSG_DEBUG( "Initializing ITkPixelRDOAnalysis" );
24
25 // This will check that the properties were initialized
26 // properly by job configuration.
27 ATH_CHECK( m_inputKey.initialize() );
28 ATH_CHECK( m_inputTruthKey.initialize() );
29 ATH_CHECK( m_inputMcEventCollectionKey.initialize() );
30
31 // Grab PixelID helper
32 ATH_CHECK(detStore()->retrieve(m_pixelID, m_pixelIDName.value()));
33 ATH_CHECK(detStore()->retrieve(m_pixelManager, m_detectorName.value()));
34
35
36 m_tree = new TTree(m_ntupleName.value().c_str(), "ITkPixelRDOAnalysis");
37 ATH_CHECK(histSvc()->regTree(m_ntuplePath.value() + m_ntupleName.value(), m_tree));
38 // PIXEL RDO
39 m_tree->Branch("rdoID", &m_rdoID);
40 m_tree->Branch("rdoWord", &m_rdoWord);
41 m_tree->Branch("barrelEndcap", &m_barrelEndcap);
42 m_tree->Branch("layerDisk", &m_layerDisk);
43 m_tree->Branch("phiModule", &m_phiModule);
44 m_tree->Branch("etaModule", &m_etaModule);
45 m_tree->Branch("phiIndex", &m_phiIndex);
46 m_tree->Branch("etaIndex", &m_etaIndex);
47 m_tree->Branch("isInnermost", &m_isInnermost);
48 m_tree->Branch("isNextToInnermost", &m_isNextToInnermost);
49 m_tree->Branch("ToT", &m_ToT); // time over threshold value (0-255)
50 m_tree->Branch("BCID", &m_BCID); // beam crossing ID
51 m_tree->Branch("LVL1A", &m_LVL1A); // Level1 accept (0-15)
52 m_tree->Branch("LVL1ID", &m_LVL1ID); // ATLAS LVL1 (0-255)
53 // Global coordinates
54 if (m_doPosition) {
55 m_tree->Branch("globalX", &m_globalX);
56 m_tree->Branch("globalY", &m_globalY);
57 m_tree->Branch("globalZ", &m_globalZ);
58 m_tree->Branch("localX", &m_localX);
59 m_tree->Branch("localY", &m_localY);
60 m_tree->Branch("localZ", &m_localZ);
61 }
62
63 // PIXEL SDO DEPOSITS
64 m_tree->Branch("sdoID", &m_sdoID);
65 m_tree->Branch("sdoWord", &m_sdoWord);
66 m_tree->Branch("barrelEndcap_sdo", &m_barrelEndcap_sdo);
67 m_tree->Branch("layerDisk_sdo", &m_layerDisk_sdo);
68 m_tree->Branch("phiModule_sdo", &m_phiModule_sdo);
69 m_tree->Branch("etaModule_sdo", &m_etaModule_sdo);
70 m_tree->Branch("phiIndex_sdo", &m_phiIndex_sdo);
71 m_tree->Branch("etaIndex_sdo", &m_etaIndex_sdo);
72 m_tree->Branch("noise", &m_noise);
73 m_tree->Branch("belowThresh", &m_belowThresh);
74 m_tree->Branch("disabled", &m_disabled);
75 m_tree->Branch("badTOT", &m_badTOT);
76 m_tree->Branch("barcode", &m_barcode);
77 m_tree->Branch("eventIndex", &m_eventIndex);
78 m_tree->Branch("charge", &m_charge);
79 m_tree->Branch("barcode_vec", &m_barcode_vec);
80 m_tree->Branch("eventIndex_vec", &m_eventIndex_vec);
81 m_tree->Branch("charge_vec", &m_charge_vec);
82
83 // HISTOGRAMS
84
86 m_h_rdoID = new TH1F("h_rdoID", "rdoID", 100, 0, 10e17);
87 m_h_rdoWord = new TH1F("h_rdoWord", "rdoWord", 100, 0, 350);
88 m_h_barrelEndcap = new TH1F("h_barrelEndcap", "Barrel or Endcap", 100, -5, 5);
89 m_h_layerDisk = new TH1F("h_layerDisk", "Barrel layer or Endcap disk", 100, 0, 10);
90 m_h_phiModule = new TH1F("h_phiModule", "Phi module", 100, 0, 100);
91 m_h_etaModule = new TH1F("h_etaModule", "Eta module", 100, -50, 50);
92 m_h_phiIndex = new TH1F("h_phiIndex", "Phi index", 820, 0, 820);
93 m_h_etaIndex = new TH1F("h_etaIndex", "Eta index", 820, 0, 820);
94 m_h_ToT = new TH1F("h_ToT", "ToT", 100, 0, 100);
95 m_h_BCID = new TH1F("h_BCID", "BCID", 100, -1.5, 1.5);
96 m_h_LVL1A = new TH1F("h_LVL1A", "LVL1A", 100, -1.5, 1.5);
97 m_h_LVL1ID = new TH1F("h_LVL1ID", "LVL1ID", 100, -1.5, 1.5);
98
100 m_h_brlLayer = new TH1F("h_brlLayer", "Barrel layer", 100, 0, 10);
101 m_h_brlPhiMod = new TH1F("h_brlPhiMod", "Barrel phi module", 100, 0, 100);
102 m_h_brlEtaMod = new TH1F("h_brlEtaMod", "Barrel eta module", 100, -50, 50);
103 m_h_brlPhiIndex = new TH1F("h_brlPhiIndex", "Barrel phi index", 820, 0, 820);
104 m_h_brlEtaIndex = new TH1F("h_brlEtaIndex", "Barrel eta index", 820, 0, 820);
105 m_h_brlToT = new TH1F("h_brlToT", "Barrel ToT", 100, 0, 100);
106 m_h_brlBCID = new TH1F("h_brlBCID", "Barrel BCID", 100, -1.5, 1.5);
107 m_h_brlLVL1A = new TH1F("h_brlLVL1A", "Barrel LVL1A", 100, -1.5, 1.5);
108 m_h_brlLVL1ID = new TH1F("h_brlLVL1ID", "Barrel LVL1ID", 100, -1.5, 1.5);
109
110 // ec histograms
111 m_h_ecDisk = new TH1F("h_ecDisk", "Endcap disk", 100, 0, 10);
112 m_h_ecPhiMod = new TH1F("h_ecPhiMod", "Endcap phi module", 100, 0, 100);
113 m_h_ecEtaMod = new TH1F("h_ecEtaMod", "Endcap eta module", 100, -50, 50);
114 m_h_ecPhiIndex = new TH1F("h_ecPhiIndex", "Endcap phi index", 820, 0, 820);
115 m_h_ecEtaIndex = new TH1F("h_ecEtaIndex", "Endcap eta index", 820, 0, 820);
116 m_h_ecToT = new TH1F("h_ecToT", "EndcapToT", 100, 0, 100);
117 m_h_ecBCID = new TH1F("h_ecBCID", "Endcap BCID", 100, -1.5, 1.5);
118 m_h_ecLVL1A = new TH1F("h_ecLVL1A", "Endcap LVL1A", 100, -1.5, 1.5);
119 m_h_ecLVL1ID = new TH1F("h_ecLVL1ID", "Endcap LVL1ID", 100, -1.5, 1.5);
120
121
123 m_h_sdoID = new TH1F("h_sdoID", "sdoID", 100, 0, 10e17);
124 m_h_sdoWord = new TH1F("h_sdoWord", "sdoWord", 100, 0, 350);
125 m_h_barrelEndcap_sdo = new TH1F("h_barrelEndcap_sdo", "Barrel or Endcap (SDO)", 100, -5, 5);
126 m_h_layerDisk_sdo = new TH1F("h_layerDisk_sdo", "Barrel layer or Endcap disk (SDO)", 100, 0, 10);
127 m_h_phiModule_sdo = new TH1F("h_phiModule_sdo", "Phi module (SDO)", 100, 0, 100);
128 m_h_etaModule_sdo = new TH1F("h_etaModule_sdo", "Eta module (SDO)", 100, -50, 50);
129 m_h_phiIndex_sdo = new TH1F("h_phiIndex_sdo", "Phi index (SDO)", 820, 0, 820);
130 m_h_etaIndex_sdo = new TH1F("h_etaIndex_sdo", "Eta index (SDO)", 820, 0, 820);
131 m_h_barcode = new TH1F("h_barcode", "Barcode (SDO)", 100, 0, 2.2e5);
132 m_h_eventIndex = new TH1F("h_eventIndex", "Event Index (SDO)", 100, 0, 2);
133 m_h_charge = new TH1F("h_charge", "Charge (SDO)", 100, 0, 1e7);
134
135
136 m_h_belowThresh_brl = new TH1F("h_belowThresh_brl", "Below threshold pixels - Barrel; # below threshold pixels; layer", 8, -0.5, 7.5);
137 m_h_disabled_brl = new TH1F("h_disabled_brl", "Disabled pixels - Barrel; # disabled pixels; layer", 8, -0.5, 7.5);
138
139 m_h_belowThresh_ec = new TH1F("h_belowThresh_ec", "Below threshold pixels - Endcap; # below threshold pixels; layer", 8, -0.5, 7.5);
140 m_h_disabled_ec = new TH1F("h_disabled_ec", "Disabled pixels - Endcap; # disabled pixels; layer", 8, -0.5, 7.5);
141
142
143 m_h_rdoID->StatOverflows();
144 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_rdoID->GetName(), m_h_rdoID));
145
146 m_h_rdoWord->StatOverflows();
147 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_rdoWord->GetName(), m_h_rdoWord));
148
149 m_h_barrelEndcap->StatOverflows();
150 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_barrelEndcap->GetName(), m_h_barrelEndcap));
151
152 m_h_layerDisk->StatOverflows();
153 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_layerDisk->GetName(), m_h_layerDisk));
154
155 m_h_phiModule->StatOverflows();
156 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_phiModule->GetName(), m_h_phiModule));
157
158 m_h_etaModule->StatOverflows();
159 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_etaModule->GetName(), m_h_etaModule));
160
161 m_h_phiIndex->StatOverflows();
162 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_phiIndex->GetName(), m_h_phiIndex));
163
164 m_h_etaIndex->StatOverflows();
165 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_etaIndex->GetName(), m_h_etaIndex));
166
167 m_h_ToT->StatOverflows();
168 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ToT->GetName(), m_h_ToT));
169
170 m_h_BCID->StatOverflows();
171 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_BCID->GetName(), m_h_BCID));
172
173 m_h_LVL1A->StatOverflows();
174 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_LVL1A->GetName(), m_h_LVL1A));
175
176 m_h_LVL1ID->StatOverflows();
177 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_LVL1ID->GetName(), m_h_LVL1ID));
178
179 m_h_brlLayer->StatOverflows();
180 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlLayer->GetName(), m_h_brlLayer));
181
182 m_h_brlPhiMod->StatOverflows();
183 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlPhiMod->GetName(), m_h_brlPhiMod));
184
185 m_h_brlEtaMod->StatOverflows();
186 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlEtaMod->GetName(), m_h_brlEtaMod));
187
188 m_h_brlPhiIndex->StatOverflows();
189 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlPhiIndex->GetName(), m_h_brlPhiIndex));
190
191 m_h_brlEtaIndex->StatOverflows();
192 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlEtaIndex->GetName(), m_h_brlEtaIndex));
193
194 m_h_brlToT->StatOverflows();
195 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlToT->GetName(), m_h_brlToT));
196
197 m_h_brlBCID->StatOverflows();
198 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlBCID->GetName(), m_h_brlBCID));
199
200 m_h_brlLVL1A->StatOverflows();
201 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlLVL1A->GetName(), m_h_brlLVL1A));
202
203 m_h_brlLVL1ID->StatOverflows();
204 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlLVL1ID->GetName(), m_h_brlLVL1ID));
205
206 m_h_ecDisk->StatOverflows();
207 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecDisk->GetName(), m_h_ecDisk));
208
209 m_h_ecPhiMod->StatOverflows();
210 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecPhiMod->GetName(), m_h_ecPhiMod));
211
212 m_h_ecEtaMod->StatOverflows();
213 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecEtaMod->GetName(), m_h_ecEtaMod));
214
215 m_h_ecPhiIndex->StatOverflows();
216 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecPhiIndex->GetName(), m_h_ecPhiIndex));
217
218 m_h_ecEtaIndex->StatOverflows();
219 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecEtaIndex->GetName(), m_h_ecEtaIndex));
220
221 m_h_ecToT->StatOverflows();
222 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecToT->GetName(), m_h_ecToT));
223
224 m_h_ecBCID->StatOverflows();
225 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecBCID->GetName(), m_h_ecBCID));
226
227 m_h_ecLVL1A->StatOverflows();
228 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecLVL1A->GetName(), m_h_ecLVL1A));
229
230 m_h_ecLVL1ID->StatOverflows();
231 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecLVL1ID->GetName(), m_h_ecLVL1ID));
232
233 m_h_sdoID->StatOverflows();
234 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_sdoID->GetName(), m_h_sdoID));
235
236 m_h_sdoWord->StatOverflows();
237 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_sdoWord->GetName(), m_h_sdoWord));
238
239 m_h_barrelEndcap_sdo->StatOverflows();
240 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_barrelEndcap_sdo->GetName(), m_h_barrelEndcap_sdo));
241
242 m_h_layerDisk_sdo->StatOverflows();
243 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_layerDisk_sdo->GetName(), m_h_layerDisk_sdo));
244
245 m_h_phiModule_sdo->StatOverflows();
246 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_phiModule_sdo->GetName(), m_h_phiModule_sdo));
247
248 m_h_etaModule_sdo->StatOverflows();
249 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_etaModule_sdo->GetName(), m_h_etaModule_sdo));
250
251 m_h_phiIndex_sdo->StatOverflows();
252 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_phiIndex_sdo->GetName(), m_h_phiIndex_sdo));
253
254 m_h_etaIndex_sdo->StatOverflows();
255 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_etaIndex_sdo->GetName(), m_h_etaIndex_sdo));
256
257 m_h_barcode->StatOverflows();
258 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_barcode->GetName(), m_h_barcode));
259
260 m_h_eventIndex->StatOverflows();
261 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_eventIndex->GetName(), m_h_eventIndex));
262
263 m_h_charge->StatOverflows();
264 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_charge->GetName(), m_h_charge));
265
266 m_h_belowThresh_brl->StatOverflows();
267 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_belowThresh_brl->GetName(), m_h_belowThresh_brl));
268
269 m_h_belowThresh_ec->StatOverflows();
270 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_belowThresh_ec->GetName(), m_h_belowThresh_ec));
271
272 m_h_disabled_brl->StatOverflows();
273 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_disabled_brl->GetName(), m_h_disabled_brl));
274
275 m_h_disabled_ec->StatOverflows();
276 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_disabled_ec->GetName(), m_h_disabled_ec));
277
278 for (unsigned int layer=0; layer<33; layer++) {
279 m_h_brlflatPhiIndex_perLayer.emplace_back(new TH1F(("h_brlflatPhiIndex_perLayer"+std::to_string(layer)).c_str(), ("Phi index - Barrel Flat - Layer "+std::to_string(layer)).c_str(), 820, 0, 820));
280 m_h_brlflatPhiIndex_perLayer.back()->StatOverflows();
281 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlflatPhiIndex_perLayer.back()->GetName(), m_h_brlflatPhiIndex_perLayer.back()));
282
283 m_h_brlflatEtaIndex_perLayer.emplace_back(new TH1F(("h_brlflatEtaIndex_perLayer"+std::to_string(layer)).c_str(), ("Eta index - Barrel Flat - Layer "+std::to_string(layer)).c_str(), 820, 0, 820));
284 m_h_brlflatEtaIndex_perLayer.back()->StatOverflows();
285 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlflatEtaIndex_perLayer.back()->GetName(), m_h_brlflatEtaIndex_perLayer.back()));
286
287 m_h_brlinclPhiIndex_perLayer.emplace_back(new TH1F(("h_brlinclPhiIndex_perLayer"+std::to_string(layer)).c_str(), ("Phi index - Barrel Inclined - Layer "+std::to_string(layer)).c_str(), 820, 0, 820));
288 m_h_brlinclPhiIndex_perLayer.back()->StatOverflows();
289 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlinclPhiIndex_perLayer.back()->GetName(), m_h_brlinclPhiIndex_perLayer.back()));
290
291 m_h_brlinclEtaIndex_perLayer.emplace_back(new TH1F(("h_brlinclEtaIndex_perLayer"+std::to_string(layer)).c_str(), ("Eta index - Barrel Inclined - Layer "+std::to_string(layer)).c_str(), 820, 0, 820));
292 m_h_brlinclEtaIndex_perLayer.back()->StatOverflows();
293 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_brlinclEtaIndex_perLayer.back()->GetName(), m_h_brlinclEtaIndex_perLayer.back()));
294
295 m_h_ecPhiIndex_perLayer.emplace_back(new TH1F(("h_ecPhiIndex_perLayer"+std::to_string(layer)).c_str(), ("Phi index - Endcap - Layer "+std::to_string(layer)).c_str(), 820, 0, 820));
296 m_h_ecPhiIndex_perLayer.back()->StatOverflows();
297 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecPhiIndex_perLayer.back()->GetName(), m_h_ecPhiIndex_perLayer.back()));
298
299 m_h_ecEtaIndex_perLayer.emplace_back(new TH1F(("h_ecEtaIndex_perLayer"+std::to_string(layer)).c_str(), ("Eta index - Endcap - Layer "+std::to_string(layer)).c_str(), 820, 0, 820));
300 m_h_ecEtaIndex_perLayer.back()->StatOverflows();
301 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_ecEtaIndex_perLayer.back()->GetName(), m_h_ecEtaIndex_perLayer.back()));
302 }
303
304 m_h_phiIndexInnermost = new TH1F("h_PhiIndexInnermost", "Phi index - Innermost Layer ", 820, 0, 820);
305 m_h_phiIndexInnermost->StatOverflows();
306 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_phiIndexInnermost->GetName(), m_h_phiIndexInnermost));
307
308 m_h_etaIndexInnermost = new TH1F("h_EtaIndexInnermost", "Eta index - Innermost Layer ", 820, 0, 820);
309 m_h_etaIndexInnermost->StatOverflows();
310 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_etaIndexInnermost->GetName(), m_h_etaIndexInnermost));
311
312 m_h_phiIndexNextToInnermost = new TH1F("h_PhiIndexNextToInnermost", "Phi index - Next To Innermost Layer ", 820, 0, 820);
313 m_h_phiIndexNextToInnermost->StatOverflows();
314 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_phiIndexNextToInnermost->GetName(), m_h_phiIndexNextToInnermost));
315
316 m_h_etaIndexNextToInnermost = new TH1F("h_EtaIndexNextToInnermost", "Eta index - Next To Innermost Layer ", 820, 0, 820);
317 m_h_etaIndexNextToInnermost->StatOverflows();
318 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_etaIndexNextToInnermost->GetName(), m_h_etaIndexNextToInnermost));
319
320 m_h_globalXY = new TH2F("h_globalXY","h_globalXY; x [mm]; y [mm]",700,-350.,350,700,-350.,350);
321 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_globalXY->GetName(), m_h_globalXY));
322 m_h_globalZR = new TH2F("h_globalZR","h_globalZR; z [mm]; r [mm]",6800,-3400.,3400,350,0.,350);
323 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_globalZR->GetName(), m_h_globalZR));
324 m_h_globalX = new TH1F("h_globalX","h_globalX; x [mm]",700,-350.,350.);
325 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_globalX->GetName(), m_h_globalX));
326 m_h_globalY = new TH1F("h_globalY","h_globalY; y [mm]",700,-350.,350.);
327 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_globalY->GetName(), m_h_globalY));
328 m_h_globalZ = new TH1F("h_globalZ","h_globalZ; z [mm]",6800,-3400.,3400.);
329 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_globalZ->GetName(), m_h_globalZ));
330
331 // Special shared ITk histograms
332 std::string xy_name = "h_ITk_xy";
333 auto xy = std::make_unique<TH2D>(xy_name.c_str(), xy_name.c_str(), 2200, -1100, 1100, 2200, -1100, 1100);
334 xy->StatOverflows();
335 ATH_CHECK(histSvc()->regShared(m_sharedHistPath + xy_name, std::move(xy), m_h_globalXY_shared));
336
337 std::string zr_name = "h_ITk_zr";
338 auto zr = std::make_unique<TH2D>(zr_name.c_str(), zr_name.c_str(), 6800, -3400, 3400, 1100, 0, 1100);
339 zr->StatOverflows();
340 ATH_CHECK(histSvc()->regShared(m_sharedHistPath + zr_name, std::move(zr), m_h_globalZR_shared));
341
342 m_h_truthMatchedRDOs = new TH1F("h_TruthMatchedPixelRDOs", "h_TruthMatchedPixelRDOs", 4, 1, 5);
343 TString truthMatchBinLables[4] = { "All RDOs", "Truth Matched", "HS Matched", "Unmatched" };
344 for(unsigned int ibin = 1; ibin < 5; ibin++) {
345 m_h_truthMatchedRDOs->GetXaxis()->SetBinLabel(ibin, truthMatchBinLables[ibin-1]);
346 }
347 ATH_CHECK(histSvc()->regHist(m_histPath + m_h_truthMatchedRDOs->GetName(), m_h_truthMatchedRDOs));
348 return StatusCode::SUCCESS;
349}
AthCommonAlgorithm< Gaudi::Algorithm >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
AthHistogramAlgorithm::histSvc
const ServiceHandle< ITHistSvc > & histSvc() const
The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a...
Definition AthHistogramAlgorithm.h:113
ITk::PixelRDOAnalysis::m_histPath
Gaudi::Property< std::string > m_histPath
Definition ITkPixelRDOAnalysis.h:55
ITk::PixelRDOAnalysis::m_h_brlinclEtaIndex_perLayer
std::vector< TH1 * > m_h_brlinclEtaIndex_perLayer
Definition ITkPixelRDOAnalysis.h:162
ITk::PixelRDOAnalysis::m_ntuplePath
Gaudi::Property< std::string > m_ntuplePath
Definition ITkPixelRDOAnalysis.h:57
ITk::PixelRDOAnalysis::m_sharedHistPath
Gaudi::Property< std::string > m_sharedHistPath
Definition ITkPixelRDOAnalysis.h:56
ITk::PixelRDOAnalysis::m_h_brlinclPhiIndex_perLayer
std::vector< TH1 * > m_h_brlinclPhiIndex_perLayer
Definition ITkPixelRDOAnalysis.h:161
ITk::PixelRDOAnalysis::m_pixelIDName
Gaudi::Property< std::string > m_pixelIDName
Definition ITkPixelRDOAnalysis.h:53
ITk::PixelRDOAnalysis::m_ntupleName
Gaudi::Property< std::string > m_ntupleName
Definition ITkPixelRDOAnalysis.h:58
ITk::PixelRDOAnalysis::m_detectorName
Gaudi::Property< std::string > m_detectorName
Definition ITkPixelRDOAnalysis.h:51
TRT::Hit::layer
@ layer
Definition HitInfo.h:79
python.TrigEgammaMonitorHelper.TH2F
TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition TrigEgammaMonitorHelper.py:45
python.TrigEgammaMonitorHelper.TH1F
TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition TrigEgammaMonitorHelper.py:24

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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.

◆ isClonable()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

47{ return false; }

◆ msg()

MsgStream & AthCommonMsg< Gaudi::Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

bool AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::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 > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ renounceArray()

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

◆ setFilterPassed()

virtual void AthCommonAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool state,
const EventContext & ctx ) const
inlinevirtualinherited

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
100 execState( ctx ).setFilterPassed( state );
101 }
AthCommonAlgorithm::setFilterPassed
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:
Definition AthCommonAlgorithm.h:99

◆ sysExecute()

StatusCode AthCommonAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthHistogramAlgorithm::sysInitialize ( )
virtualinherited

Initialization method invoked by the framework.

This method is responsible for any bookkeeping of initialization required by the framework itself. It will in turn invoke the initialize() method of the derived algorithm, and of any sub-algorithms which it creates.

Reimplemented from AthCommonAlgorithm< Gaudi::Algorithm >.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 75 of file AthHistogramAlgorithm.cxx.

76{
77 // ---- stolen from GaudiKernel/Algorithm::sysInitialize -------
78 // Bypass the initialization if the algorithm
79 // has already been initialized.
80 if ( Gaudi::StateMachine::INITIALIZED <= FSMState() ) return StatusCode::SUCCESS;
81
82 // Set the Algorithm's properties
83 bindPropertiesTo( serviceLocator()->getOptsSvc() );
84
85 // Bypass the initialization if the algorithm is disabled.
86 // Need to do this after bindPropertiesTo.
87 if ( !isEnabled( ) ) return StatusCode::SUCCESS;
88
89 // ---- stolen from GaudiKernel/Algorithm::sysInitialize ------- END ---
90
91
92 // Get the THistSvc
93 ATH_CHECK ( histSvc().retrieve() );
94
95 // Configure the underlying AthHistogramming helper
96 ATH_CHECK ( AthHistogramming::configAthHistogramming( m_histSvc,
97 m_prefix, m_rootDir,
98 m_histNamePrefix, m_histNamePostfix,
99 m_histTitlePrefix, m_histTitlePostfix ) );
100
101 // Print some setup information into the log file
102 ATH_MSG_DEBUG ("Initializing " << name() << "...");
103 ATH_MSG_DEBUG (" using THistService = " << m_histSvc );
104 ATH_MSG_DEBUG (" using RootStreamName = " << m_prefix );
105 ATH_MSG_DEBUG (" using RootDirName = " << m_rootDir );
106 ATH_MSG_DEBUG (" using HistNamePrefix = " << m_histNamePrefix );
107 ATH_MSG_DEBUG (" using HistNamePostfix = " << m_histNamePostfix );
108 ATH_MSG_DEBUG (" using HistTitlePrefix = " << m_histTitlePrefix );
109 ATH_MSG_DEBUG (" using HistTitlePostfix = " << m_histTitlePostfix );
110
111
112 // re-direct to base class...
113 return AthAlgorithm::sysInitialize();
114}
AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Definition AthCommonAlgorithm.cxx:71
AthHistogramming::configAthHistogramming
StatusCode configAthHistogramming(const ServiceHandle< ITHistSvc > &histSvc, const std::string &prefix, const std::string &rootDir, const std::string &histNamePrefix, const std::string &histNamePostfix, const std::string &histTitlePrefix, const std::string &histTitlePostfix)
To be called to fill the internal configuration.
Definition AthHistogramming.cxx:64

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::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.

◆ tree()

TTree * AthHistogramming::tree ( std::string_view treeName,
std::string_view tDir = "",
std::string_view stream = "" )
protectedinherited

Simplify the retrieval of registered TTrees.

Definition at line 333 of file AthHistogramming.cxx.

334{
335 // Build a 32 bit hash out of the name
336 const hash_t treeHash = this->hash(treeName);
337 // See if this entry exists in the map
338 TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
339 if ( it == m_treeMap.end() ) // It doesn't exist!
340 { // Let's see into the THistSvc if somebody else has registered the TTree...
341 // Massage the final string to book things
342 std::string bookingString = buildBookingString( treeName, tDir, stream);
343
344 TTree* treePointer(NULL);
345 if ( !((histSvc()->getTree(bookingString, treePointer)).isSuccess()) )
346 {
347 m_msg << MSG::WARNING
348 << "Problem retrieving the TTree with name " << treeName
349 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
350 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
351 return NULL;
352 }
353 // If we get to here, we actually found the TTree in the THistSvc.
354 // So let's add it to the local cache map and return its pointer
355 m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treePointer ) );
356 return treePointer;
357 }
358
359 // Return the pointer to the TTree that we got from the local cache map
360 return it->second;
361}
AthenaInternal::getTree
std::pair< StatusCode, TTree * > getTree(ITHistSvc &svc, const std::string &name)
Definition AthenaPythonDict.h:67

◆ updateVHKA()

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

Member Data Documentation

◆ m_badTOT

std::vector<bool>* ITk::PixelRDOAnalysis::m_badTOT {}
private

Definition at line 100 of file ITkPixelRDOAnalysis.h.

100{};

◆ m_barcode

std::vector<int>* ITk::PixelRDOAnalysis::m_barcode {}
private

Definition at line 102 of file ITkPixelRDOAnalysis.h.

102{};

◆ m_barcode_vec

std::vector< std::vector<int> >* ITk::PixelRDOAnalysis::m_barcode_vec {}
private

Definition at line 105 of file ITkPixelRDOAnalysis.h.

105{};

◆ m_barrelEndcap

std::vector<int>* ITk::PixelRDOAnalysis::m_barrelEndcap {}
private

Definition at line 65 of file ITkPixelRDOAnalysis.h.

65{};

◆ m_barrelEndcap_sdo

std::vector<int>* ITk::PixelRDOAnalysis::m_barrelEndcap_sdo {}
private

Definition at line 90 of file ITkPixelRDOAnalysis.h.

90{};

◆ m_BCID

std::vector<int>* ITk::PixelRDOAnalysis::m_BCID {}
private

Definition at line 75 of file ITkPixelRDOAnalysis.h.

75{};

◆ m_belowThresh

std::vector<bool>* ITk::PixelRDOAnalysis::m_belowThresh {}
private

Definition at line 98 of file ITkPixelRDOAnalysis.h.

98{};

◆ m_charge

std::vector<int>* ITk::PixelRDOAnalysis::m_charge {}
private

Definition at line 104 of file ITkPixelRDOAnalysis.h.

104{};

◆ m_charge_vec

std::vector< std::vector<float> >* ITk::PixelRDOAnalysis::m_charge_vec {}
private

Definition at line 107 of file ITkPixelRDOAnalysis.h.

107{};

◆ m_detectorName

Gaudi::Property<std::string> ITk::PixelRDOAnalysis::m_detectorName {this, "DetectorName", "ITkPixel", "Pixel detector name"}
private

Definition at line 50 of file ITkPixelRDOAnalysis.h.

51{this, "DetectorName", "ITkPixel", "Pixel detector name"};

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_disabled

std::vector<bool>* ITk::PixelRDOAnalysis::m_disabled {}
private

Definition at line 99 of file ITkPixelRDOAnalysis.h.

99{};

◆ m_doPosition

Gaudi::Property<bool> ITk::PixelRDOAnalysis::m_doPosition {this, "DoPosition", true, ""}
private

Definition at line 59 of file ITkPixelRDOAnalysis.h.

59{this, "DoPosition", true, ""};

◆ m_effMap

EffMap_t AthHistogramming::m_effMap
privateinherited

The map of histogram names to their pointers.

Definition at line 202 of file AthHistogramming.h.

◆ m_etaIndex

std::vector<int>* ITk::PixelRDOAnalysis::m_etaIndex {}
private

Definition at line 70 of file ITkPixelRDOAnalysis.h.

70{};

◆ m_etaIndex_sdo

std::vector<int>* ITk::PixelRDOAnalysis::m_etaIndex_sdo {}
private

Definition at line 95 of file ITkPixelRDOAnalysis.h.

95{};

◆ m_etaModule

std::vector<int>* ITk::PixelRDOAnalysis::m_etaModule {}
private

Definition at line 68 of file ITkPixelRDOAnalysis.h.

68{};

◆ m_etaModule_sdo

std::vector<int>* ITk::PixelRDOAnalysis::m_etaModule_sdo {}
private

Definition at line 93 of file ITkPixelRDOAnalysis.h.

93{};

◆ m_eventIndex

std::vector<int>* ITk::PixelRDOAnalysis::m_eventIndex {}
private

Definition at line 103 of file ITkPixelRDOAnalysis.h.

103{};

◆ m_eventIndex_vec

std::vector< std::vector<int> >* ITk::PixelRDOAnalysis::m_eventIndex_vec {}
private

Definition at line 106 of file ITkPixelRDOAnalysis.h.

106{};

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_globalX

std::vector<double>* ITk::PixelRDOAnalysis::m_globalX {}
private

Definition at line 79 of file ITkPixelRDOAnalysis.h.

79{};

◆ m_globalY

std::vector<double>* ITk::PixelRDOAnalysis::m_globalY {}
private

Definition at line 80 of file ITkPixelRDOAnalysis.h.

80{};

◆ m_globalZ

std::vector<double>* ITk::PixelRDOAnalysis::m_globalZ {}
private

Definition at line 81 of file ITkPixelRDOAnalysis.h.

81{};

◆ m_graphMap

GraphMap_t AthHistogramming::m_graphMap
privateinherited

The map of TGraph names to their pointers.

Definition at line 216 of file AthHistogramming.h.

◆ m_h_barcode

TH1* ITk::PixelRDOAnalysis::m_h_barcode {}
private

Definition at line 151 of file ITkPixelRDOAnalysis.h.

151{};

◆ m_h_barrelEndcap

TH1* ITk::PixelRDOAnalysis::m_h_barrelEndcap {}
private

Definition at line 112 of file ITkPixelRDOAnalysis.h.

112{};

◆ m_h_barrelEndcap_sdo

TH1* ITk::PixelRDOAnalysis::m_h_barrelEndcap_sdo {}
private

Definition at line 145 of file ITkPixelRDOAnalysis.h.

145{};

◆ m_h_BCID

TH1* ITk::PixelRDOAnalysis::m_h_BCID {}
private

Definition at line 119 of file ITkPixelRDOAnalysis.h.

119{};

◆ m_h_belowThresh_brl

TH1* ITk::PixelRDOAnalysis::m_h_belowThresh_brl {}
private

Definition at line 155 of file ITkPixelRDOAnalysis.h.

155{};

◆ m_h_belowThresh_ec

TH1* ITk::PixelRDOAnalysis::m_h_belowThresh_ec {}
private

Definition at line 156 of file ITkPixelRDOAnalysis.h.

156{};

◆ m_h_brlBCID

TH1* ITk::PixelRDOAnalysis::m_h_brlBCID {}
private

Definition at line 129 of file ITkPixelRDOAnalysis.h.

129{};

◆ m_h_brlEtaIndex

TH1* ITk::PixelRDOAnalysis::m_h_brlEtaIndex {}
private

Definition at line 127 of file ITkPixelRDOAnalysis.h.

127{};

◆ m_h_brlEtaMod

TH1* ITk::PixelRDOAnalysis::m_h_brlEtaMod {}
private

Definition at line 125 of file ITkPixelRDOAnalysis.h.

125{};

◆ m_h_brlflatEtaIndex_perLayer

std::vector<TH1*> ITk::PixelRDOAnalysis::m_h_brlflatEtaIndex_perLayer
private

Definition at line 165 of file ITkPixelRDOAnalysis.h.

◆ m_h_brlflatPhiIndex_perLayer

std::vector<TH1*> ITk::PixelRDOAnalysis::m_h_brlflatPhiIndex_perLayer
private

Definition at line 164 of file ITkPixelRDOAnalysis.h.

◆ m_h_brlinclEtaIndex_perLayer

std::vector<TH1*> ITk::PixelRDOAnalysis::m_h_brlinclEtaIndex_perLayer
private

Definition at line 162 of file ITkPixelRDOAnalysis.h.

◆ m_h_brlinclPhiIndex_perLayer

std::vector<TH1*> ITk::PixelRDOAnalysis::m_h_brlinclPhiIndex_perLayer
private

Definition at line 161 of file ITkPixelRDOAnalysis.h.

◆ m_h_brlLayer

TH1* ITk::PixelRDOAnalysis::m_h_brlLayer {}
private

Definition at line 123 of file ITkPixelRDOAnalysis.h.

123{};

◆ m_h_brlLVL1A

TH1* ITk::PixelRDOAnalysis::m_h_brlLVL1A {}
private

Definition at line 130 of file ITkPixelRDOAnalysis.h.

130{};

◆ m_h_brlLVL1ID

TH1* ITk::PixelRDOAnalysis::m_h_brlLVL1ID {}
private

Definition at line 131 of file ITkPixelRDOAnalysis.h.

131{};

◆ m_h_brlPhiIndex

TH1* ITk::PixelRDOAnalysis::m_h_brlPhiIndex {}
private

Definition at line 126 of file ITkPixelRDOAnalysis.h.

126{};

◆ m_h_brlPhiMod

TH1* ITk::PixelRDOAnalysis::m_h_brlPhiMod {}
private

Definition at line 124 of file ITkPixelRDOAnalysis.h.

124{};

◆ m_h_brlToT

TH1* ITk::PixelRDOAnalysis::m_h_brlToT {}
private

Definition at line 128 of file ITkPixelRDOAnalysis.h.

128{};

◆ m_h_charge

TH1* ITk::PixelRDOAnalysis::m_h_charge {}
private

Definition at line 153 of file ITkPixelRDOAnalysis.h.

153{};

◆ m_h_disabled_brl

TH1* ITk::PixelRDOAnalysis::m_h_disabled_brl {}
private

Definition at line 158 of file ITkPixelRDOAnalysis.h.

158{};

◆ m_h_disabled_ec

TH1* ITk::PixelRDOAnalysis::m_h_disabled_ec {}
private

Definition at line 159 of file ITkPixelRDOAnalysis.h.

159{};

◆ m_h_ecBCID

TH1* ITk::PixelRDOAnalysis::m_h_ecBCID {}
private

Definition at line 139 of file ITkPixelRDOAnalysis.h.

139{};

◆ m_h_ecDisk

TH1* ITk::PixelRDOAnalysis::m_h_ecDisk {}
private

Definition at line 133 of file ITkPixelRDOAnalysis.h.

133{};

◆ m_h_ecEtaIndex

TH1* ITk::PixelRDOAnalysis::m_h_ecEtaIndex {}
private

Definition at line 137 of file ITkPixelRDOAnalysis.h.

137{};

◆ m_h_ecEtaIndex_perLayer

std::vector<TH1*> ITk::PixelRDOAnalysis::m_h_ecEtaIndex_perLayer
private

Definition at line 168 of file ITkPixelRDOAnalysis.h.

◆ m_h_ecEtaMod

TH1* ITk::PixelRDOAnalysis::m_h_ecEtaMod {}
private

Definition at line 135 of file ITkPixelRDOAnalysis.h.

135{};

◆ m_h_ecLVL1A

TH1* ITk::PixelRDOAnalysis::m_h_ecLVL1A {}
private

Definition at line 140 of file ITkPixelRDOAnalysis.h.

140{};

◆ m_h_ecLVL1ID

TH1* ITk::PixelRDOAnalysis::m_h_ecLVL1ID {}
private

Definition at line 141 of file ITkPixelRDOAnalysis.h.

141{};

◆ m_h_ecPhiIndex

TH1* ITk::PixelRDOAnalysis::m_h_ecPhiIndex {}
private

Definition at line 136 of file ITkPixelRDOAnalysis.h.

136{};

◆ m_h_ecPhiIndex_perLayer

std::vector<TH1*> ITk::PixelRDOAnalysis::m_h_ecPhiIndex_perLayer
private

Definition at line 167 of file ITkPixelRDOAnalysis.h.

◆ m_h_ecPhiMod

TH1* ITk::PixelRDOAnalysis::m_h_ecPhiMod {}
private

Definition at line 134 of file ITkPixelRDOAnalysis.h.

134{};

◆ m_h_ecToT

TH1* ITk::PixelRDOAnalysis::m_h_ecToT {}
private

Definition at line 138 of file ITkPixelRDOAnalysis.h.

138{};

◆ m_h_etaIndex

TH1* ITk::PixelRDOAnalysis::m_h_etaIndex {}
private

Definition at line 117 of file ITkPixelRDOAnalysis.h.

117{};

◆ m_h_etaIndex_sdo

TH1* ITk::PixelRDOAnalysis::m_h_etaIndex_sdo {}
private

Definition at line 150 of file ITkPixelRDOAnalysis.h.

150{};

◆ m_h_etaIndexInnermost

TH1* ITk::PixelRDOAnalysis::m_h_etaIndexInnermost {}
private

Definition at line 171 of file ITkPixelRDOAnalysis.h.

171{};

◆ m_h_etaIndexNextToInnermost

TH1* ITk::PixelRDOAnalysis::m_h_etaIndexNextToInnermost {}
private

Definition at line 174 of file ITkPixelRDOAnalysis.h.

174{};

◆ m_h_etaModule

TH1* ITk::PixelRDOAnalysis::m_h_etaModule {}
private

Definition at line 115 of file ITkPixelRDOAnalysis.h.

115{};

◆ m_h_etaModule_sdo

TH1* ITk::PixelRDOAnalysis::m_h_etaModule_sdo {}
private

Definition at line 148 of file ITkPixelRDOAnalysis.h.

148{};

◆ m_h_eventIndex

TH1* ITk::PixelRDOAnalysis::m_h_eventIndex {}
private

Definition at line 152 of file ITkPixelRDOAnalysis.h.

152{};

◆ m_h_globalX

TH1* ITk::PixelRDOAnalysis::m_h_globalX {}
private

Definition at line 180 of file ITkPixelRDOAnalysis.h.

180{};

◆ m_h_globalXY

TH2* ITk::PixelRDOAnalysis::m_h_globalXY {}
private

Definition at line 176 of file ITkPixelRDOAnalysis.h.

176{};

◆ m_h_globalXY_shared

LockedHandle<TH2> ITk::PixelRDOAnalysis::m_h_globalXY_shared {}
private

Definition at line 178 of file ITkPixelRDOAnalysis.h.

178{};

◆ m_h_globalY

TH1* ITk::PixelRDOAnalysis::m_h_globalY {}
private

Definition at line 181 of file ITkPixelRDOAnalysis.h.

181{};

◆ m_h_globalZ

TH1* ITk::PixelRDOAnalysis::m_h_globalZ {}
private

Definition at line 182 of file ITkPixelRDOAnalysis.h.

182{};

◆ m_h_globalZR

TH2* ITk::PixelRDOAnalysis::m_h_globalZR {}
private

Definition at line 177 of file ITkPixelRDOAnalysis.h.

177{};

◆ m_h_globalZR_shared

LockedHandle<TH2> ITk::PixelRDOAnalysis::m_h_globalZR_shared {}
private

Definition at line 179 of file ITkPixelRDOAnalysis.h.

179{};

◆ m_h_layerDisk

TH1* ITk::PixelRDOAnalysis::m_h_layerDisk {}
private

Definition at line 113 of file ITkPixelRDOAnalysis.h.

113{};

◆ m_h_layerDisk_sdo

TH1* ITk::PixelRDOAnalysis::m_h_layerDisk_sdo {}
private

Definition at line 146 of file ITkPixelRDOAnalysis.h.

146{};

◆ m_h_LVL1A

TH1* ITk::PixelRDOAnalysis::m_h_LVL1A {}
private

Definition at line 120 of file ITkPixelRDOAnalysis.h.

120{};

◆ m_h_LVL1ID

TH1* ITk::PixelRDOAnalysis::m_h_LVL1ID {}
private

Definition at line 121 of file ITkPixelRDOAnalysis.h.

121{};

◆ m_h_phiIndex

TH1* ITk::PixelRDOAnalysis::m_h_phiIndex {}
private

Definition at line 116 of file ITkPixelRDOAnalysis.h.

116{};

◆ m_h_phiIndex_sdo

TH1* ITk::PixelRDOAnalysis::m_h_phiIndex_sdo {}
private

Definition at line 149 of file ITkPixelRDOAnalysis.h.

149{};

◆ m_h_phiIndexInnermost

TH1* ITk::PixelRDOAnalysis::m_h_phiIndexInnermost {}
private

Definition at line 170 of file ITkPixelRDOAnalysis.h.

170{};

◆ m_h_phiIndexNextToInnermost

TH1* ITk::PixelRDOAnalysis::m_h_phiIndexNextToInnermost {}
private

Definition at line 173 of file ITkPixelRDOAnalysis.h.

173{};

◆ m_h_phiModule

TH1* ITk::PixelRDOAnalysis::m_h_phiModule {}
private

Definition at line 114 of file ITkPixelRDOAnalysis.h.

114{};

◆ m_h_phiModule_sdo

TH1* ITk::PixelRDOAnalysis::m_h_phiModule_sdo {}
private

Definition at line 147 of file ITkPixelRDOAnalysis.h.

147{};

◆ m_h_rdoID

TH1* ITk::PixelRDOAnalysis::m_h_rdoID {}
private

Definition at line 110 of file ITkPixelRDOAnalysis.h.

110{};

◆ m_h_rdoWord

TH1* ITk::PixelRDOAnalysis::m_h_rdoWord {}
private

Definition at line 111 of file ITkPixelRDOAnalysis.h.

111{};

◆ m_h_sdoID

TH1* ITk::PixelRDOAnalysis::m_h_sdoID {}
private

Definition at line 143 of file ITkPixelRDOAnalysis.h.

143{};

◆ m_h_sdoWord

TH1* ITk::PixelRDOAnalysis::m_h_sdoWord {}
private

Definition at line 144 of file ITkPixelRDOAnalysis.h.

144{};

◆ m_h_ToT

TH1* ITk::PixelRDOAnalysis::m_h_ToT {}
private

Definition at line 118 of file ITkPixelRDOAnalysis.h.

118{};

◆ m_h_truthMatchedRDOs

TH1* ITk::PixelRDOAnalysis::m_h_truthMatchedRDOs {}
private

Definition at line 184 of file ITkPixelRDOAnalysis.h.

184{};

◆ m_histMap

HistMap_t AthHistogramming::m_histMap
privateinherited

The map of histogram names to their pointers.

Definition at line 195 of file AthHistogramming.h.

◆ m_histNamePostfix

std::string AthHistogramAlgorithm::m_histNamePostfix
privateinherited

The postfix for the histogram THx name.

Definition at line 97 of file AthHistogramAlgorithm.h.

◆ m_histNamePrefix

std::string AthHistogramAlgorithm::m_histNamePrefix
privateinherited

The prefix for the histogram THx name.

Definition at line 94 of file AthHistogramAlgorithm.h.

◆ m_histPath

Gaudi::Property<std::string> ITk::PixelRDOAnalysis::m_histPath {this, "HistPath", "/RDOAnalysis/ITkPixel/", ""}
private

Definition at line 55 of file ITkPixelRDOAnalysis.h.

55{this, "HistPath", "/RDOAnalysis/ITkPixel/", ""};

◆ m_histSvc

ServiceHandle<ITHistSvc> AthHistogramAlgorithm::m_histSvc
privateinherited

Default constructor: AthHistogramAlgorithm();.

a handle on the Hist/TTree registration service

Definition at line 83 of file AthHistogramAlgorithm.h.

◆ m_histTitlePostfix

std::string AthHistogramAlgorithm::m_histTitlePostfix
privateinherited

The postfix for the histogram THx title.

Definition at line 103 of file AthHistogramAlgorithm.h.

◆ m_histTitlePrefix

std::string AthHistogramAlgorithm::m_histTitlePrefix
privateinherited

The prefix for the histogram THx title.

Definition at line 100 of file AthHistogramAlgorithm.h.

◆ m_inputKey

SG::ReadHandleKey<PixelRDO_Container> ITk::PixelRDOAnalysis::m_inputKey {this, "CollectionName", "ITkPixelRDOs", "Input ITk Pixel RDO collection name"}
private

Definition at line 45 of file ITkPixelRDOAnalysis.h.

45{this, "CollectionName", "ITkPixelRDOs", "Input ITk Pixel RDO collection name"};

◆ m_inputMcEventCollectionKey

SG::ReadHandleKey<McEventCollection> ITk::PixelRDOAnalysis::m_inputMcEventCollectionKey {this, "McEventCollectionName", "TruthEvent", "Input McEventCollection name"}
private

Definition at line 47 of file ITkPixelRDOAnalysis.h.

47{this, "McEventCollectionName", "TruthEvent", "Input McEventCollection name"};

◆ m_inputTruthKey

SG::ReadHandleKey<InDetSimDataCollection> ITk::PixelRDOAnalysis::m_inputTruthKey {this, "SDOCollectionName", "ITkPixelSDO_Map", "Input ITk Pixel SDO collection name"}
private

Definition at line 46 of file ITkPixelRDOAnalysis.h.

46{this, "SDOCollectionName", "ITkPixelSDO_Map", "Input ITk Pixel SDO collection name"};

◆ m_isInnermost

std::vector<int>* ITk::PixelRDOAnalysis::m_isInnermost {}
private

Definition at line 71 of file ITkPixelRDOAnalysis.h.

71{};

◆ m_isNextToInnermost

std::vector<int>* ITk::PixelRDOAnalysis::m_isNextToInnermost {}
private

Definition at line 72 of file ITkPixelRDOAnalysis.h.

72{};

◆ m_layerDisk

std::vector<int>* ITk::PixelRDOAnalysis::m_layerDisk {}
private

Definition at line 66 of file ITkPixelRDOAnalysis.h.

66{};

◆ m_layerDisk_sdo

std::vector<int>* ITk::PixelRDOAnalysis::m_layerDisk_sdo {}
private

Definition at line 91 of file ITkPixelRDOAnalysis.h.

91{};

◆ m_localX

std::vector<double>* ITk::PixelRDOAnalysis::m_localX {}
private

Definition at line 82 of file ITkPixelRDOAnalysis.h.

82{};

◆ m_localY

std::vector<double>* ITk::PixelRDOAnalysis::m_localY {}
private

Definition at line 83 of file ITkPixelRDOAnalysis.h.

83{};

◆ m_localZ

std::vector<double>* ITk::PixelRDOAnalysis::m_localZ {}
private

Definition at line 84 of file ITkPixelRDOAnalysis.h.

84{};

◆ m_LVL1A

std::vector<int>* ITk::PixelRDOAnalysis::m_LVL1A {}
private

Definition at line 76 of file ITkPixelRDOAnalysis.h.

76{};

◆ m_LVL1ID

std::vector<int>* ITk::PixelRDOAnalysis::m_LVL1ID {}
private

Definition at line 77 of file ITkPixelRDOAnalysis.h.

77{};

◆ m_msg

MsgStream AthHistogramming::m_msg
privateinherited

Cached Message Stream.

Definition at line 242 of file AthHistogramming.h.

◆ m_name

std::string AthHistogramming::m_name
privateinherited

Instance name.

Definition at line 239 of file AthHistogramming.h.

◆ m_noise

std::vector<bool>* ITk::PixelRDOAnalysis::m_noise {}
private

Definition at line 97 of file ITkPixelRDOAnalysis.h.

97{};

◆ m_ntupleName

Gaudi::Property<std::string> ITk::PixelRDOAnalysis::m_ntupleName {this, "NtupleName", "ITkPixel", ""}
private

Definition at line 58 of file ITkPixelRDOAnalysis.h.

58{this, "NtupleName", "ITkPixel", ""};

◆ m_ntuplePath

Gaudi::Property<std::string> ITk::PixelRDOAnalysis::m_ntuplePath {this, "NtuplePath", "/RDOAnalysis/ntuples/", ""}
private

Definition at line 57 of file ITkPixelRDOAnalysis.h.

57{this, "NtuplePath", "/RDOAnalysis/ntuples/", ""};

◆ m_phiIndex

std::vector<int>* ITk::PixelRDOAnalysis::m_phiIndex {}
private

Definition at line 69 of file ITkPixelRDOAnalysis.h.

69{};

◆ m_phiIndex_sdo

std::vector<int>* ITk::PixelRDOAnalysis::m_phiIndex_sdo {}
private

Definition at line 94 of file ITkPixelRDOAnalysis.h.

94{};

◆ m_phiModule

std::vector<int>* ITk::PixelRDOAnalysis::m_phiModule {}
private

Definition at line 67 of file ITkPixelRDOAnalysis.h.

67{};

◆ m_phiModule_sdo

std::vector<int>* ITk::PixelRDOAnalysis::m_phiModule_sdo {}
private

Definition at line 92 of file ITkPixelRDOAnalysis.h.

92{};

◆ m_pixelID

const PixelID* ITk::PixelRDOAnalysis::m_pixelID {}
private

Definition at line 48 of file ITkPixelRDOAnalysis.h.

48{};

◆ m_pixelIDName

Gaudi::Property<std::string> ITk::PixelRDOAnalysis::m_pixelIDName {this, "PixelIDName", "PixelID", "Pixel ID name"}
private

Definition at line 52 of file ITkPixelRDOAnalysis.h.

53{this, "PixelIDName", "PixelID", "Pixel ID name"};

◆ m_pixelManager

const InDetDD::PixelDetectorManager* ITk::PixelRDOAnalysis::m_pixelManager {}
private

Definition at line 49 of file ITkPixelRDOAnalysis.h.

49{};

◆ m_prefix

std::string AthHistogramAlgorithm::m_prefix
privateinherited

Name of the ROOT output stream (file).

Definition at line 88 of file AthHistogramAlgorithm.h.

◆ m_rdoID

std::vector<unsigned long long>* ITk::PixelRDOAnalysis::m_rdoID {}
private

Definition at line 62 of file ITkPixelRDOAnalysis.h.

62{};

◆ m_rdoWord

std::vector<unsigned int>* ITk::PixelRDOAnalysis::m_rdoWord {}
private

Definition at line 63 of file ITkPixelRDOAnalysis.h.

63{};

◆ m_rootDir

std::string AthHistogramAlgorithm::m_rootDir
privateinherited

Name of the ROOT directory.

Definition at line 91 of file AthHistogramAlgorithm.h.

◆ m_sdoID

std::vector<unsigned long long>* ITk::PixelRDOAnalysis::m_sdoID {}
private

Definition at line 87 of file ITkPixelRDOAnalysis.h.

87{};

◆ m_sdoWord

std::vector<int>* ITk::PixelRDOAnalysis::m_sdoWord {}
private

Definition at line 88 of file ITkPixelRDOAnalysis.h.

88{};

◆ m_sharedHistPath

Gaudi::Property<std::string> ITk::PixelRDOAnalysis::m_sharedHistPath {this, "SharedHistPath", "/RDOAnalysis/histos/", ""}
private

Definition at line 56 of file ITkPixelRDOAnalysis.h.

56{this, "SharedHistPath", "/RDOAnalysis/histos/", ""};

◆ m_streamName

std::string AthHistogramming::m_streamName
privateinherited

Name of the ROOT output stream (file).

Definition at line 220 of file AthHistogramming.h.

◆ m_ToT

std::vector<int>* ITk::PixelRDOAnalysis::m_ToT {}
private

Definition at line 74 of file ITkPixelRDOAnalysis.h.

74{};

◆ m_tree

TTree* ITk::PixelRDOAnalysis::m_tree {}
private

Definition at line 186 of file ITkPixelRDOAnalysis.h.

186{};

◆ m_treeMap

TreeMap_t AthHistogramming::m_treeMap
privateinherited

The map of TTree names to their pointers.

Definition at line 209 of file AthHistogramming.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.17.0