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 () override final
 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 const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies.
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

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 by the derived classes to fill the internal configuration.
TH1 * bookGetPointer (const TH1 &hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 *hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 &histRef, std::string tDir="", std::string stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TTree * bookGetPointer (const TTree &treeRef, std::string tDir="", std::string stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
TGraph * bookGetPointer (const TGraph &graphRef, std::string tDir="", std::string stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
TEfficiency * bookGetPointer (const TEfficiency &eff, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency *eff, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency &effRef, std::string tDir="", std::string stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (const TH1 &hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 *hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 &histRef, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (const TTree &treeRef, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
StatusCode book (const TGraph &graphRef, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
StatusCode book (const TEfficiency &eff, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency *eff, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency &effRef, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TH1 * hist (const std::string &histName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered histograms of any type.
TH2 * hist2d (const std::string &histName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered 2-d histograms.
TH3 * hist3d (const std::string &histName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered 3-d histograms.
TTree * tree (const std::string &treeName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered TTrees.
TGraph * graph (const std::string &graphName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered TGraphs.
TEfficiency * efficiency (const std::string &effName, const std::string &tDir="", const std::string &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>
void buildBookingString (std::string &bookingString, std::string &histName, std::string &tDir, std::string &stream, bool usePrefixPostfix=false)
 Method to build individual booking string.
void myReplace (std::string &str, const std::string &oldStr, const std::string &newStr)
 Helper method to replace sub-string.
hash_t hash (const std::string &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
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 205 of file AthHistogramming.h.

◆ GraphMap_t

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

Typedef for convenience.

Definition at line 219 of file AthHistogramming.h.

◆ hash_t

typedef uint32_t AthHistogramming::hash_t
privateinherited

typedef for the internal hash

Definition at line 169 of file AthHistogramming.h.

◆ HistMap_t

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

Typedef for convenience.

Definition at line 198 of file AthHistogramming.h.

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< 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 212 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()
Default constructor:
AthCommonDataStore< AthCommonMsg< 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:41

◆ book() [1/8]

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

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

Definition at line 335 of file AthHistogramming.h.

336{
337 // We need to create a non-const clone
338 TEfficiency* effClone = dynamic_cast< TEfficiency* >( eff.Clone() );
339 if ( !effClone ) {
340 m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone" << endmsg;
341 return StatusCode::FAILURE;
342 }
343 return this->book( *effClone, tDir, stream );
344}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
AthHistogramming::book
StatusCode book(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition AthHistogramming.h:303
AthHistogramming::m_msg
MsgStream m_msg
Cached Message Stream.
Definition AthHistogramming.h:248
dqt_zlumi_alleff_HIST.eff
int eff
Definition dqt_zlumi_alleff_HIST.py:113

◆ book() [2/8]

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

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

◆ book() [3/8]

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

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

Definition at line 303 of file AthHistogramming.h.

304{
305 // We need to create a non-const clone
306 TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
307 if ( !histClone ) {
308 m_msg << MSG::ERROR << "Couldn't create a TH1 clone" << endmsg;
309 return StatusCode::FAILURE;
310 }
311 return this->book( *histClone, tDir, stream );
312}
AthHistogramming::hist
TH1 * hist(const std::string &histName, const std::string &tDir="", const std::string &stream="")
Simplify the retrieval of registered histograms of any type.
Definition AthHistogramming.cxx:198

◆ book() [4/8]

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

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

Definition at line 403 of file AthHistogramming.h.

404{
405 // Call the other Book method and see if it returns a valid pointer
406 TTree* treePointer = this->bookGetPointer( treeRef, tDir, stream );
407 if ( treePointer )
408 {
409 return StatusCode::SUCCESS;
410 }
411 else
412 {
413 return StatusCode::FAILURE;
414 }
415}
AthHistogramming::bookGetPointer
TH1 * bookGetPointer(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition AthHistogramming.h:260

◆ book() [5/8]

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

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

Definition at line 356 of file AthHistogramming.h.

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

◆ book() [6/8]

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

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

Definition at line 346 of file AthHistogramming.h.

347{
348 if ( !eff ) {
349 m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency" << endmsg;
350 return StatusCode::FAILURE;
351 }
352 return this->book( *eff, tDir, stream );
353}

◆ book() [7/8]

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

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

Definition at line 324 of file AthHistogramming.h.

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

◆ book() [8/8]

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

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

Definition at line 314 of file AthHistogramming.h.

315{
316 if ( !hist ) {
317 m_msg << MSG::ERROR << "Got a zero pointer to a TH1" << endmsg;
318 return StatusCode::FAILURE;
319 }
320 return this->book( *hist, tDir, stream );
321}

◆ bookGetPointer() [1/8]

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

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

Definition at line 281 of file AthHistogramming.h.

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

◆ bookGetPointer() [2/8]

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

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

Definition at line 427 of file AthHistogramming.cxx.

428{
429 // Get a pointer
430 const TGraph* graphPointer = &graphRef;
431
432 // Check that we got a valid pointer
433 if ( !graphPointer )
434 {
435 m_msg << MSG::WARNING
436 << "We got an invalid TGraph pointer in the BookGetPointer(TGraph*) method of the class" << m_name
437 << "!" << endmsg;
438 return NULL;
439 }
440
441 // Modify the name and title according to the prefixes of this classes instance
442 std::string graphName = graphPointer->GetName();
443 const std::string graphTitle = graphPointer->GetTitle();
444
445 // Check if the hash for this graphName already exists, i.e., if we have a hash collision
446 const hash_t graphHash = this->hash(graphName);
447 GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
448 if ( it != m_graphMap.end() ) // It does exist!
449 {
450 m_msg << MSG::WARNING
451 << "Detected a hash collision. The hash for the TGraph with name=" << graphName
452 << " already exists and points to a TGraph with name=" << it->second->GetName()
453 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
454 return NULL;
455 }
456
457 // Create a clone that has the new name
458 TGraph* graphClone = dynamic_cast< TGraph* >( graphPointer->Clone((m_histNamePrefix+graphName+m_histNamePostfix).c_str()) );
459 if( !graphClone )
460 {
461 m_msg << MSG::WARNING
462 << "We couldn't clone the TGraph in the BookGetPointer(TGraph&) method of the class" << m_name
463 << "!" << endmsg;
464 return NULL;
465 }
466 graphClone->SetTitle ((m_histTitlePrefix+graphTitle+m_histTitlePostfix).c_str());
467
468 // Massage the final string to book things
469 std::string bookingString("");
470 this->buildBookingString( bookingString, graphName, tDir, stream );
471
472 // Register the TGraph into the THistSvc
473 if ( !((histSvc()->regGraph(bookingString, graphClone)).isSuccess()) )
474 {
475 m_msg << MSG::WARNING
476 << "Problem registering TGraph with name " << graphName
477 << ", title " << graphTitle
478 << " in " << m_name << "!" << endmsg;
479 return NULL;
480 }
481
482 // Also register it in the local map of string to pointer
483 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphClone ) );
484
485 return graphClone;
486}
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:421
AthHistogramming::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition AthHistogramming.h:235
AthHistogramming::hash
hash_t hash(const std::string &histName) const
Method to calculate a 32-bit hash from a string.
Definition AthHistogramming.h:428
AthHistogramming::hash_t
uint32_t hash_t
typedef for the internal hash
Definition AthHistogramming.h:169
AthHistogramming::m_histTitlePostfix
std::string m_histTitlePostfix
The postfix for the histogram THx title.
Definition AthHistogramming.h:241
AthHistogramming::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition AthHistogramming.h:238
AthHistogramming::m_name
std::string m_name
Instance name.
Definition AthHistogramming.h:245
AthHistogramming::buildBookingString
void buildBookingString(std::string &bookingString, std::string &histName, std::string &tDir, std::string &stream, bool usePrefixPostfix=false)
Method to build individual booking string.
Definition AthHistogramming.cxx:560
AthHistogramming::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition AthHistogramming.h:232
AthHistogramming::m_graphMap
GraphMap_t m_graphMap
The map of TGraph names to their pointers.
Definition AthHistogramming.h:222

◆ bookGetPointer() [3/8]

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

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

Definition at line 260 of file AthHistogramming.h.

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

◆ bookGetPointer() [4/8]

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

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

Definition at line 312 of file AthHistogramming.cxx.

313{
314 // Get a pointer
315 const TTree* treePointer = &treeRef;
316
317 // Check that we got a valid pointer
318 if ( !treePointer )
319 {
320 m_msg << MSG::WARNING
321 << "We got an invalid TTree pointer in the BookGetPointer(TTree*) method of the class" << m_name
322 << "!" << endmsg;
323 return NULL;
324 }
325
326 // Modify the name and title according to the prefixes of this classes instance
327 std::string treeName = treePointer->GetName();
328 const std::string treeTitle = treePointer->GetTitle();
329
330 // Check if the hash for this treeName already exists, i.e., if we have a hash collision
331 const hash_t treeHash = this->hash(treeName);
332 TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
333 if ( it != m_treeMap.end() ) // It does exist!
334 {
335 m_msg << MSG::WARNING
336 << "Detected a hash collision. The hash for the TTree with name=" << treeName
337 << " already exists and points to a TTree with name=" << it->second->GetName()
338 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
339 return NULL;
340 }
341
342 // Create a clone that has the new name
343 TTree* treeClone = dynamic_cast< TTree* >( treePointer->Clone(treeName.c_str()) );
344 if( !treeClone )
345 {
346 m_msg << MSG::WARNING
347 << "We couldn't clone the TTree in the BookGetPointer(TTree&) method of the class" << m_name
348 << "!" << endmsg;
349 return NULL;
350 }
351 treeClone->SetTitle (treeTitle.c_str());
352
353 // Massage the final string to book things
354 std::string bookingString("");
355 this->buildBookingString( bookingString, treeName, tDir, stream );
356
357 // Register the TTree into the THistSvc
358 if ( !((histSvc()->regTree(bookingString, treeClone)).isSuccess()) )
359 {
360 m_msg << MSG::WARNING
361 << "Problem registering TTree with name " << treeName
362 << ", title " << treeTitle
363 << " in " << m_name << "!" << endmsg;
364 return NULL;
365 }
366
367 // Also register it in the local map of string to pointer
368 m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treeClone ) );
369
370 return treeClone;
371}
AthHistogramming::m_treeMap
TreeMap_t m_treeMap
The map of TTree names to their pointers.
Definition AthHistogramming.h:215

◆ bookGetPointer() [5/8]

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

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

Definition at line 146 of file AthHistogramming.cxx.

147{
148 // Modify the name and title according to the prefixes of this classes instance
149 std::string effName(effRef.GetName());
150 const std::string effTitle(effRef.GetTitle());
151 std::string bookingString("");
152
153 this->buildBookingString( bookingString, effName, tDir, stream );
154 effRef.SetTitle((m_histTitlePrefix+effTitle+m_histTitlePostfix).c_str() );
155 effRef.SetName(effName.c_str());
156
157 // Check if the hash for this effName already exists, i.e., if we have a hash collision
158 const hash_t effHash = this->hash(effName);
159 EffMap_t::const_iterator it = m_effMap.find( effHash );
160 if ( it != m_effMap.end() ) // It does exist!
161 {
162 m_msg << MSG::WARNING
163 << "Detected a hash collision. The hash for the TEfficiency with name=" << effName
164 << " already exists and points to a TEfficiency with name=" << it->second->GetName()
165 << " NOT going to book the new TEfficiency and returning a NULL pointer!" << endmsg;
166 return NULL;
167 }
168
169 // Set the new name and title for the TEfficiency, based on the prefixes that the user set for this class instance
170 // Create a clone that has the new name
171
172 // Massage the final string to book things
173
174 // Register the TEfficiency into the THistSvc
175 if ( !((histSvc()->regEfficiency(bookingString, &effRef)).isSuccess()) )
176 {
177 m_msg << MSG::WARNING
178 << "Problem registering TEfficiency with name " << effName
179 << ", name prefix " << m_histNamePrefix
180 << ", title " << effTitle
181 << ", tile prefix " << m_histTitlePrefix
182 << ", and tile postfix " << m_histTitlePostfix
183 << " in " << m_name << "!" << endmsg;
184 return NULL;
185 }
186
187 // Also register it in the local map of string to pointer
188 m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, &effRef ) );
189
190 return &effRef;
191}
AthHistogramming::m_effMap
EffMap_t m_effMap
The map of histogram names to their pointers.
Definition AthHistogramming.h:208

◆ bookGetPointer() [6/8]

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

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

Definition at line 293 of file AthHistogramming.h.

294{
295 if ( !hist ) {
296 m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency in bookGetPointer" << endmsg;
297 return 0;
298 }
299 return this->bookGetPointer( *hist, tDir, stream );
300}

◆ bookGetPointer() [7/8]

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

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

Definition at line 98 of file AthHistogramming.cxx.

99{
100 // Modify the name and title according to the prefixes of this classes instance
101 std::string histName(histRef.GetName());
102 const std::string histTitle(histRef.GetTitle());
103 std::string bookingString("");
104
105 this->buildBookingString( bookingString, histName, tDir, stream );
106 histRef.SetTitle((m_histTitlePrefix+histTitle+m_histTitlePostfix).c_str() );
107 histRef.SetName(histName.c_str());
108
109 // Check if the hash for this histName already exists, i.e., if we have a hash collision
110 const hash_t histHash = this->hash(histName);
111 HistMap_t::const_iterator it = m_histMap.find( histHash );
112 if ( it != m_histMap.end() ) // It does exist!
113 {
114 m_msg << MSG::WARNING
115 << "Detected a hash collision. The hash for the histogram with name=" << histName
116 << " already exists and points to a histogram with name=" << it->second->GetName()
117 << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
118 return NULL;
119 }
120
121 // Set the new name and title for the histogram, based on the prefixes that the user set for this class instance
122 // Create a clone that has the new name
123
124 // Massage the final string to book things
125
126 // Register the histogram into the THistSvc
127 if ( !((histSvc()->regHist(bookingString, &histRef)).isSuccess()) )
128 {
129 m_msg << MSG::WARNING
130 << "Problem registering histogram with name " << histName
131 << ", name prefix " << m_histNamePrefix
132 << ", title " << histTitle
133 << ", tile prefix " << m_histTitlePrefix
134 << ", and tile postfix " << m_histTitlePostfix
135 << " in " << m_name << "!" << endmsg;
136 return NULL;
137 }
138
139 // Also register it in the local map of string to pointer
140 m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, &histRef ) );
141
142 return &histRef;
143}
AthHistogramming::m_histMap
HistMap_t m_histMap
The map of histogram names to their pointers.
Definition AthHistogramming.h:201

◆ bookGetPointer() [8/8]

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

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

Definition at line 272 of file AthHistogramming.h.

273{
274 if ( !hist ) {
275 m_msg << MSG::ERROR << "Got a zero pointer to a TH1 in bookGetPointer" << endmsg;
276 return 0;
277 }
278 return this->bookGetPointer( *hist, tDir, stream );
279}

◆ buildBookingString()

void AthHistogramming::buildBookingString ( std::string & bookingString,
std::string & histName,
std::string & tDir,
std::string & stream,
bool usePrefixPostfix = false )
privateinherited

Method to build individual booking string.

Definition at line 560 of file AthHistogramming.cxx.

565{
566 // Massage the final string to book things
567 if(tDir.empty()) tDir = m_rootDir;
568 size_t pos = histName.rfind('/');
569 if(pos != std::string::npos){
570 tDir+='/';
571 tDir.append(histName, 0,pos);
572 histName.erase(0,pos+1);
573 };
574 if(stream.empty()) stream = m_streamName;
575
576 if(usePrefixPostfix){
577 bookingString = "/"+stream+"/"+tDir+"/"+m_histNamePrefix+histName+m_histNamePostfix;
578 } else {
579 bookingString = "/"+stream+"/"+tDir+"/"+histName;
580 }
581 while(bookingString.find("//") != std::string::npos){
582 this->myReplace(bookingString,"//","/");
583 }
584
585 return;
586}
AthHistogramming::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition AthHistogramming.h:229
AthHistogramming::m_streamName
std::string m_streamName
Name of the ROOT output stream (file)
Definition AthHistogramming.h:226
AthHistogramming::myReplace
void myReplace(std::string &str, const std::string &oldStr, const std::string &newStr)
Helper method to replace sub-string.
Definition AthHistogramming.cxx:590

◆ 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 by the derived classes to fill the internal configuration.

Definition at line 66 of file AthHistogramming.cxx.

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

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
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< 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 ( const std::string & effName,
const std::string & tDir = "",
const std::string & stream = "" )
protectedinherited

Simplify the retrieval of registered TEfficiency.

Definition at line 250 of file AthHistogramming.cxx.

251{
252 // Build a 32 bit hash out of the name
253 const hash_t effHash = this->hash(effName);
254
255 // See if this entry exists in the map
256 EffMap_t::const_iterator it = m_effMap.find( effHash );
257 if ( it == m_effMap.end() ) // It doesn't exist!
258 { // Let's see into the THistSvc if somebody else has registered the TEfficiency...
259
260 // Need to copy the strings as we will massage them from here on
261 std::string effNameCopy = effName;
262 std::string tDirCopy = tDir;
263 std::string streamCopy = stream;
264
265 // Massage the final string to book things
266 std::string bookingString("");
267 this->buildBookingString( bookingString, effNameCopy, tDirCopy, streamCopy ,false);
268
269 TEfficiency* effPointer(NULL);
270 if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
271 {
272 // Massage the final string to book things
273 std::string bookingString("");
274 this->buildBookingString( bookingString, effNameCopy, tDirCopy, streamCopy, true );
275
276 if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
277 {
278 m_msg << MSG::WARNING
279 << "Problem retrieving the TEfficiency with name (including pre- and post-fixes) "
280 << m_histNamePrefix + effNameCopy + m_histNamePostfix
281 << " or with name " << effNameCopy
282 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
283 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
284 return NULL;
285 }
286 // If we get to here, we actually found the TEfficiency in the THistSvc.
287 // So let's add it to the local cache map and return its pointer
288 m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
289 return effPointer;
290 }
291 // If we get to here, we actually found the TEfficiency in the THistSvc.
292 // So let's add it to the local cache map and return its pointer
293 m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
294 return effPointer;
295 }
296
297 // Return the pointer to the TEfficiency that we got from the local cache map
298 return it->second;
299}

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ execute()

StatusCode PixelRDOAnalysis::execute ( )
finaloverridevirtual

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 const EventContext& ctx{Gaudi::Hive::currentContext()};
396
397 const PixelRDO_Container* p_pixelRDO_cont{nullptr};
398 ATH_CHECK(SG::get(p_pixelRDO_cont, m_inputKey, ctx));
399 //Adding SimMap and McEvent here for added truthMatching checks
400 const InDetSimDataCollection* simDataMapPixel{nullptr};
401 ATH_CHECK(SG::get(simDataMapPixel, m_inputTruthKey, ctx));
402 const McEventCollection* mcEventCollection{nullptr};
403 ATH_CHECK(SG::get(mcEventCollection, m_inputMcEventCollectionKey, ctx));
404 bool doTruthMatching = true;
405 const HepMC::GenEvent* hardScatterEvent(nullptr);
406
407 if (mcEventCollection->size()==0){
408 ATH_MSG_WARNING("Failed to retrieve a nonzero sized truth event collection, disabling truthMatching");
409 doTruthMatching = false;
410 }
411 if(doTruthMatching) hardScatterEvent = mcEventCollection->at(0);
412
413 if(p_pixelRDO_cont) {
414 // loop over RDO container
415 PixelRDO_Container::const_iterator rdoCont_itr(p_pixelRDO_cont->begin());
416 const PixelRDO_Container::const_iterator rdoCont_end(p_pixelRDO_cont->end());
417 for ( ; rdoCont_itr != rdoCont_end; ++rdoCont_itr ) {
418 const PixelRDO_Collection* p_pixelRDO_coll(*rdoCont_itr);
419 PixelRDO_Collection::const_iterator rdo_itr(p_pixelRDO_coll->begin());
420 const PixelRDO_Collection::const_iterator rdo_end(p_pixelRDO_coll->end());
421
422 const Identifier rdoIDColl(p_pixelRDO_coll->identify());
423 const int pixBrlEc(m_pixelID->barrel_ec(rdoIDColl));
424 const int pixLayerDisk(m_pixelID->layer_disk(rdoIDColl));
425 const int pixPhiMod(m_pixelID->phi_module(rdoIDColl));
426 const int pixEtaMod(m_pixelID->eta_module(rdoIDColl));
427 const int pixIsInnermost(0);
428 const int pixIsNextToInnermost(0);
429 //These are not yet implemented! Need to
430 //const int pixIsInnermost(m_pixelID->is_innermost(rdoIDColl));
431 //const int pixIsNextToInnermost(m_pixelID->is_nexttoinnermost(rdoIDColl));
432
433 const InDetDD::SiDetectorElement *detEl = m_pixelManager->getDetectorElement(rdoIDColl);
434
435 for ( ; rdo_itr != rdo_end; ++rdo_itr ) {
436 if(doTruthMatching){
437 m_h_truthMatchedRDOs->Fill(1.5);
438 bool findMatch = false;
439 if(simDataMapPixel){
440 InDetSimDataCollection::const_iterator iter = (*simDataMapPixel).find((*rdo_itr)->identify());
441
442 if ( iter != (*simDataMapPixel).end() ) {
443 const InDetSimData& sdo = iter->second;
444 const std::vector< InDetSimData::Deposit >& deposits = sdo.getdeposits();
445 std::vector< InDetSimData::Deposit >::const_iterator nextdeposit = deposits.begin();
446 std::vector< InDetSimData::Deposit >::const_iterator lastdeposit = deposits.end();
447 for( ; nextdeposit!=lastdeposit; ++nextdeposit) {
448 const HepMcParticleLink& particleLink = nextdeposit->first;
449 if(particleLink.isValid() && !findMatch){
450 HepMC::ConstGenParticlePtr genPart(particleLink.cptr());
451 if(genPart->parent_event() == hardScatterEvent) m_h_truthMatchedRDOs->Fill(3.5);
452 m_h_truthMatchedRDOs->Fill(2.5);
453 findMatch = true;
454 }
455 }
456 }
457 }
458 if(!findMatch) m_h_truthMatchedRDOs->Fill(4.5);
459 }
460 const Identifier rdoID((*rdo_itr)->identify());
461 const unsigned int rdoWord((*rdo_itr)->getWord());
462 const int pixPhiIx(m_pixelID->phi_index(rdoID));
463 const int pixEtaIx(m_pixelID->eta_index(rdoID));
464 const int pixToT((*rdo_itr)->getToT());
465 const int pixBCID((*rdo_itr)->getBCID());
466 const int pixLVL1A((*rdo_itr)->getLVL1A());
467 const int pixLVL1ID((*rdo_itr)->getLVL1ID());
468
469 //NB This is the position without lorentz correction
470 //(ATLSWUPGR-103)
471 //NB rationlization as here should probably also be done in master
472 //https://gitlab.cern.ch/atlas/athena/-/merge_requests/33398
473 InDetDD::SiLocalPosition localPos = detEl->rawLocalPositionOfCell(rdoID);
474 Amg::Vector3D globalPos = detEl->globalPosition(localPos);
475 if (m_doPosition) {
476 m_globalX->push_back(globalPos[Amg::x]);
477 m_globalY->push_back(globalPos[Amg::y]);
478 m_globalZ->push_back(globalPos[Amg::z]);
479
480 m_localX->push_back(localPos.xPhi());
481 m_localY->push_back(localPos.xEta());
482 m_localZ->push_back(localPos.xDepth());
483 }
484 float pixelRadius = sqrt(globalPos[Amg::x]*globalPos[Amg::x]+globalPos[Amg::y]*globalPos[Amg::y]);
485 m_h_globalXY->Fill(globalPos[Amg::x],globalPos[Amg::y]);
486 m_h_globalXY_shared->Fill(globalPos[Amg::x],globalPos[Amg::y]);
487 m_h_globalZR->Fill(globalPos[Amg::z],pixelRadius);
488 m_h_globalZR_shared->Fill(globalPos[Amg::z],pixelRadius);
489 m_h_globalX->Fill(globalPos[Amg::x]);
490 m_h_globalY->Fill(globalPos[Amg::y]);
491 m_h_globalZ->Fill(globalPos[Amg::z]);
492 const unsigned long long rdoID_int = rdoID.get_compact();
493 m_rdoID->push_back(rdoID_int);
494 m_rdoWord->push_back(rdoWord);
495 m_barrelEndcap->push_back(pixBrlEc);
496 m_layerDisk->push_back(pixLayerDisk);
497 m_phiModule->push_back(pixPhiMod);
498 m_etaModule->push_back(pixEtaMod);
499 m_isInnermost->push_back(pixIsInnermost);
500 m_isNextToInnermost->push_back(pixIsNextToInnermost);
501 m_phiIndex->push_back(pixPhiIx);
502 m_etaIndex->push_back(pixEtaIx);
503 m_ToT->push_back(pixToT);
504 m_BCID->push_back(pixBCID);
505 m_LVL1A->push_back(pixLVL1A);
506 m_LVL1ID->push_back(pixLVL1ID);
507
508 m_h_rdoID->Fill(rdoID_int);
509 m_h_rdoWord->Fill(rdoWord);
510 m_h_barrelEndcap->Fill(pixBrlEc);
511 m_h_layerDisk->Fill(pixLayerDisk);
512 m_h_phiModule->Fill(pixPhiMod);
513 m_h_etaModule->Fill(pixEtaMod);
514 m_h_phiIndex->Fill(pixPhiIx);
515 m_h_etaIndex->Fill(pixEtaIx);
516 m_h_ToT->Fill(pixToT);
517 m_h_BCID->Fill(pixBCID);
518 m_h_LVL1A->Fill(pixLVL1A);
519 m_h_LVL1ID->Fill(pixLVL1ID);
520
521 if (pixIsInnermost) {
522 m_h_phiIndexInnermost->Fill(pixPhiIx);
523 m_h_etaIndexInnermost->Fill(pixEtaIx);
524 } else if (pixIsNextToInnermost) {
525 m_h_phiIndexNextToInnermost->Fill(pixPhiIx);
526 m_h_etaIndexNextToInnermost->Fill(pixEtaIx);
527 }
528
529 //isInclined not yet implemented
530 //if (detEl->isBarrel() || detEl->isInclined()) {
531 if (detEl->isBarrel()){
532 m_h_brlLayer->Fill(pixLayerDisk);
533 m_h_brlPhiMod->Fill(pixPhiMod);
534 m_h_brlEtaMod->Fill(pixEtaMod);
535 m_h_brlPhiIndex->Fill(pixPhiIx);
536 m_h_brlEtaIndex->Fill(pixEtaIx);
537 m_h_brlToT->Fill(pixToT);
538 m_h_brlBCID->Fill(pixBCID);
539 m_h_brlLVL1A->Fill(pixLVL1A);
540 m_h_brlLVL1ID->Fill(pixLVL1ID);
541
542 //if (detEl->isInclined()) {
543 // m_h_brlinclPhiIndex_perLayer[pixLayerDisk]->Fill(pixPhiIx);
544 // m_h_brlinclEtaIndex_perLayer[pixLayerDisk]->Fill(pixEtaIx);
545 //} else {
546 m_h_brlflatPhiIndex_perLayer[pixLayerDisk]->Fill(pixPhiIx);
547 m_h_brlflatEtaIndex_perLayer[pixLayerDisk]->Fill(pixEtaIx);
548 //}
549
550 }
551 else if (detEl->isEndcap()) {
552 m_h_ecDisk->Fill(pixLayerDisk);
553 m_h_ecPhiMod->Fill(pixPhiMod);
554 m_h_ecEtaMod->Fill(pixEtaMod);
555 m_h_ecPhiIndex->Fill(pixPhiIx);
556 m_h_ecEtaIndex->Fill(pixEtaIx);
557 m_h_ecToT->Fill(pixToT);
558 m_h_ecBCID->Fill(pixBCID);
559 m_h_ecLVL1A->Fill(pixLVL1A);
560 m_h_ecLVL1ID->Fill(pixLVL1ID);
561
562 m_h_ecPhiIndex_perLayer[pixLayerDisk]->Fill(pixPhiIx);
563 m_h_ecEtaIndex_perLayer[pixLayerDisk]->Fill(pixEtaIx);
564
565 }
566 }
567 }
568 }
569
570 // Sim Data
571 if(simDataMapPixel) {
572 // loop over SDO container
573 InDetSimDataCollection::const_iterator sdo_itr(simDataMapPixel->begin());
574 const InDetSimDataCollection::const_iterator sdo_end(simDataMapPixel->end());
575
576 std::vector<int> barcode_vec;
577 std::vector<int> eventIndex_vec;
578 std::vector<float> charge_vec;
579 for ( ; sdo_itr != sdo_end; ++sdo_itr ) {
580 const Identifier sdoID((*sdo_itr).first);
581 const InDetSimData& sdo((*sdo_itr).second);
582 const unsigned long long sdoID_int = sdoID.get_compact();
583 const int sdoWord(sdo.word());
584 const int pixBrlEc_sdo(m_pixelID->barrel_ec(sdoID));
585 const int pixLayerDisk_sdo(m_pixelID->layer_disk(sdoID));
586 const int pixPhiMod_sdo(m_pixelID->phi_module(sdoID));
587 const int pixEtaMod_sdo(m_pixelID->eta_module(sdoID));
588 const int pixPhiIx_sdo(m_pixelID->phi_index(sdoID));
589 const int pixEtaIx_sdo(m_pixelID->eta_index(sdoID));
590 const bool noise(PixelSimHelper::isNoise(sdo));
591 const bool belowThresh(PixelSimHelper::isBelowThreshold(sdo));
592 const bool disabled(PixelSimHelper::isDisabled(sdo));
593 const bool badTOT(PixelSimHelper::hasBadTOT(sdo));
594
595 m_sdoID->push_back(sdoID_int);
596 m_sdoWord->push_back(sdoWord);
597 m_barrelEndcap_sdo->push_back(pixBrlEc_sdo);
598 m_layerDisk_sdo->push_back(pixLayerDisk_sdo);
599 m_phiModule_sdo->push_back(pixPhiMod_sdo);
600 m_etaModule_sdo->push_back(pixEtaMod_sdo);
601 m_phiIndex_sdo->push_back(pixPhiIx_sdo);
602 m_etaIndex_sdo->push_back(pixEtaIx_sdo);
603 m_noise->push_back(noise);
604
605 m_belowThresh->push_back(belowThresh);
606 if (belowThresh) {
607 if (pixBrlEc_sdo==0)
608 m_h_belowThresh_brl->Fill(pixLayerDisk_sdo);
609 else if (abs(pixBrlEc_sdo)==2)
610 m_h_belowThresh_ec->Fill(pixLayerDisk_sdo);
611 }
612
613 m_disabled->push_back(disabled);
614 if (disabled) {
615 if (pixBrlEc_sdo==0)
616 m_h_disabled_brl->Fill(pixLayerDisk_sdo);
617 else if (abs(pixBrlEc_sdo)==2)
618 m_h_disabled_ec->Fill(pixLayerDisk_sdo);
619 }
620
621 m_badTOT->push_back(badTOT);
622
623 m_h_sdoID->Fill(sdoID_int);
624 m_h_sdoWord->Fill(sdoWord);
625 m_h_barrelEndcap_sdo->Fill(pixBrlEc_sdo);
626 m_h_layerDisk_sdo->Fill(pixLayerDisk_sdo);
627 m_h_phiModule_sdo->Fill(pixPhiMod_sdo);
628 m_h_etaModule_sdo->Fill(pixEtaMod_sdo);
629 m_h_phiIndex_sdo->Fill(pixPhiIx_sdo);
630 m_h_etaIndex_sdo->Fill(pixEtaIx_sdo);
631
632 // loop over deposits
633 const std::vector<InDetSimData::Deposit>& deposits = sdo.getdeposits();
634 std::vector<InDetSimData::Deposit>::const_iterator dep_itr(deposits.begin());
635 const std::vector<InDetSimData::Deposit>::const_iterator dep_end(deposits.end());
636 for ( ; dep_itr != dep_end; ++dep_itr ) {
637 const HepMcParticleLink& particleLink = (*dep_itr).first;
638 const int bar(HepMC::barcode(particleLink)); // FIXME barcode-based
639 const int eventIx(particleLink.eventIndex());
640 const int charge((*dep_itr).second);
641
642 m_barcode->push_back(bar);
643 m_eventIndex->push_back(eventIx);
644 m_charge->push_back(charge);
645
646 m_h_barcode->Fill(bar);
647 m_h_eventIndex->Fill(eventIx);
648 m_h_charge->Fill(charge);
649
650 barcode_vec.push_back(bar);
651 eventIndex_vec.push_back(eventIx);
652 charge_vec.push_back(charge);
653 }
654 m_barcode_vec->push_back(barcode_vec);
655 m_eventIndex_vec->push_back(eventIndex_vec);
656 m_charge_vec->push_back(charge_vec);
657 barcode_vec.clear();
658 eventIndex_vec.clear();
659 charge_vec.clear();
660 }
661 }
662
663 m_tree->Fill();
664
665 return StatusCode::SUCCESS;
666}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
charge
double charge(const T &p)
Definition AtlasPID.h:997
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:838
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:80
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition IdentifiableContainerMT.h:240
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition IdentifiableContainerMT.h:234
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:47
HepMC::barcode
int barcode(const T *p)
Definition Barcode.h:16
HepMC::ConstGenParticlePtr
const GenParticle * ConstGenParticlePtr
Definition GenParticle.h:38
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:283

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ graph()

TGraph * AthHistogramming::graph ( const std::string & graphName,
const std::string & tDir = "",
const std::string & stream = "" )
protectedinherited

Simplify the retrieval of registered TGraphs.

Definition at line 492 of file AthHistogramming.cxx.

493{
494 // Build a 32 bit hash out of the name
495 const hash_t graphHash = this->hash(graphName);
496
497 // See if this entry exists in the map
498 GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
499 if ( it == m_graphMap.end() ) // It doesn't exist!
500 { // Let's see into the THistSvc if somebody else has registered the TGraph...
501
502 // Need to copy the strings as we will massage them from here on
503 std::string graphNameCopy = graphName;
504 std::string tDirCopy = tDir;
505 std::string streamCopy = stream;
506
507 // Massage the final string to book things
508 std::string bookingString("");
509 this->buildBookingString( bookingString, graphNameCopy, tDirCopy, streamCopy, true);
510
511 TGraph* graphPointer(NULL);
512 if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
513 {
514 // Massage the final string to book things
515 std::string bookingString("");
516 this->buildBookingString( bookingString, graphNameCopy, tDirCopy, streamCopy, false );
517
518 if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
519 {
520 m_msg << MSG::WARNING
521 << "Problem retrieving the TGraph with name (including pre- and post-fixes) "
522 << m_histNamePrefix + graphNameCopy + m_histNamePostfix
523 << " or with name " << graphNameCopy
524 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
525 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
526 return NULL;
527 }
528 // If we get to here, we actually found the TGraph in the THistSvc.
529 // So let's add it to the local cache map and return its pointer
530 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
531 return graphPointer;
532 }
533 // If we get to here, we actually found the TGraph in the THistSvc.
534 // So let's add it to the local cache map and return its pointer
535 m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
536 return graphPointer;
537 }
538
539
540 // Return the pointer to the TGraph that we got from the local cache map
541 return it->second;
542}

◆ hash()

AthHistogramming::hash_t AthHistogramming::hash ( const std::string & histName) const
inlineprivateinherited

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

Definition at line 428 of file AthHistogramming.h.

429{
430 const uint64_t hash64 = CxxUtils::crc64( histName );
431 return (hash_t)(hash64 & 0xFFFFFFFF);
432}
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:696
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 ( const std::string & histName,
const std::string & tDir = "",
const std::string & stream = "" )
protectedinherited

Simplify the retrieval of registered histograms of any type.

Definition at line 198 of file AthHistogramming.cxx.

199{
200 // Build a 32 bit hash out of the name
201 const hash_t histHash = this->hash(histName);
202
203 // See if this entry exists in the map
204 HistMap_t::const_iterator it = m_histMap.find( histHash );
205 if ( it == m_histMap.end() ) // It doesn't exist!
206 { // Let's see into the THistSvc if somebody else has registered the histogram...
207
208 // Need to copy the strings as we will massage them from here on
209 std::string histNameCopy = histName;
210 std::string tDirCopy = tDir;
211 std::string streamCopy = stream;
212
213 // Massage the final string to book things
214 std::string bookingString("");
215 this->buildBookingString( bookingString, histNameCopy, tDirCopy, streamCopy ,false);
216
217 TH1* histPointer(NULL);
218 if ( !((histSvc()->getHist(bookingString, histPointer)).isSuccess()) )
219 {
220 // Massage the final string to book things
221 std::string bookingString("");
222 this->buildBookingString( bookingString, histNameCopy, tDirCopy, streamCopy, true );
223
224 if ( !((histSvc()->getHist(bookingString, histPointer)).isSuccess()) )
225 {
226 m_msg << MSG::WARNING
227 << "Problem retrieving the histogram with name (including pre- and post-fixes) "
228 << m_histNamePrefix + histNameCopy + m_histNamePostfix
229 << " or with name " << histNameCopy
230 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
231 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
232 return NULL;
233 }
234 // If we get to here, we actually found the histogram in the THistSvc.
235 // So let's add it to the local cache map and return its pointer
236 m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, histPointer ) );
237 return histPointer;
238 }
239 // If we get to here, we actually found the histogram in the THistSvc.
240 // So let's add it to the local cache map and return its pointer
241 m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, histPointer ) );
242 return histPointer;
243 }
244
245
246 // Return the pointer to the histogram that we got from the local cache map
247 return it->second;
248}

◆ hist2d()

TH2 * AthHistogramming::hist2d ( const std::string & histName,
const std::string & tDir = "",
const std::string & stream = "" )
inlineprotectedinherited

Simplify the retrieval of registered 2-d histograms.

Definition at line 369 of file AthHistogramming.h.

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

◆ hist3d()

TH3 * AthHistogramming::hist3d ( const std::string & histName,
const std::string & tDir = "",
const std::string & stream = "" )
inlineprotectedinherited

Simplify the retrieval of registered 3-d histograms.

Definition at line 386 of file AthHistogramming.h.

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

◆ 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}
AthCommonDataStore< AthCommonMsg< 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.PyKernel.retrieve
retrieve(aClass, aKey=None)
Definition PyKernel.py:110
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< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

◆ myReplace()

void AthHistogramming::myReplace ( std::string & str,
const std::string & oldStr,
const std::string & newStr )
privateinherited

Helper method to replace sub-string.

Definition at line 590 of file AthHistogramming.cxx.

593{
594 size_t pos = 0;
595 while((pos = str.find(oldStr, pos)) != std::string::npos)
596 {
597 str.replace(pos, oldStr.length(), newStr);
598 pos += newStr.length();
599 }
600}

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
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< Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
365 handlesArray.renounce();
366 }

◆ sysInitialize()

StatusCode 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 AthAlgorithm.

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}
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition AthAlgorithm.cxx:66
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 by the derived classes to fill the internal configuration.
Definition AthHistogramming.cxx:66

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ tree()

TTree * AthHistogramming::tree ( const std::string & treeName,
const std::string & tDir = "",
const std::string & stream = "" )
protectedinherited

Simplify the retrieval of registered TTrees.

Definition at line 378 of file AthHistogramming.cxx.

379{
380 // Build a 32 bit hash out of the name
381 const hash_t treeHash = this->hash(treeName);
382
383 // See if this entry exists in the map
384 TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
385 if ( it == m_treeMap.end() ) // It doesn't exist!
386 { // Let's see into the THistSvc if somebody else has registered the TTree...
387
388 // Need to copy the strings as we will massage them from here on
389 std::string treeNameCopy = treeName;
390 std::string tDirCopy = tDir;
391 std::string streamCopy = stream;
392
393 // Massage the final string to book things
394 std::string bookingString("");
395 this->buildBookingString( bookingString, treeNameCopy, tDirCopy, streamCopy );
396
397 TTree* treePointer(NULL);
398 if ( !((histSvc()->getTree(bookingString, treePointer)).isSuccess()) )
399 {
400 m_msg << MSG::WARNING
401 << "Problem retrieving the TTree with name " << treeNameCopy
402 << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
403 << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
404 return NULL;
405 }
406 // If we get to here, we actually found the TTree in the THistSvc.
407 // So let's add it to the local cache map and return its pointer
408 m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treePointer ) );
409 return treePointer;
410 }
411
412 // Return the pointer to the TTree that we got from the local cache map
413 return it->second;
414}

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:398

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< 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 208 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< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_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 222 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 201 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 248 of file AthHistogramming.h.

◆ m_name

std::string AthHistogramming::m_name
privateinherited

Instance name.

Definition at line 245 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 226 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 215 of file AthHistogramming.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

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