ATLAS Offline Software
Loading...
Searching...
No Matches
MuonValR4::MuonFastRecoTester Class Reference

#include <MuonFastRecoTester.h>

Inheritance diagram for MuonValR4::MuonFastRecoTester:

Public Types

using simHitSet = std::vector<const xAOD::MuonSimHit*>
using TruthParticleMap = std::map<const xAOD::TruthParticle*, std::vector<simHitSet>>

Public Member Functions

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

Protected Member Functions

virtual bool isReEntrant () const override final
 Legacy algorithms are not thread-safe.
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.
StatusCode configAthHistogramming (const ServiceHandle< ITHistSvc > &histSvc, const std::string &prefix, const std::string &rootDir, const std::string &histNamePrefix, const std::string &histNamePostfix, const std::string &histTitlePrefix, const std::string &histTitlePostfix)
 To be called to fill the internal configuration.
TH1 * bookGetPointer (const TH1 &hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 *hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TH1 * bookGetPointer (TH1 &histRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
TTree * bookGetPointer (const TTree &treeRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
TGraph * bookGetPointer (const TGraph &graphRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
TEfficiency * bookGetPointer (const TEfficiency &eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency *eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency * bookGetPointer (TEfficiency &effRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (const TH1 &hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 *hist, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (TH1 &histRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of histograms.
StatusCode book (const TTree &treeRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TTrees.
StatusCode book (const TGraph &graphRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TGraphs.
StatusCode book (const TEfficiency &eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency *eff, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode book (TEfficiency &effRef, std::string_view tDir="", std::string_view stream="")
 Simplify the booking and registering (into THistSvc) of TEfficiency.
TH1 * hist (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered histograms of any type.
TH2 * hist2d (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered 2-d histograms.
TH3 * hist3d (std::string_view histName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered 3-d histograms.
TTree * tree (std::string_view treeName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TTrees.
TGraph * graph (std::string_view graphName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TGraphs.
TEfficiency * efficiency (std::string_view effName, std::string_view tDir="", std::string_view stream="")
 Simplify the retrieval of registered TEfficiency.

Private Types

enum class  measType { Prec , NonPrec , Phi , nTypes }
 Enum for measurement types. More...
enum class  ePatBranchType : std::uint8_t {
  eReco , eTruth , ePileup , eMismatched ,
  eAll
}
 Enum for different types of pattern hit content branches. More...
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

TruthParticleMap fillTruthMap (const xAOD::MuonSegmentContainer *truthSegments, const TrigRoiDescriptorCollection *roiCollection) const
 Fill the truth particle map.
void fillSpacePointInfo (const MuonR4::SpacePointContainer *spc, const MuonR4::GlobalPatternContainer *patternCont, const TruthParticleMap &truthHits, SpacePointTesterModule &spTester, MuonVal::VectorBranch< unsigned char > &spTypeBranch, MuonVal::MatrixBranch< unsigned char > &spMatchedToPatternBranch, MuonVal::MatrixBranch< unsigned char > &spMatchedToTruthBranch) const
 Fill the space point information into the tree.
void fillGlobPatternInfo (const MuonR4::GlobalPatternContainer *patternCont, const TruthParticleMap &truthHits, const std::vector< const MuonR4::SpacePointContainer * > &spContainers)
 Fill the info associated to the global patterns into the tree.
void fillFastRecoMuonInfo (const xAOD::MuonContainer *muonCont, const MuonR4::GlobalPatternContainer *patternCont)
 Fill the info associated to fast reco muons.
void fillTruthInfo (const TruthParticleMap &truthHits, const std::vector< const MuonR4::SpacePointContainer * > &spContainers)
 Fill the truth particle information into the tree.
void fillRoIInfo (const TrigRoiDescriptorCollection *roiCollection)
 Fill the RoI information into the tree.
void updatePatHitInfo (const ePatBranchType type, const std::size_t patIdx, const Muon::MuonStationIndex::StIndex hitSt, const MuonR4::SpacePoint *sp, const bool isSecondaryMatched=false)
 Update the hit counts for a given pattern branch type.
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>
std::string buildBookingString (std::string_view histName, std::string_view tDir, std::string_view stream, bool usePrefixPostfix=false) const
 Method to build individual booking string.
hash_t hash (std::string_view histName) const
 Method to calculate a 32-bit hash from a string.

Private Attributes

MuonVal::MuonTesterTree m_tree {"MuonFastRecoTest","FastRecoTester"}
SG::ReadHandleKey< MuonR4::SpacePointContainer > m_spKey {this, "SpacePointKey", "MuonSpacePoints"}
SG::ReadHandleKey< MuonR4::SpacePointContainer > m_NSWspKey {this, "NswSpacePointKey", "NswSpacePoints"}
SG::ReadHandleKey< MuonR4::GlobalPatternContainer > m_patternKey {this, "PatternKey", "MuonR4GlobalPatterns", "global pattern container"}
SG::ReadHandleKey< xAOD::MuonContainer > m_fastMuonKey {this, "FastMuonKey", "FastRecoSAMuons", "fast reco muon container"}
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_truthSegmentKey {this, "TruthSegmentKey","MuonTruthSegments", "truth segment container"}
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey {this, "MuRoIs", "EFMuMSReco_RoI", "Name of the input data from HLTSeeding"}
ActsTrk::GeoContextReadKey_t m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
BooleanProperty m_isMC {this, "isMC", false, "Toggle whether the job is ran on MC or not"}
BooleanProperty m_isSeededReco {this, "isSeededReco", false, "Toggle whether the job is ran on seeded reconstruction or not"}
BooleanProperty m_writeSpacePoints
std::shared_ptr< SpacePointTesterModule > m_spTester {}
 ====== Spacepoint block ===========
std::shared_ptr< SpacePointTesterModule > m_NSWspTester {}
MuonVal::VectorBranch< unsigned char > & m_spType {m_tree.newVector<unsigned char>(m_spKey.key()+"_type")}
 Type of spacepoints: 1 for trigger eta, 2 for precision, 3 for only-phi.
MuonVal::VectorBranch< unsigned char > & m_NSWspType {m_tree.newVector<unsigned char>(m_NSWspKey.key()+"_type")}
MuonVal::MatrixBranch< unsigned char > & m_spMatchedToPattern {m_tree.newMatrix<unsigned char>(m_spKey.key()+"_patternMatched")}
 Branch indicating which space points in the tree are associated to the i-th pattern.
MuonVal::MatrixBranch< unsigned char > & m_NSWspMatchedToPattern {m_tree.newMatrix<unsigned char>(m_NSWspKey.key()+"_patternMatched")}
MuonVal::MatrixBranch< unsigned char > & m_spMatchedToTruth {m_tree.newMatrix<unsigned char>(m_spKey.key()+"_truthMatched")}
 Branch indicating which space points in the tree are associated to the i-th truth particle.
MuonVal::MatrixBranch< unsigned char > & m_NSWspMatchedToTruth {m_tree.newMatrix<unsigned char>(m_NSWspKey.key()+"_truthMatched")}
MuonVal::VectorBranch< short > & m_gen_Q {m_tree.newVector<short>("gen_Q", 0)}
 ====== Truth particle block ===========
MuonVal::VectorBranch< float > & m_gen_Eta {m_tree.newVector<float>("gen_Eta",-10.)}
MuonVal::VectorBranch< float > & m_gen_Phi {m_tree.newVector<float>("gen_Phi",-10.)}
MuonVal::VectorBranch< float > & m_gen_Pt {m_tree.newVector<float>("gen_Pt",-10.)}
MuonVal::MatrixBranch< unsigned char > & m_gen_nNonPrecMeas {m_tree.newMatrix<unsigned char>("gen_NNonPrecMeas", 0)}
 Number of trigger eta measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_gen_nPrecMeas {m_tree.newMatrix<unsigned char>("gen_NPrecMeas", 0)}
 Number of precision measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_gen_nPhiMeas {m_tree.newMatrix<unsigned char>("gen_NPhiMeas", 0)}
 Number of phi measurements per station.
MuonVal::ScalarBranch< unsigned > & m_pat_n {m_tree.newScalar<unsigned>("pat_nPatterns", 0)}
 ====== Global Pattern block ===========
MuonVal::VectorBranch< float > & m_pat_Eta {m_tree.newVector<float>("pat_Eta", 0.0)}
 pattern average theta & phi
MuonVal::VectorBranch< float > & m_pat_phi {m_tree.newVector<float>("pat_Phi", 0.0)}
MuonVal::VectorBranch< uint16_t > & m_pat_sector1 {m_tree.newVector<uint16_t>("pat_Sector1", 0)}
 pattern primary & secondary sectors (different if the pattern is in the sector overlap)
MuonVal::VectorBranch< uint16_t > & m_pat_sector2 {m_tree.newVector<uint16_t>("pat_Sector2", 0)}
MuonVal::VectorBranch< float > & m_pat_meanNormResidual2 {m_tree.newVector<float>("pat_meanNormResidual2", 0.0)}
 mean square normalized pattern residual
MuonVal::VectorBranch< short > & m_pat_side {m_tree.newVector<short>("pat_Side", 0)}
 +1 for A-, -1 of C-side
MuonVal::VectorBranch< unsigned char > & m_pat_nStations {m_tree.newVector<unsigned char>("pat_NStations", 0)}
 Number of stations.
MuonVal::MatrixBranch< unsigned char > & m_pat_nNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NNonPrecMeas", 0)}
 Number of trigger eta measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPrecMeas {m_tree.newMatrix<unsigned char>("pat_NPrecMeas", 0)}
 Number of precision measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPhiMeas {m_tree.newMatrix<unsigned char>("pat_NPhiMeas", 0)}
 Number of phi measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nTruthNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NTruthNonPrecMeas", 0)}
 Number of truth trigger eta measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nTruthPrecMeas {m_tree.newMatrix<unsigned char>("pat_NTruthPrecMeas", 0)}
 Number of truth precision measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nTruthPhiMeas {m_tree.newMatrix<unsigned char>("pat_NTruthPhiMeas", 0)}
 Number of truth phi measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nMisTruthNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NMisTruthNonPrecMeas", 0)}
 Number of mismatched truth trigger eta measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nMisTruthPrecMeas {m_tree.newMatrix<unsigned char>("pat_NMisTruthPrecMeas", 0)}
 Number of mismatched truth precision measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nMisTruthPhiMeas {m_tree.newMatrix<unsigned char>("pat_NMisTruthPhiMeas", 0)}
 Number of mismatched truth phi measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPileupNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NPileupNonPrecMeas", 0)}
 Number of pileup trigger eta measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPileupPrecMeas {m_tree.newMatrix<unsigned char>("pat_NPileupPrecMeas", 0)}
 Number of pileup precision measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPileupPhiMeas {m_tree.newMatrix<unsigned char>("pat_NPileupPhiMeas", 0)}
 Number of pileup phi measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nAllNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NAllNonPrecMeas", 0)}
 Number of trigger eta measurements in the buckets crossed by the pattern, grouped by station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nAllPrecMeas {m_tree.newMatrix<unsigned char>("pat_NAllPrecMeas", 0)}
 Number of precision measurements in the buckets crossed by the pattern, grouped by station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nAllPhiMeas {m_tree.newMatrix<unsigned char>("pat_NAllPhiMeas", 0)}
 Number of phi measurements in the buckets crossed by the pattern, grouped by station.
MuonVal::MatrixBranch< unsigned char > & m_pat_MatchedToTruth {m_tree.newMatrix<unsigned char>("pat_truthMatched")}
 Branch indicating which truth particles in the tree are associated to the i-th pattern.
MuonVal::VectorBranch< float > & m_roi_EtaMin {m_tree.newVector<float>("roi_EtaMin",-10.)}
 ====== RoI info ===========
MuonVal::VectorBranch< float > & m_roi_EtaMax {m_tree.newVector<float>("roi_EtaMax",-10.)}
MuonVal::VectorBranch< float > & m_roi_PhiMin {m_tree.newVector<float>("roi_PhiMin",-10.)}
MuonVal::VectorBranch< float > & m_roi_PhiMax {m_tree.newVector<float>("roi_PhiMax",-10.)}
MuonVal::VectorBranch< float > & m_roi_ZMin {m_tree.newVector<float>("roi_ZMin",-10.)}
MuonVal::VectorBranch< float > & m_roi_ZMax {m_tree.newVector<float>("roi_ZMax",-10.)}
MuonVal::VectorBranch< float > & m_muon_Eta {m_tree.newVector<float>("muon_Eta", -10.)}
 ====== Fast Reco Muon info ===========
MuonVal::VectorBranch< float > & m_muon_Phi {m_tree.newVector<float>("muon_Phi", -10.)}
MuonVal::VectorBranch< float > & m_muon_Pt {m_tree.newVector<float>("muon_Pt", -10.)}
MuonVal::VectorBranch< short > & m_muon_Q {m_tree.newVector<short>("muon_Q", 0)}
MuonVal::VectorBranch< unsigned char > & m_muon_MatchedToPattern {m_tree.newVector<unsigned char>("muon_patMatched")}
MuonR4::SpacePointPerLayerSorter m_spSorter {}
ServiceHandle< ITHistSvc > m_histSvc
 Default constructor: AthHistogramAlgorithm();.
std::string m_prefix
 Name of the ROOT output stream (file).
std::string m_rootDir
 Name of the ROOT directory.
std::string m_histNamePrefix
 The prefix for the histogram THx name.
std::string m_histNamePostfix
 The postfix for the histogram THx name.
std::string m_histTitlePrefix
 The prefix for the histogram THx title.
std::string m_histTitlePostfix
 The postfix for the histogram THx title.
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared
HistMap_t m_histMap
 The map of histogram names to their pointers.
EffMap_t m_effMap
 The map of histogram names to their pointers.
TreeMap_t m_treeMap
 The map of TTree names to their pointers.
GraphMap_t m_graphMap
 The map of TGraph names to their pointers.
std::string m_streamName
 Name of the ROOT output stream (file).
std::string m_name
 Instance name.
MsgStream m_msg
 Cached Message Stream.

Detailed Description

Definition at line 27 of file MuonFastRecoTester.h.

Member Typedef Documentation

◆ EffMap_t

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

Typedef for convenience.

Definition at line 199 of file AthHistogramming.h.

◆ GraphMap_t

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

Typedef for convenience.

Definition at line 213 of file AthHistogramming.h.

◆ hash_t

typedef uint32_t AthHistogramming::hash_t
privateinherited

typedef for the internal hash

Definition at line 171 of file AthHistogramming.h.

◆ HistMap_t

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

Typedef for convenience.

Definition at line 192 of file AthHistogramming.h.

◆ simHitSet

Definition at line 36 of file MuonFastRecoTester.h.

◆ StoreGateSvc_t

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

Definition at line 376 of file AthCommonDataStore.h.

◆ TreeMap_t

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

Typedef for convenience.

Definition at line 206 of file AthHistogramming.h.

◆ TruthParticleMap

Definition at line 37 of file MuonFastRecoTester.h.

Member Enumeration Documentation

◆ ePatBranchType

enum class MuonValR4::MuonFastRecoTester::ePatBranchType : std::uint8_t
strongprivate

Enum for different types of pattern hit content branches.

Enumerator
eReco 
eTruth 
ePileup 
eMismatched 
eAll 

Definition at line 85 of file MuonFastRecoTester.h.

85 : std::uint8_t {
86 eReco, // Counts of pattern hits
87 eTruth, // Counts of pattern hits matched to truth
88 ePileup, // Counts of pattern hits matched to pileup truth
89 eMismatched, // Counts of pattern hits matched to truth but not to the main truth particle of the pattern
90 eAll, // Counts of all hits in the buckets crossed by the pattern
91 };

◆ measType

enum class MuonValR4::MuonFastRecoTester::measType
strongprivate

Enum for measurement types.

Enumerator
Prec 
NonPrec 
Phi 
nTypes 

Definition at line 41 of file MuonFastRecoTester.h.

41{Prec, NonPrec, Phi, nTypes};
@ Phi
Definition RPCdef.h:8

Constructor & Destructor Documentation

◆ ~MuonFastRecoTester()

virtual MuonValR4::MuonFastRecoTester::~MuonFastRecoTester ( )
virtualdefault

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(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
std::string m_histNamePrefix
The prefix for the histogram THx name.
ServiceHandle< ITHistSvc > m_histSvc
Default constructor: AthHistogramAlgorithm();.
std::string m_prefix
Name of the ROOT output stream (file).
std::string m_histNamePostfix
The postfix for the histogram THx name.
std::string m_histTitlePostfix
The postfix for the histogram THx title.
std::string m_rootDir
Name of the ROOT directory.
std::string m_histTitlePrefix
The prefix for the histogram THx title.
AthHistogramming(const std::string &name)
Constructor with parameters:

◆ book() [1/8]

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

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

Definition at line 329 of file AthHistogramming.h.

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

◆ book() [2/8]

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

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

◆ book() [3/8]

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

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

Definition at line 297 of file AthHistogramming.h.

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

◆ book() [4/8]

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

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

Definition at line 397 of file AthHistogramming.h.

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

◆ book() [5/8]

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

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

Definition at line 350 of file AthHistogramming.h.

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

◆ book() [6/8]

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

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

Definition at line 340 of file AthHistogramming.h.

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

◆ book() [7/8]

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

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

Definition at line 318 of file AthHistogramming.h.

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

◆ book() [8/8]

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

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

Definition at line 308 of file AthHistogramming.h.

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

◆ bookGetPointer() [1/8]

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

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

Definition at line 275 of file AthHistogramming.h.

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

◆ bookGetPointer() [2/8]

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

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

Definition at line 374 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [3/8]

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

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

Definition at line 254 of file AthHistogramming.h.

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

◆ bookGetPointer() [4/8]

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

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

Definition at line 268 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [5/8]

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

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

Definition at line 139 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [6/8]

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

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

Definition at line 287 of file AthHistogramming.h.

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

◆ bookGetPointer() [7/8]

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

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

Definition at line 97 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [8/8]

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

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

Definition at line 266 of file AthHistogramming.h.

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

◆ buildBookingString()

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

Method to build individual booking string.

Definition at line 500 of file AthHistogramming.cxx.

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

◆ configAthHistogramming()

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

To be called to fill the internal configuration.

Definition at line 64 of file AthHistogramming.cxx.

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

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

◆ efficiency()

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

Simplify the retrieval of registered TEfficiency.

Definition at line 214 of file AthHistogramming.cxx.

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

◆ evtStore()

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

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

Definition at line 85 of file AthCommonDataStore.h.

◆ execute()

StatusCode MuonValR4::MuonFastRecoTester::execute ( const EventContext & ctx)
overridevirtual

Execute method.

Implements AthAlgorithm.

Definition at line 117 of file MuonFastRecoTester.cxx.

117 {
118
119 //const ActsTrk::GeometryContext* gctxPtr{nullptr};
120 //ATH_CHECK(SG::get(gctxPtr, m_geoCtxKey, ctx));
121
122 const SpacePointContainer* spContainer {nullptr};
123 ATH_CHECK(SG::get(spContainer, m_spKey, ctx));
124
125 const SpacePointContainer* NSWspContainer {nullptr};
126 ATH_CHECK(SG::get(NSWspContainer, m_NSWspKey, ctx));
127
128 const GlobalPatternContainer* globPatterns{nullptr};
129 ATH_CHECK(SG::get(globPatterns, m_patternKey, ctx));
130
131 const xAOD::MuonContainer* fastMuons{nullptr};
132 ATH_CHECK(SG::get(fastMuons, m_fastMuonKey, ctx));
133
134 const xAOD::MuonSegmentContainer* readTruthSegments{nullptr};
135 if(m_isMC){
136 ATH_CHECK(SG::get(readTruthSegments , m_truthSegmentKey, ctx));
137 }
138 const TrigRoiDescriptorCollection* roiCollection{nullptr};
139 if(m_isSeededReco) {
140 ATH_CHECK(SG::get(roiCollection, m_roiCollectionKey, ctx));
141 }
142
143 ATH_MSG_DEBUG("Succesfully retrieved input collections: Global Patterns: "<<globPatterns->size()
144 <<", truth segments: "<<(readTruthSegments? std::to_string(readTruthSegments->size()) : std::to_string(-1))
145 <<", Rois: "<<(roiCollection ? std::to_string(roiCollection->size()) : std::to_string(-1)));
146
147 const TruthParticleMap truthMap{fillTruthMap(readTruthSegments, roiCollection)};
148 fillTruthInfo(truthMap, {spContainer, NSWspContainer});
149 fillRoIInfo(roiCollection);
150
151 if (m_writeSpacePoints) {
152 fillSpacePointInfo(spContainer, globPatterns, truthMap,
154 fillSpacePointInfo(NSWspContainer, globPatterns, truthMap,
156 }
157 fillGlobPatternInfo(globPatterns, truthMap,
158 std::vector<const MuonR4::SpacePointContainer*>{spContainer, NSWspContainer});
159
160 fillFastRecoMuonInfo(fastMuons, globPatterns);
161
162 ATH_CHECK(m_tree.fill(ctx));
163 return StatusCode::SUCCESS;
164 }
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x,...)
Athena::TPCnvVers::Old Athena::TPCnvVers::Current TrigRoiDescriptorCollection
size_type size() const noexcept
Returns the number of elements in the collection.
void fillTruthInfo(const TruthParticleMap &truthHits, const std::vector< const MuonR4::SpacePointContainer * > &spContainers)
Fill the truth particle information into the tree.
MuonVal::VectorBranch< unsigned char > & m_spType
Type of spacepoints: 1 for trigger eta, 2 for precision, 3 for only-phi.
SG::ReadHandleKey< MuonR4::SpacePointContainer > m_NSWspKey
SG::ReadHandleKey< xAOD::MuonContainer > m_fastMuonKey
SG::ReadHandleKey< MuonR4::GlobalPatternContainer > m_patternKey
MuonVal::MatrixBranch< unsigned char > & m_spMatchedToPattern
Branch indicating which space points in the tree are associated to the i-th pattern.
MuonVal::MatrixBranch< unsigned char > & m_NSWspMatchedToTruth
void fillRoIInfo(const TrigRoiDescriptorCollection *roiCollection)
Fill the RoI information into the tree.
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
std::map< const xAOD::TruthParticle *, std::vector< simHitSet > > TruthParticleMap
SG::ReadHandleKey< xAOD::MuonSegmentContainer > m_truthSegmentKey
void fillFastRecoMuonInfo(const xAOD::MuonContainer *muonCont, const MuonR4::GlobalPatternContainer *patternCont)
Fill the info associated to fast reco muons.
std::shared_ptr< SpacePointTesterModule > m_NSWspTester
std::shared_ptr< SpacePointTesterModule > m_spTester
====== Spacepoint block ===========
void fillSpacePointInfo(const MuonR4::SpacePointContainer *spc, const MuonR4::GlobalPatternContainer *patternCont, const TruthParticleMap &truthHits, SpacePointTesterModule &spTester, MuonVal::VectorBranch< unsigned char > &spTypeBranch, MuonVal::MatrixBranch< unsigned char > &spMatchedToPatternBranch, MuonVal::MatrixBranch< unsigned char > &spMatchedToTruthBranch) const
Fill the space point information into the tree.
MuonVal::VectorBranch< unsigned char > & m_NSWspType
void fillGlobPatternInfo(const MuonR4::GlobalPatternContainer *patternCont, const TruthParticleMap &truthHits, const std::vector< const MuonR4::SpacePointContainer * > &spContainers)
Fill the info associated to the global patterns into the tree.
MuonVal::MatrixBranch< unsigned char > & m_NSWspMatchedToPattern
MuonVal::MuonTesterTree m_tree
MuonVal::MatrixBranch< unsigned char > & m_spMatchedToTruth
Branch indicating which space points in the tree are associated to the i-th truth particle.
SG::ReadHandleKey< MuonR4::SpacePointContainer > m_spKey
TruthParticleMap fillTruthMap(const xAOD::MuonSegmentContainer *truthSegments, const TrigRoiDescriptorCollection *roiCollection) const
Fill the truth particle map.
DataVector< GlobalPattern > GlobalPatternContainer
Abrivation of the GlobalPattern container type.
DataVector< SpacePointBucket > SpacePointContainer
Abrivation of the space point container type.
const T * get(const ReadCondHandleKey< T > &key, const EventContext &ctx)
Convenience function to retrieve an object given a ReadCondHandleKey.
MuonSegmentContainer_v1 MuonSegmentContainer
Definition of the current "MuonSegment container version".
MuonContainer_v1 MuonContainer
Definition of the current "Muon container version".

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthCommonAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
59 }
61}
Common base class for algorithms.

◆ fillFastRecoMuonInfo()

void MuonValR4::MuonFastRecoTester::fillFastRecoMuonInfo ( const xAOD::MuonContainer * muonCont,
const MuonR4::GlobalPatternContainer * patternCont )
private

Fill the info associated to fast reco muons.

Parameters
muonContPointer to the fast muon container
patternContPointer to the global pattern container, needed to match muons to patterns

Definition at line 456 of file MuonFastRecoTester.cxx.

457 {
458 if (!fastMuons) return;
459
460
461 for (const xAOD::Muon* mu : *fastMuons) {
462 m_muon_Eta.push_back(mu->eta());
463 m_muon_Phi.push_back(mu->phi());
464 m_muon_Pt.push_back(mu->pt());
465 m_muon_Q.push_back(mu->charge());
466
467 auto patItr {std::ranges::find(*patternCont, FastReco::getParentPattern(*mu))};
468 assert(patItr != patternCont->end());
469 const std::size_t patIdx = std::distance(patternCont->begin(), patItr);
470 m_muon_MatchedToPattern.push_back(patIdx);
471
472 ATH_MSG_VERBOSE("FastMuonSA eta: "<<mu->eta()<<", phi[Deg]: "<<inDegrees(mu->phi())
473 <<", pt[GeV]: "<<mu->pt()/Gaudi::Units::GeV<<", q: "<<mu->charge());
474 }
475 }
#define ATH_MSG_VERBOSE(x,...)
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
MuonVal::VectorBranch< unsigned char > & m_muon_MatchedToPattern
MuonVal::VectorBranch< float > & m_muon_Pt
MuonVal::VectorBranch< short > & m_muon_Q
MuonVal::VectorBranch< float > & m_muon_Phi
MuonVal::VectorBranch< float > & m_muon_Eta
====== Fast Reco Muon info ===========
const GlobalPattern * getParentPattern(const xAOD::MuonSegment &segment)
Retrieve the parent global pattern of the segment.
Muon_v1 Muon
Reference the current persistent version:
Definition Muon.h:13

◆ fillGlobPatternInfo()

void MuonValR4::MuonFastRecoTester::fillGlobPatternInfo ( const MuonR4::GlobalPatternContainer * patternCont,
const TruthParticleMap & truthHits,
const std::vector< const MuonR4::SpacePointContainer * > & spContainers )
private

Fill the info associated to the global patterns into the tree.

Parameters
patternContPointer to the global pattern container
truthHitsMap of truth particle hits, needed to match patterns to truth
spContainersVector of pointers to space point containers, needed to compute pattern hit counts

Definition at line 347 of file MuonFastRecoTester.cxx.

349 {
350 m_pat_n = patternCont->size();
351 // Resize all the matrix branches
352 resize_all(patternCont->size(), s_nStations,
356 if (m_isMC) {
357 resize_all(patternCont->size(), s_nStations,
360 }
361 auto isSecondaryMatched = [&truthHits](const SpacePoint* sp, std::size_t tpIdx) {
362 return sp->secondaryMeasurement() && isTruthMatched(*sp->secondaryMeasurement(), truthHits) == tpIdx;
363 };
364 std::size_t patternIdx{0};
365 for (const GlobalPattern* pattern : *patternCont) {
366 // We define a map of truth particles and associated hits for the current pattern, so we can determine the main truth particle is multiple are associated
367 std::unordered_map<std::size_t, std::vector<const SpacePoint*>> patternTruthHits{};
368
369 const std::vector<StIndex> stations {pattern->getStations()};
370 for (const StIndex station : stations) {
371 for (const SpacePoint* sp : pattern->hitsInStation(station)) {
372 updatePatHitInfo(ePatBranchType::eReco, patternIdx, station, sp);
373
374 if (!m_isMC) continue;
375 if (const auto tpIdx {isTruthMatched(*sp->primaryMeasurement(), truthHits)}; tpIdx.has_value()) {
376 // By convention, if truth particle index is equal to the size of the truth map, it means it's a pileup particle
377 if (*tpIdx >= truthHits.size() ) {
378 updatePatHitInfo(ePatBranchType::ePileup, patternIdx, station, sp, isSecondaryMatched(sp, *tpIdx));
379 } else {
380 patternTruthHits[*tpIdx].push_back(sp);
381 }
382 }
383 }
384 }
385 if (!patternTruthHits.empty()) {
386 // Sort the TPs by number of matched hits and define the main truth particle as the one with the most hits in the pattern
387 std::vector<std::size_t> sortedTPs {};
388 std::ranges::transform(patternTruthHits, std::back_inserter(sortedTPs), [](const auto& pair){ return pair.first; });
389 std::ranges::sort(sortedTPs, [&patternTruthHits](const auto& a, const auto& b){
390 return patternTruthHits.at(a).size() > patternTruthHits.at(b).size();
391 });
392 const auto mainTP = sortedTPs.front();
393 for (const SpacePoint* sp : patternTruthHits[mainTP]) {
394 const StIndex station {m_idHelperSvc->stationIndex(sp->identify())};
395 updatePatHitInfo(ePatBranchType::eTruth, patternIdx, station, sp, isSecondaryMatched(sp, mainTP));
396 }
397 // Add truth hits that are matched to other truth particles than the main one
398 for (const auto& [tpIdx, hits] : patternTruthHits) {
399 if (tpIdx == mainTP) continue;
400 for (const SpacePoint* sp : hits) {
401 const StIndex station {m_idHelperSvc->stationIndex(sp->identify())};
402 updatePatHitInfo(ePatBranchType::eMismatched, patternIdx, station, sp, isSecondaryMatched(sp, tpIdx));
403 }
404 }
405 // Save the matched truth particle index in the tree, either is a signal or pileup particle
406 std::ranges::transform(sortedTPs, std::back_inserter(m_pat_MatchedToTruth[patternIdx]), [](const std::size_t& tp){ return tp; });
407 }
408 // Loop over the space point containers to count the number of hits in the buckets crossed by the pattern
409 for (const SpacePointContainer* spContainer : spContainers) {
410 if (!spContainer) continue;
411 for (const SpacePointBucket* bucket : *spContainer) {
412 bool bucketInPattern{false};
413 const StIndex bucketStation {m_idHelperSvc->stationIndex(bucket->front()->identify())};
414 std::vector<const SpacePoint*> allHits{};
415
416 for (const auto& sp : *bucket) {
417 if (isInPattern(sp.get(), bucketStation, *pattern)) {
418 bucketInPattern = true;
419 }
420 allHits.push_back(sp.get());
421 }
422 if (bucketInPattern) {
423 for (const SpacePoint* sp : allHits) {
424 updatePatHitInfo(ePatBranchType::eAll, patternIdx, bucketStation, sp);
425 }
426 }
427 }
428 }
429 m_pat_Eta.push_back(-std::log(std::tan(pattern->theta()/2.)));
430 m_pat_phi.push_back(pattern->phi());
431 m_pat_sector1.push_back(pattern->sector());
432 m_pat_sector2.push_back(pattern->secondarySector());
433 m_pat_meanNormResidual2.push_back(pattern->meanNormResidual2());
434 m_pat_side.push_back(pattern->hitsInStation(stations.front()).front()->msSector()->side());
435 m_pat_nStations.push_back(stations.size());
436
437 if (msgLevel(MSG::VERBOSE)) {
438 const auto mainTP {m_pat_MatchedToTruth[patternIdx].size() > 0 ? static_cast<int>(m_pat_MatchedToTruth[patternIdx].front()) : -1};
439 unsigned nPrecHits{0}, nNonPrecHits{0}, nPhiHits{0};
440 unsigned gen_nPrecHits{0}, gen_nNonPrecHits{0}, gen_nPhiHits{0};
441 for (std::size_t stIdx = 0; stIdx < s_nStations; ++stIdx) {
442 nPrecHits += static_cast<unsigned>(m_pat_nTruthPrecMeas[patternIdx][stIdx]);
443 nNonPrecHits += static_cast<unsigned>(m_pat_nTruthNonPrecMeas[patternIdx][stIdx]);
444 nPhiHits += static_cast<unsigned>(m_pat_nTruthPhiMeas[patternIdx][stIdx]);
445 if (mainTP < 0) continue;
446 gen_nPrecHits += static_cast<unsigned>(m_gen_nPrecMeas[mainTP][stIdx]);
447 gen_nNonPrecHits += static_cast<unsigned>(m_gen_nNonPrecMeas[mainTP][stIdx]);
448 gen_nPhiHits += static_cast<unsigned>(m_gen_nPhiMeas[mainTP][stIdx]);
449 }
450 ATH_MSG_VERBOSE("Pat #" << patternIdx<< ": " << *pattern << "mainTP: "<<std::to_string(mainTP)
451 <<", nTruthMatchedHits Trig: "<<nNonPrecHits<<" / "<<gen_nNonPrecHits<<", Prec: "<<nPrecHits<<" / "<<gen_nPrecHits<<", Phi: "<<nPhiHits<<" / "<<gen_nPhiHits);
452 }
453 patternIdx++;
454 }
455 }
static Double_t sp
static Double_t a
MuonVal::MatrixBranch< unsigned char > & m_pat_nAllNonPrecMeas
Number of trigger eta measurements in the buckets crossed by the pattern, grouped by station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nNonPrecMeas
Number of trigger eta measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nAllPhiMeas
Number of phi measurements in the buckets crossed by the pattern, grouped by station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nTruthPrecMeas
Number of truth precision measurements per station.
MuonVal::ScalarBranch< unsigned > & m_pat_n
====== Global Pattern block ===========
MuonVal::MatrixBranch< unsigned char > & m_pat_nMisTruthPhiMeas
Number of mismatched truth phi measurements per station.
MuonVal::VectorBranch< unsigned char > & m_pat_nStations
Number of stations.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPileupPhiMeas
Number of pileup phi measurements per station.
MuonVal::VectorBranch< uint16_t > & m_pat_sector2
MuonVal::MatrixBranch< unsigned char > & m_pat_nAllPrecMeas
Number of precision measurements in the buckets crossed by the pattern, grouped by station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPileupPrecMeas
Number of pileup precision measurements per station.
MuonVal::VectorBranch< float > & m_pat_phi
MuonVal::MatrixBranch< unsigned char > & m_gen_nPrecMeas
Number of precision measurements per station.
ServiceHandle< Muon::IMuonIdHelperSvc > m_idHelperSvc
void updatePatHitInfo(const ePatBranchType type, const std::size_t patIdx, const Muon::MuonStationIndex::StIndex hitSt, const MuonR4::SpacePoint *sp, const bool isSecondaryMatched=false)
Update the hit counts for a given pattern branch type.
MuonVal::MatrixBranch< unsigned char > & m_pat_nTruthPhiMeas
Number of truth phi measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nTruthNonPrecMeas
Number of truth trigger eta measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPhiMeas
Number of phi measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPrecMeas
Number of precision measurements per station.
MuonVal::VectorBranch< float > & m_pat_meanNormResidual2
mean square normalized pattern residual
MuonVal::MatrixBranch< unsigned char > & m_pat_nMisTruthNonPrecMeas
Number of mismatched truth trigger eta measurements per station.
MuonVal::VectorBranch< uint16_t > & m_pat_sector1
pattern primary & secondary sectors (different if the pattern is in the sector overlap)
MuonVal::MatrixBranch< unsigned char > & m_pat_nMisTruthPrecMeas
Number of mismatched truth precision measurements per station.
MuonVal::VectorBranch< short > & m_pat_side
+1 for A-, -1 of C-side
MuonVal::MatrixBranch< unsigned char > & m_pat_MatchedToTruth
Branch indicating which truth particles in the tree are associated to the i-th pattern.
MuonVal::MatrixBranch< unsigned char > & m_gen_nPhiMeas
Number of phi measurements per station.
MuonVal::MatrixBranch< unsigned char > & m_pat_nPileupNonPrecMeas
Number of pileup trigger eta measurements per station.
MuonVal::VectorBranch< float > & m_pat_Eta
pattern average theta & phi
MuonVal::MatrixBranch< unsigned char > & m_gen_nNonPrecMeas
Number of trigger eta measurements per station.
bool isInPattern(const SpacePoint *sp, const StIndex station, const GlobalPattern &pattern)
constexpr std::size_t s_nStations
std::optional< std::size_t > isTruthMatched(const xAOD::MuonMeasurement &meas, const TruthParticleMap &truthHits)
StIndex
enum to classify the different station layers in the muon spectrometer

◆ fillRoIInfo()

void MuonValR4::MuonFastRecoTester::fillRoIInfo ( const TrigRoiDescriptorCollection * roiCollection)
private

Fill the RoI information into the tree.

Parameters
roiCollectionPointer to the RoI collection

Definition at line 306 of file MuonFastRecoTester.cxx.

306 {
307 if (!m_isSeededReco || !roiCollection || roiCollection->empty()) return;
308 for (const TrigRoiDescriptor* roi : *roiCollection) {
309 m_roi_EtaMin.push_back(roi->etaMinus());
310 m_roi_EtaMax.push_back(roi->etaPlus());
311 m_roi_PhiMin.push_back(roi->phiMinus());
312 m_roi_PhiMax.push_back(roi->phiPlus());
313 m_roi_ZMin.push_back(roi->zedMinus());
314 m_roi_ZMax.push_back(roi->zedPlus());
315 }
316 }
bool empty() const noexcept
Returns true if the collection is empty.
MuonVal::VectorBranch< float > & m_roi_ZMax
MuonVal::VectorBranch< float > & m_roi_EtaMin
====== RoI info ===========
MuonVal::VectorBranch< float > & m_roi_PhiMin
MuonVal::VectorBranch< float > & m_roi_PhiMax
MuonVal::VectorBranch< float > & m_roi_EtaMax
MuonVal::VectorBranch< float > & m_roi_ZMin

◆ fillSpacePointInfo()

void MuonValR4::MuonFastRecoTester::fillSpacePointInfo ( const MuonR4::SpacePointContainer * spc,
const MuonR4::GlobalPatternContainer * patternCont,
const TruthParticleMap & truthHits,
SpacePointTesterModule & spTester,
MuonVal::VectorBranch< unsigned char > & spTypeBranch,
MuonVal::MatrixBranch< unsigned char > & spMatchedToPatternBranch,
MuonVal::MatrixBranch< unsigned char > & spMatchedToTruthBranch ) const
private

Fill the space point information into the tree.

Parameters
spcPointer to the space point container
patternContPointer to the global pattern container, needed to match spacepoints to patterns
truthHitsMap of truth particle hits
spTesterSpace point branches
spTypeBranchBranch for space point types
spMatchedToPatternBranchBranch for space point matches to patterns
spMatchedToTruthBranchBranch for space point matches to truth

Definition at line 317 of file MuonFastRecoTester.cxx.

323 {
324 if (!spc) return;
325 for (const SpacePointBucket* bucket : *spc) {
326 for (const auto& sp : *bucket) {
328 spTypeBranch.push_back(Acts::toUnderlying(type));
329 if(!m_isMC) continue;
330 if (const auto tpIdx {isTruthMatched(*sp->primaryMeasurement(), truthHits)}; tpIdx.has_value()) {
331 unsigned treeIdx = spTester.push_back(*sp);
332 spMatchedToTruthBranch[tpIdx.value()].push_back(treeIdx);
333 }
334 }
335 }
336 std::size_t patternIdx{0};
337 for (const GlobalPattern* pattern : *patternCont) {
338 for (const StIndex station : pattern->getStations()) {
339 for (const SpacePoint* sp : pattern->hitsInStation(station)) {
340 unsigned treeIdx = spTester.push_back(*sp);
341 spMatchedToPatternBranch[patternIdx].push_back(treeIdx);
342 }
343 }
344 ++patternIdx;
345 }
346 }
measType
Enum for measurement types.
void push_back(size_t i, const T &value)
void push_back(const T &value)
Adds a new element at the end of the vector.
bool isPrecisionHit(const SpacePoint &hit)
Returns whether the uncalibrated spacepoint is a precision hit (Mdt, micromegas, stgc strips).

◆ fillTruthInfo()

void MuonValR4::MuonFastRecoTester::fillTruthInfo ( const TruthParticleMap & truthHits,
const std::vector< const MuonR4::SpacePointContainer * > & spContainers )
private

Fill the truth particle information into the tree.

Parameters
truthHitsMap of truth particle hits
spContainersVector of pointers to space point containers, needed for truth hit counts

Track which layers already have a spacepoint to avoid double counting. This is done per station.

Select the measurement type

Select the truth particle

Filling truth hit counts. We cannot use directly the segments because we have sim hits that haven't made it into spacepoints due to inefficiencies

Select the buckets in this station

Geometric (sanity) check: sector & side

Definition at line 192 of file MuonFastRecoTester.cxx.

193 {
194 if (!m_isMC || truthHits.empty()) return;
195 resize_all(truthHits.size(), s_nStations,
197 using enum measType;
198 using LayerBookeeper = std::unordered_map<const MuonGMR4::SpectrometerSector*, std::set<unsigned>>;
199 using MeasBookeeper = std::array<std::vector<const SpacePoint*>, Acts::toUnderlying(nTypes)>;
201 MeasBookeeper measInStation{};
202 LayerBookeeper seenEtaLayers{};
203 LayerBookeeper seenPhiLayers{};
204
205 auto processMeas = [&truthHits, &measInStation, &seenEtaLayers, &seenPhiLayers, this]
206 (const SpacePoint* sp, const measType type, const bool process2Dmeas, const int tpIdx, const std::size_t stIdx) {
208 const bool isPrec {MuonR4::isPrecisionHit(*sp)};
209 if ((type == Prec && !isPrec) ||
210 (type == NonPrec && (isPrec || !sp->measuresEta())) || (type == Phi && sp->measuresEta())) {
211 return;
212 }
213 /* Check if the hit has already been counted, i.e. duplicated hits. Needed for precision hits, since we can have multiple on the same layer */
214 std::vector<const SpacePoint*>& outCont {measInStation[Acts::toUnderlying(type)]};
215 if (std::ranges::find_if(outCont, [sp](const SpacePoint* s) {
216 return s->primaryMeasurement() == sp->primaryMeasurement(); }) != outCont.end()) {
217 return;
218 }
220 if (isTruthMatched(*sp->primaryMeasurement(), truthHits) != tpIdx) return;
221
222 const bool isDoubleMatched {sp->dimension() == 2u && sp->secondaryMeasurement() && isTruthMatched(*sp->secondaryMeasurement(), truthHits) == tpIdx};
223 if (process2Dmeas && !isDoubleMatched) return;
224
225 /* Check if we have already measurements in the same layer, except for precision hits */
226 const unsigned layNum {m_spSorter.sectorLayerNum(*sp)};
227
228 if (sp->measuresEta()) {
229 const bool isSeenLayer {seenEtaLayers[sp->msSector()].count(layNum) > 0};
230 if (isSeenLayer && !sp->isStraw()) return;
231 if (!isSeenLayer) seenEtaLayers[sp->msSector()].insert(layNum);
232 auto& measCounter = isPrec ? m_gen_nPrecMeas : m_gen_nNonPrecMeas;
233 ++measCounter[tpIdx][stIdx];
234
235 // Eta hit can also have phi measurements. For combined spacepoints, need to be check the secondaty measurements. No need for 2D spacepoints.
236 if (sp->measuresPhi() && isDoubleMatched) {
237 seenPhiLayers[sp->msSector()].insert(layNum);
238 ++m_gen_nPhiMeas[tpIdx][stIdx];
239 measInStation[Acts::toUnderlying(Phi)].push_back(sp);
240 }
241 } else {
242 if (seenPhiLayers[sp->msSector()].count(layNum) > 0) return;
243 seenPhiLayers[sp->msSector()].insert(layNum);
244 ++m_gen_nPhiMeas[tpIdx][stIdx];
245 }
246 outCont.push_back(sp);
247 ATH_MSG_VERBOSE("---> "<<(isPrec ? "Prec" : (type == NonPrec ? "Trig" : "Phi "))<< " " << *sp << " in sector "<<sp->msSector()->identString() << " lay "<<layNum);
248 };
249
250 int tpIdx{-1};
251 for (const auto& [tp, _] : truthHits) {
252 if(!tp) continue;
253 m_gen_Eta.push_back(tp->eta());
254 m_gen_Phi.push_back(tp->phi());
255 m_gen_Pt.push_back(tp->pt());
256 m_gen_Q.push_back(tp->charge());
257 ++tpIdx;
258 // Save the sectors compatible for the tp
259 std::vector<int> sectors{};
260 sectorMap.getSectors(tp->phi(), sectors);
261 const int side {tp->eta() > 0 ? 1 : -1};
264 ATH_MSG_VERBOSE("tp: " << tpIdx << ", Eta: " << tp->eta() << ", Phi: " << inDegrees(tp->phi()) << ", Pt [GeV]: " << tp->pt() * 1e-3 << ", Q: " << tp->charge());
265 for (std::size_t stIdx = 0; stIdx < s_nStations; ++stIdx) {
266 ATH_MSG_VERBOSE("\tStation "<< stName(static_cast<StIndex>(stIdx)) << ": matched hits before layer deduplication: ");
267 // Clear the bookkeeping structures for the new station
268 for (auto& vec : measInStation) vec.clear();
269 seenEtaLayers.clear();
270 seenPhiLayers.clear();
271 // We fill per measurement type, so we give priority to precision hits if they are in the same layer as trigger hits, e.g. sTGCs
272 for (const measType type : {Prec, NonPrec, Phi}) {
273 // We fill first 2D measurements and then 1D ones
274 for (const bool process2Dmeas : {true, false}) {
275 for (const auto& spContainer : spContainers) {
276 if (!spContainer) continue;
277 for (const SpacePointBucket* bucket : *spContainer) {
279 if (static_cast<std::size_t>(m_idHelperSvc->stationIndex(bucket->front()->identify())) != stIdx) continue;
281 if (bucket->msSector()->side() != side ||
282 std::ranges::none_of(sectors, [&](int s){ return bucket->msSector()->sector() == s; })) {
283 continue;
284 }
285 for (const auto& sp : *bucket) {
286 /* Process first the precision hits, 2D measurements first and then 1D */
287 processMeas(sp.get(), type, process2Dmeas, tpIdx, stIdx);
288 }
289 } // End loop over buckets
290 } // End loop over containers
291 } // End loop over "process2Dmeas" flag
292 } // End loop over measurement types
293 if (msgLevel(MSG::VERBOSE)) {
294 const auto gen_nNonPrecHits {static_cast<unsigned>(m_gen_nNonPrecMeas[tpIdx][stIdx])};
295 const auto gen_nPrecHits {static_cast<unsigned>(m_gen_nPrecMeas[tpIdx][stIdx])};
296 const auto gen_nPhiHits {static_cast<unsigned>(m_gen_nPhiMeas[tpIdx][stIdx])};
297 if (gen_nNonPrecHits + gen_nPrecHits + gen_nPhiHits > 0) {
298 ATH_MSG_VERBOSE("\t after deduplication: N trig/Prec/phi meas: "
299 << gen_nNonPrecHits << "/" << gen_nPrecHits << "/" << gen_nPhiHits);
300 }
301 }
302
303 } // End loop over stations
304 } // End loop over truth particles
305 }
std::vector< size_t > vec
MuonVal::VectorBranch< float > & m_gen_Phi
MuonVal::VectorBranch< float > & m_gen_Eta
MuonVal::VectorBranch< short > & m_gen_Q
====== Truth particle block ===========
MuonVal::VectorBranch< float > & m_gen_Pt
MuonR4::SpacePointPerLayerSorter m_spSorter
const std::string & stName(StIndex index)
convert StIndex into a string

◆ fillTruthMap()

TruthParticleMap MuonValR4::MuonFastRecoTester::fillTruthMap ( const xAOD::MuonSegmentContainer * truthSegments,
const TrigRoiDescriptorCollection * roiCollection ) const
private

Fill the truth particle map.

Parameters
truthSegmentsPointer to the truth segments
roiCollectionPointer to the RoI collection, needed to match truth particles to RoIs in seeded reco
Returns
Map of truth particle hits

In seeded reco, we want to include only truth particles that are in the RoIs

Check eta

Check phi

Definition at line 165 of file MuonFastRecoTester.cxx.

166 {
167 if (!truthSegments) return TruthParticleMap{};
168 ATH_MSG_VERBOSE("Filling truth map with "<<truthSegments->size());
170 auto isInROI = [roiCollection](const xAOD::TruthParticle* tp) {
171 for (const TrigRoiDescriptor* roi : *roiCollection) {
173 if (tp->eta() < roi->etaMinus() || tp->eta() > roi->etaPlus()) continue;
175 const double dPhiPlus = CxxUtils::deltaPhi(roi->phiPlus(), tp->phi());
176 const double dPhiMinus = CxxUtils::deltaPhi(roi->phiMinus(), tp->phi());
177 if (dPhiPlus >= 0. && dPhiMinus <= 0.) return true;
178 }
179 return false;
180 };
181
182 TruthParticleMap truthMap{};
183 for (const xAOD::MuonSegment* truth : *truthSegments) {
185 // In case of seeded reco, we only save truth particles that are in the RoIs
186 if (!m_isSeededReco || !tp || isInROI(tp)){
187 truthMap[tp].push_back(getMatchingSimHits(*truth));
188 }
189 }
190 return truthMap;
191 }
constexpr T deltaPhi(T phiA, T phiB)
Return difference phiA - phiB in range [-pi, pi].
Definition phihelper.h:64
const xAOD::TruthParticle * getTruthMatchedParticle(const xAOD::MuonSegment &segment)
Returns the particle truth-matched to the segment.
std::vector< const xAOD::MuonSimHit * > getMatchingSimHits(const xAOD::MuonSegment &segment)
: Returns all sim hits matched to a xAOD::MuonSegment
TruthParticle_v1 TruthParticle
Typedef to implementation.
MuonSegment_v1 MuonSegment
Reference the current persistent version:

◆ filterPassed()

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

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

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

◆ finalize()

StatusCode MuonValR4::MuonFastRecoTester::finalize ( )
overridevirtual

Definition at line 113 of file MuonFastRecoTester.cxx.

113 {
114 ATH_CHECK(m_tree.write());
115 return StatusCode::SUCCESS;
116 }

◆ graph()

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

Simplify the retrieval of registered TGraphs.

Definition at line 438 of file AthHistogramming.cxx.

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

◆ hash()

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

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

Definition at line 422 of file AthHistogramming.h.

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

◆ hist()

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

Simplify the retrieval of registered histograms of any type.

Definition at line 182 of file AthHistogramming.cxx.

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

◆ hist2d()

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

Simplify the retrieval of registered 2-d histograms.

Definition at line 363 of file AthHistogramming.h.

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

◆ hist3d()

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

Simplify the retrieval of registered 3-d histograms.

Definition at line 380 of file AthHistogramming.h.

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

◆ histSvc()

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

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

Definition at line 113 of file AthHistogramAlgorithm.h.

114{
115 return m_histSvc;
116}

◆ initialize()

StatusCode MuonValR4::MuonFastRecoTester::initialize ( )
overridevirtual

Definition at line 58 of file MuonFastRecoTester.cxx.

58 {
59 ATH_CHECK(m_geoCtxKey.initialize());
60 {
61 int infoOpts = 0;
62 if (m_isMC) infoOpts = EventInfoBranch::isMC;
63 m_tree.addBranch(std::make_unique<EventInfoBranch>(m_tree, infoOpts));
64 }
65 ATH_CHECK(m_spKey.initialize(!m_spKey.empty()));
66 ATH_CHECK(m_NSWspKey.initialize(!m_NSWspKey.empty()));
69 if (!m_spKey.empty()) {
70 m_spTester = std::make_shared<SpacePointTesterModule>(m_tree, m_spKey.key(), msgLevel(), "Muon");
71 m_tree.addBranch(m_spTester);
72 if (!m_isMC) m_tree.disableBranch(m_spMatchedToTruth.name());
73 }
74 if (!m_NSWspKey.empty()) {
75 m_NSWspTester = std::make_shared<SpacePointTesterModule>(m_tree, m_NSWspKey.key(), msgLevel(), "Nsw");
76 m_tree.addBranch(m_NSWspTester);
77 if (!m_isMC) m_tree.disableBranch(m_NSWspMatchedToTruth.name());
78 }
79 } else {
80 m_tree.disableBranch(m_spType.name());
81 m_tree.disableBranch(m_NSWspType.name());
82 m_tree.disableBranch(m_spMatchedToPattern.name());
83 m_tree.disableBranch(m_NSWspMatchedToPattern.name());
84 m_tree.disableBranch(m_spMatchedToTruth.name());
85 m_tree.disableBranch(m_NSWspMatchedToTruth.name());
86 }
87 if (!m_isMC) {
88 m_tree.disableBranch(m_gen_Eta.name());
89 m_tree.disableBranch(m_gen_Phi.name());
90 m_tree.disableBranch(m_gen_Pt.name());
91 m_tree.disableBranch(m_gen_Q.name());
92 m_tree.disableBranch(m_pat_nTruthNonPrecMeas.name());
93 m_tree.disableBranch(m_pat_nTruthPrecMeas.name());
94 m_tree.disableBranch(m_pat_nTruthPhiMeas.name());
95 m_tree.disableBranch(m_pat_MatchedToTruth.name());
96 }
97 if (!m_isSeededReco) {
98 m_tree.disableBranch(m_roi_EtaMin.name());
99 m_tree.disableBranch(m_roi_EtaMax.name());
100 m_tree.disableBranch(m_roi_PhiMin.name());
101 m_tree.disableBranch(m_roi_PhiMax.name());
102 m_tree.disableBranch(m_roi_ZMin.name());
103 m_tree.disableBranch(m_roi_ZMax.name());
104 }
105 ATH_CHECK(m_patternKey.initialize());
106 ATH_CHECK(m_fastMuonKey.initialize());
107 ATH_CHECK(m_truthSegmentKey.initialize(!m_truthSegmentKey.empty()));
108 ATH_CHECK(m_tree.init(this));
109 ATH_CHECK(m_idHelperSvc.retrieve());
110 return StatusCode::SUCCESS;
111 }
ActsTrk::GeoContextReadKey_t m_geoCtxKey
@ isMC
Flag determining whether the branch is simulation.

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

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

Specify if the algorithm is clonable.

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

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

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isReEntrant()

virtual bool AthAlgorithm::isReEntrant ( ) const
inlinefinaloverrideprotectedvirtualinherited

Legacy algorithms are not thread-safe.

Definition at line 47 of file AthAlgorithm.h.

47{ return false; }

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 368 of file AthCommonDataStore.h.

369 {
370 h.renounce();
372 }
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)

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
354 }

◆ setFilterPassed()

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

Set filter decision:

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
101 }
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:

◆ sysExecute()

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

Execute an algorithm.

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

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

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

◆ sysInitialize()

StatusCode AthHistogramAlgorithm::sysInitialize ( )
virtualinherited

Initialization method invoked by the framework.

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

Reimplemented from AthCommonAlgorithm< Gaudi::Algorithm >.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 75 of file AthHistogramAlgorithm.cxx.

76{
77 // ---- stolen from GaudiKernel/Algorithm::sysInitialize -------
78 // Bypass the initialization if the algorithm
79 // has already been initialized.
80 if ( Gaudi::StateMachine::INITIALIZED <= FSMState() ) return StatusCode::SUCCESS;
81
82 // Set the Algorithm's properties
83 bindPropertiesTo( serviceLocator()->getOptsSvc() );
84
85 // Bypass the initialization if the algorithm is disabled.
86 // Need to do this after bindPropertiesTo.
87 if ( !isEnabled( ) ) return StatusCode::SUCCESS;
88
89 // ---- stolen from GaudiKernel/Algorithm::sysInitialize ------- END ---
90
91
92 // Get the THistSvc
93 ATH_CHECK ( histSvc().retrieve() );
94
95 // Configure the underlying AthHistogramming helper
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...
114}
virtual StatusCode sysInitialize() override
const ServiceHandle< ITHistSvc > & histSvc() const
The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a...
StatusCode configAthHistogramming(const ServiceHandle< ITHistSvc > &histSvc, const std::string &prefix, const std::string &rootDir, const std::string &histNamePrefix, const std::string &histNamePostfix, const std::string &histTitlePrefix, const std::string &histTitlePostfix)
To be called to fill the internal configuration.

◆ sysStart()

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

Handle START transition.

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

◆ tree()

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

Simplify the retrieval of registered TTrees.

Definition at line 333 of file AthHistogramming.cxx.

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

◆ updatePatHitInfo()

void MuonValR4::MuonFastRecoTester::updatePatHitInfo ( const ePatBranchType type,
const std::size_t patIdx,
const Muon::MuonStationIndex::StIndex hitSt,
const MuonR4::SpacePoint * sp,
const bool isSecondaryMatched = false )
private

Update the hit counts for a given pattern branch type.

Parameters
typeThe pattern branch type
patIdxIndex of the pattern
hitStStation index of the hit
spPointer to the space point
isSecondaryMatchedif the spacepoint has a secondary measurement and it is matched to truth

Definition at line 476 of file MuonFastRecoTester.cxx.

480 {
481 using enum ePatBranchType;
482 const bool isTruthInfo = (type == ePatBranchType::eTruth || type == ePatBranchType::eMismatched);
483 const auto updateCounts = [&](unsigned char& nonPrecCount,
484 unsigned char& precCount,
485 unsigned char& phiCount) {
486 if (sp->measuresEta()) {
487 if (MuonR4::isPrecisionHit(*sp)) precCount++;
488 else nonPrecCount++;
489 if (type == ePatBranchType::eTruth) {
490 ATH_MSG_VERBOSE("---> "<<(MuonR4::isPrecisionHit(*sp) ? "Prec" : "Trig")<< " " << *sp << " in sector "<<sp->msSector()->identString() << " lay "<<m_spSorter.sectorLayerNum(*sp));
491 }
492 }
493 if (sp->measuresPhi() && (!isTruthInfo || isSecondaryMatched)) {
494 ++phiCount;
495 if (type == ePatBranchType::eTruth) {
496 ATH_MSG_VERBOSE("---> "<<"Phi " << *sp << " in sector "<<sp->msSector()->identString() << " lay "<<m_spSorter.sectorLayerNum(*sp));
497 }
498 }
499 };
500 const auto stIdx = Acts::toUnderlying(hitSt);
501 switch (type) {
502 case eReco:
503 updateCounts(m_pat_nNonPrecMeas[patIdx][stIdx],
504 m_pat_nPrecMeas[patIdx][stIdx], m_pat_nPhiMeas[patIdx][stIdx]);
505 return;
506 case eTruth:
507 updateCounts(m_pat_nTruthNonPrecMeas[patIdx][stIdx],
508 m_pat_nTruthPrecMeas[patIdx][stIdx], m_pat_nTruthPhiMeas[patIdx][stIdx]);
509 return;
510 case eMismatched:
511 updateCounts(m_pat_nMisTruthNonPrecMeas[patIdx][stIdx],
512 m_pat_nMisTruthPrecMeas[patIdx][stIdx], m_pat_nMisTruthPhiMeas[patIdx][stIdx]);
513 return;
514 case eAll:
515 updateCounts(m_pat_nAllNonPrecMeas[patIdx][stIdx],
516 m_pat_nAllPrecMeas[patIdx][stIdx], m_pat_nAllPhiMeas[patIdx][stIdx]);
517 return;
518 case ePileup:
519 updateCounts(m_pat_nPileupNonPrecMeas[patIdx][stIdx],
520 m_pat_nPileupPrecMeas[patIdx][stIdx], m_pat_nPileupPhiMeas[patIdx][stIdx]);
521 return;
522 }
523 }
ePatBranchType
Enum for different types of pattern hit content branches.

◆ updateVHKA()

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

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }

Member Data Documentation

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

Definition at line 381 of file AthCommonDataStore.h.

◆ m_effMap

EffMap_t AthHistogramming::m_effMap
privateinherited

The map of histogram names to their pointers.

Definition at line 202 of file AthHistogramming.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 378 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

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

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_fastMuonKey

SG::ReadHandleKey<xAOD::MuonContainer> MuonValR4::MuonFastRecoTester::m_fastMuonKey {this, "FastMuonKey", "FastRecoSAMuons", "fast reco muon container"}
private

Definition at line 115 of file MuonFastRecoTester.h.

115{this, "FastMuonKey", "FastRecoSAMuons", "fast reco muon container"};

◆ m_gen_Eta

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_gen_Eta {m_tree.newVector<float>("gen_Eta",-10.)}
private

Definition at line 150 of file MuonFastRecoTester.h.

150{m_tree.newVector<float>("gen_Eta",-10.)};

◆ m_gen_nNonPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_gen_nNonPrecMeas {m_tree.newMatrix<unsigned char>("gen_NNonPrecMeas", 0)}
private

Number of trigger eta measurements per station.

Definition at line 155 of file MuonFastRecoTester.h.

155{m_tree.newMatrix<unsigned char>("gen_NNonPrecMeas", 0)};

◆ m_gen_nPhiMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_gen_nPhiMeas {m_tree.newMatrix<unsigned char>("gen_NPhiMeas", 0)}
private

Number of phi measurements per station.

Definition at line 159 of file MuonFastRecoTester.h.

159{m_tree.newMatrix<unsigned char>("gen_NPhiMeas", 0)};

◆ m_gen_nPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_gen_nPrecMeas {m_tree.newMatrix<unsigned char>("gen_NPrecMeas", 0)}
private

Number of precision measurements per station.

Definition at line 157 of file MuonFastRecoTester.h.

157{m_tree.newMatrix<unsigned char>("gen_NPrecMeas", 0)};

◆ m_gen_Phi

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_gen_Phi {m_tree.newVector<float>("gen_Phi",-10.)}
private

Definition at line 151 of file MuonFastRecoTester.h.

151{m_tree.newVector<float>("gen_Phi",-10.)};

◆ m_gen_Pt

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_gen_Pt {m_tree.newVector<float>("gen_Pt",-10.)}
private

Definition at line 152 of file MuonFastRecoTester.h.

152{m_tree.newVector<float>("gen_Pt",-10.)};

◆ m_gen_Q

MuonVal::VectorBranch<short>& MuonValR4::MuonFastRecoTester::m_gen_Q {m_tree.newVector<short>("gen_Q", 0)}
private

====== Truth particle block ===========

properties of truth particles

Definition at line 149 of file MuonFastRecoTester.h.

149{m_tree.newVector<short>("gen_Q", 0)};

◆ m_geoCtxKey

ActsTrk::GeoContextReadKey_t MuonValR4::MuonFastRecoTester::m_geoCtxKey {this, "AlignmentKey", "ActsAlignment", "cond handle key"}
private

Definition at line 123 of file MuonFastRecoTester.h.

123{this, "AlignmentKey", "ActsAlignment", "cond handle key"};

◆ m_graphMap

GraphMap_t AthHistogramming::m_graphMap
privateinherited

The map of TGraph names to their pointers.

Definition at line 216 of file AthHistogramming.h.

◆ m_histMap

HistMap_t AthHistogramming::m_histMap
privateinherited

The map of histogram names to their pointers.

Definition at line 195 of file AthHistogramming.h.

◆ m_histNamePostfix

std::string AthHistogramAlgorithm::m_histNamePostfix
privateinherited

The postfix for the histogram THx name.

Definition at line 97 of file AthHistogramAlgorithm.h.

◆ m_histNamePrefix

std::string AthHistogramAlgorithm::m_histNamePrefix
privateinherited

The prefix for the histogram THx name.

Definition at line 94 of file AthHistogramAlgorithm.h.

◆ m_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_idHelperSvc

ServiceHandle<Muon::IMuonIdHelperSvc> MuonValR4::MuonFastRecoTester::m_idHelperSvc {this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"}
private

Definition at line 124 of file MuonFastRecoTester.h.

124{this, "MuonIdHelperSvc", "Muon::MuonIdHelperSvc/MuonIdHelperSvc"};

◆ m_isMC

BooleanProperty MuonValR4::MuonFastRecoTester::m_isMC {this, "isMC", false, "Toggle whether the job is ran on MC or not"}
private

Definition at line 126 of file MuonFastRecoTester.h.

126{this, "isMC", false, "Toggle whether the job is ran on MC or not"};

◆ m_isSeededReco

BooleanProperty MuonValR4::MuonFastRecoTester::m_isSeededReco {this, "isSeededReco", false, "Toggle whether the job is ran on seeded reconstruction or not"}
private

Definition at line 128 of file MuonFastRecoTester.h.

128{this, "isSeededReco", false, "Toggle whether the job is ran on seeded reconstruction or not"};

◆ m_msg

MsgStream AthHistogramming::m_msg
privateinherited

Cached Message Stream.

Definition at line 242 of file AthHistogramming.h.

◆ m_muon_Eta

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_muon_Eta {m_tree.newVector<float>("muon_Eta", -10.)}
private

====== Fast Reco Muon info ===========

Definition at line 226 of file MuonFastRecoTester.h.

226{m_tree.newVector<float>("muon_Eta", -10.)};

◆ m_muon_MatchedToPattern

MuonVal::VectorBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_muon_MatchedToPattern {m_tree.newVector<unsigned char>("muon_patMatched")}
private

Definition at line 230 of file MuonFastRecoTester.h.

230{m_tree.newVector<unsigned char>("muon_patMatched")};

◆ m_muon_Phi

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_muon_Phi {m_tree.newVector<float>("muon_Phi", -10.)}
private

Definition at line 227 of file MuonFastRecoTester.h.

227{m_tree.newVector<float>("muon_Phi", -10.)};

◆ m_muon_Pt

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_muon_Pt {m_tree.newVector<float>("muon_Pt", -10.)}
private

Definition at line 228 of file MuonFastRecoTester.h.

228{m_tree.newVector<float>("muon_Pt", -10.)};

◆ m_muon_Q

MuonVal::VectorBranch<short>& MuonValR4::MuonFastRecoTester::m_muon_Q {m_tree.newVector<short>("muon_Q", 0)}
private

Definition at line 229 of file MuonFastRecoTester.h.

229{m_tree.newVector<short>("muon_Q", 0)};

◆ m_name

std::string AthHistogramming::m_name
privateinherited

Instance name.

Definition at line 239 of file AthHistogramming.h.

◆ m_NSWspKey

SG::ReadHandleKey<MuonR4::SpacePointContainer> MuonValR4::MuonFastRecoTester::m_NSWspKey {this, "NswSpacePointKey", "NswSpacePoints"}
private

Definition at line 109 of file MuonFastRecoTester.h.

109{this, "NswSpacePointKey", "NswSpacePoints"};

◆ m_NSWspMatchedToPattern

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_NSWspMatchedToPattern {m_tree.newMatrix<unsigned char>(m_NSWspKey.key()+"_patternMatched")}
private

Definition at line 142 of file MuonFastRecoTester.h.

142{m_tree.newMatrix<unsigned char>(m_NSWspKey.key()+"_patternMatched")};

◆ m_NSWspMatchedToTruth

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_NSWspMatchedToTruth {m_tree.newMatrix<unsigned char>(m_NSWspKey.key()+"_truthMatched")}
private

Definition at line 145 of file MuonFastRecoTester.h.

145{m_tree.newMatrix<unsigned char>(m_NSWspKey.key()+"_truthMatched")};

◆ m_NSWspTester

std::shared_ptr<SpacePointTesterModule> MuonValR4::MuonFastRecoTester::m_NSWspTester {}
private

Definition at line 136 of file MuonFastRecoTester.h.

136{};

◆ m_NSWspType

MuonVal::VectorBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_NSWspType {m_tree.newVector<unsigned char>(m_NSWspKey.key()+"_type")}
private

Definition at line 139 of file MuonFastRecoTester.h.

139{m_tree.newVector<unsigned char>(m_NSWspKey.key()+"_type")};

◆ m_pat_Eta

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_pat_Eta {m_tree.newVector<float>("pat_Eta", 0.0)}
private

pattern average theta & phi

Definition at line 166 of file MuonFastRecoTester.h.

166{m_tree.newVector<float>("pat_Eta", 0.0)};

◆ m_pat_MatchedToTruth

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_MatchedToTruth {m_tree.newMatrix<unsigned char>("pat_truthMatched")}
private

Branch indicating which truth particles in the tree are associated to the i-th pattern.

We can have in principle multiple truth particles associated to the same pattern.

Definition at line 215 of file MuonFastRecoTester.h.

215{m_tree.newMatrix<unsigned char>("pat_truthMatched")};

◆ m_pat_meanNormResidual2

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_pat_meanNormResidual2 {m_tree.newVector<float>("pat_meanNormResidual2", 0.0)}
private

mean square normalized pattern residual

Definition at line 172 of file MuonFastRecoTester.h.

172{m_tree.newVector<float>("pat_meanNormResidual2", 0.0)};

◆ m_pat_n

MuonVal::ScalarBranch<unsigned>& MuonValR4::MuonFastRecoTester::m_pat_n {m_tree.newScalar<unsigned>("pat_nPatterns", 0)}
private

====== Global Pattern block ===========

pattern count

Definition at line 164 of file MuonFastRecoTester.h.

164{m_tree.newScalar<unsigned>("pat_nPatterns", 0)};

◆ m_pat_nAllNonPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nAllNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NAllNonPrecMeas", 0)}
private

Number of trigger eta measurements in the buckets crossed by the pattern, grouped by station.

Definition at line 207 of file MuonFastRecoTester.h.

207{m_tree.newMatrix<unsigned char>("pat_NAllNonPrecMeas", 0)};

◆ m_pat_nAllPhiMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nAllPhiMeas {m_tree.newMatrix<unsigned char>("pat_NAllPhiMeas", 0)}
private

Number of phi measurements in the buckets crossed by the pattern, grouped by station.

Definition at line 211 of file MuonFastRecoTester.h.

211{m_tree.newMatrix<unsigned char>("pat_NAllPhiMeas", 0)};

◆ m_pat_nAllPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nAllPrecMeas {m_tree.newMatrix<unsigned char>("pat_NAllPrecMeas", 0)}
private

Number of precision measurements in the buckets crossed by the pattern, grouped by station.

Definition at line 209 of file MuonFastRecoTester.h.

209{m_tree.newMatrix<unsigned char>("pat_NAllPrecMeas", 0)};

◆ m_pat_nMisTruthNonPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nMisTruthNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NMisTruthNonPrecMeas", 0)}
private

Number of mismatched truth trigger eta measurements per station.

Definition at line 193 of file MuonFastRecoTester.h.

193{m_tree.newMatrix<unsigned char>("pat_NMisTruthNonPrecMeas", 0)};

◆ m_pat_nMisTruthPhiMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nMisTruthPhiMeas {m_tree.newMatrix<unsigned char>("pat_NMisTruthPhiMeas", 0)}
private

Number of mismatched truth phi measurements per station.

Definition at line 197 of file MuonFastRecoTester.h.

197{m_tree.newMatrix<unsigned char>("pat_NMisTruthPhiMeas", 0)};

◆ m_pat_nMisTruthPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nMisTruthPrecMeas {m_tree.newMatrix<unsigned char>("pat_NMisTruthPrecMeas", 0)}
private

Number of mismatched truth precision measurements per station.

Definition at line 195 of file MuonFastRecoTester.h.

195{m_tree.newMatrix<unsigned char>("pat_NMisTruthPrecMeas", 0)};

◆ m_pat_nNonPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NNonPrecMeas", 0)}
private

Number of trigger eta measurements per station.

Definition at line 179 of file MuonFastRecoTester.h.

179{m_tree.newMatrix<unsigned char>("pat_NNonPrecMeas", 0)};

◆ m_pat_nPhiMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nPhiMeas {m_tree.newMatrix<unsigned char>("pat_NPhiMeas", 0)}
private

Number of phi measurements per station.

Definition at line 183 of file MuonFastRecoTester.h.

183{m_tree.newMatrix<unsigned char>("pat_NPhiMeas", 0)};

◆ m_pat_nPileupNonPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nPileupNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NPileupNonPrecMeas", 0)}
private

Number of pileup trigger eta measurements per station.

Definition at line 200 of file MuonFastRecoTester.h.

200{m_tree.newMatrix<unsigned char>("pat_NPileupNonPrecMeas", 0)};

◆ m_pat_nPileupPhiMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nPileupPhiMeas {m_tree.newMatrix<unsigned char>("pat_NPileupPhiMeas", 0)}
private

Number of pileup phi measurements per station.

Definition at line 204 of file MuonFastRecoTester.h.

204{m_tree.newMatrix<unsigned char>("pat_NPileupPhiMeas", 0)};

◆ m_pat_nPileupPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nPileupPrecMeas {m_tree.newMatrix<unsigned char>("pat_NPileupPrecMeas", 0)}
private

Number of pileup precision measurements per station.

Definition at line 202 of file MuonFastRecoTester.h.

202{m_tree.newMatrix<unsigned char>("pat_NPileupPrecMeas", 0)};

◆ m_pat_nPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nPrecMeas {m_tree.newMatrix<unsigned char>("pat_NPrecMeas", 0)}
private

Number of precision measurements per station.

Definition at line 181 of file MuonFastRecoTester.h.

181{m_tree.newMatrix<unsigned char>("pat_NPrecMeas", 0)};

◆ m_pat_nStations

MuonVal::VectorBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nStations {m_tree.newVector<unsigned char>("pat_NStations", 0)}
private

Number of stations.

Definition at line 176 of file MuonFastRecoTester.h.

176{m_tree.newVector<unsigned char>("pat_NStations", 0)};

◆ m_pat_nTruthNonPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nTruthNonPrecMeas {m_tree.newMatrix<unsigned char>("pat_NTruthNonPrecMeas", 0)}
private

Number of truth trigger eta measurements per station.

Definition at line 186 of file MuonFastRecoTester.h.

186{m_tree.newMatrix<unsigned char>("pat_NTruthNonPrecMeas", 0)};

◆ m_pat_nTruthPhiMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nTruthPhiMeas {m_tree.newMatrix<unsigned char>("pat_NTruthPhiMeas", 0)}
private

Number of truth phi measurements per station.

Definition at line 190 of file MuonFastRecoTester.h.

190{m_tree.newMatrix<unsigned char>("pat_NTruthPhiMeas", 0)};

◆ m_pat_nTruthPrecMeas

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_pat_nTruthPrecMeas {m_tree.newMatrix<unsigned char>("pat_NTruthPrecMeas", 0)}
private

Number of truth precision measurements per station.

Definition at line 188 of file MuonFastRecoTester.h.

188{m_tree.newMatrix<unsigned char>("pat_NTruthPrecMeas", 0)};

◆ m_pat_phi

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_pat_phi {m_tree.newVector<float>("pat_Phi", 0.0)}
private

Definition at line 167 of file MuonFastRecoTester.h.

167{m_tree.newVector<float>("pat_Phi", 0.0)};

◆ m_pat_sector1

MuonVal::VectorBranch<uint16_t>& MuonValR4::MuonFastRecoTester::m_pat_sector1 {m_tree.newVector<uint16_t>("pat_Sector1", 0)}
private

pattern primary & secondary sectors (different if the pattern is in the sector overlap)

Definition at line 169 of file MuonFastRecoTester.h.

169{m_tree.newVector<uint16_t>("pat_Sector1", 0)};
setWord1 uint16_t

◆ m_pat_sector2

MuonVal::VectorBranch<uint16_t>& MuonValR4::MuonFastRecoTester::m_pat_sector2 {m_tree.newVector<uint16_t>("pat_Sector2", 0)}
private

Definition at line 170 of file MuonFastRecoTester.h.

170{m_tree.newVector<uint16_t>("pat_Sector2", 0)};

◆ m_pat_side

MuonVal::VectorBranch<short>& MuonValR4::MuonFastRecoTester::m_pat_side {m_tree.newVector<short>("pat_Side", 0)}
private

+1 for A-, -1 of C-side

Definition at line 174 of file MuonFastRecoTester.h.

174{m_tree.newVector<short>("pat_Side", 0)};

◆ m_patternKey

SG::ReadHandleKey<MuonR4::GlobalPatternContainer> MuonValR4::MuonFastRecoTester::m_patternKey {this, "PatternKey", "MuonR4GlobalPatterns", "global pattern container"}
private

Definition at line 112 of file MuonFastRecoTester.h.

112{this, "PatternKey", "MuonR4GlobalPatterns", "global pattern container"};

◆ m_prefix

std::string AthHistogramAlgorithm::m_prefix
privateinherited

Name of the ROOT output stream (file).

Definition at line 88 of file AthHistogramAlgorithm.h.

◆ m_roi_EtaMax

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_roi_EtaMax {m_tree.newVector<float>("roi_EtaMax",-10.)}
private

Definition at line 219 of file MuonFastRecoTester.h.

219{m_tree.newVector<float>("roi_EtaMax",-10.)};

◆ m_roi_EtaMin

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_roi_EtaMin {m_tree.newVector<float>("roi_EtaMin",-10.)}
private

====== RoI info ===========

Definition at line 218 of file MuonFastRecoTester.h.

218{m_tree.newVector<float>("roi_EtaMin",-10.)};

◆ m_roi_PhiMax

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_roi_PhiMax {m_tree.newVector<float>("roi_PhiMax",-10.)}
private

Definition at line 221 of file MuonFastRecoTester.h.

221{m_tree.newVector<float>("roi_PhiMax",-10.)};

◆ m_roi_PhiMin

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_roi_PhiMin {m_tree.newVector<float>("roi_PhiMin",-10.)}
private

Definition at line 220 of file MuonFastRecoTester.h.

220{m_tree.newVector<float>("roi_PhiMin",-10.)};

◆ m_roi_ZMax

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_roi_ZMax {m_tree.newVector<float>("roi_ZMax",-10.)}
private

Definition at line 223 of file MuonFastRecoTester.h.

223{m_tree.newVector<float>("roi_ZMax",-10.)};

◆ m_roi_ZMin

MuonVal::VectorBranch<float>& MuonValR4::MuonFastRecoTester::m_roi_ZMin {m_tree.newVector<float>("roi_ZMin",-10.)}
private

Definition at line 222 of file MuonFastRecoTester.h.

222{m_tree.newVector<float>("roi_ZMin",-10.)};

◆ m_roiCollectionKey

SG::ReadHandleKey<TrigRoiDescriptorCollection> MuonValR4::MuonFastRecoTester::m_roiCollectionKey {this, "MuRoIs", "EFMuMSReco_RoI", "Name of the input data from HLTSeeding"}
private

Definition at line 121 of file MuonFastRecoTester.h.

121{this, "MuRoIs", "EFMuMSReco_RoI", "Name of the input data from HLTSeeding"};

◆ m_rootDir

std::string AthHistogramAlgorithm::m_rootDir
privateinherited

Name of the ROOT directory.

Definition at line 91 of file AthHistogramAlgorithm.h.

◆ m_spKey

SG::ReadHandleKey<MuonR4::SpacePointContainer> MuonValR4::MuonFastRecoTester::m_spKey {this, "SpacePointKey", "MuonSpacePoints"}
private

Definition at line 108 of file MuonFastRecoTester.h.

108{this, "SpacePointKey", "MuonSpacePoints"};

◆ m_spMatchedToPattern

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_spMatchedToPattern {m_tree.newMatrix<unsigned char>(m_spKey.key()+"_patternMatched")}
private

Branch indicating which space points in the tree are associated to the i-th pattern.

Definition at line 141 of file MuonFastRecoTester.h.

141{m_tree.newMatrix<unsigned char>(m_spKey.key()+"_patternMatched")};

◆ m_spMatchedToTruth

MuonVal::MatrixBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_spMatchedToTruth {m_tree.newMatrix<unsigned char>(m_spKey.key()+"_truthMatched")}
private

Branch indicating which space points in the tree are associated to the i-th truth particle.

Definition at line 144 of file MuonFastRecoTester.h.

144{m_tree.newMatrix<unsigned char>(m_spKey.key()+"_truthMatched")};

◆ m_spSorter

MuonR4::SpacePointPerLayerSorter MuonValR4::MuonFastRecoTester::m_spSorter {}
private

Definition at line 232 of file MuonFastRecoTester.h.

232{};

◆ m_spTester

std::shared_ptr<SpacePointTesterModule> MuonValR4::MuonFastRecoTester::m_spTester {}
private

====== Spacepoint block ===========

Branch dumping all the space points from the difference buckets

Definition at line 135 of file MuonFastRecoTester.h.

135{};

◆ m_spType

MuonVal::VectorBranch<unsigned char>& MuonValR4::MuonFastRecoTester::m_spType {m_tree.newVector<unsigned char>(m_spKey.key()+"_type")}
private

Type of spacepoints: 1 for trigger eta, 2 for precision, 3 for only-phi.

Definition at line 138 of file MuonFastRecoTester.h.

138{m_tree.newVector<unsigned char>(m_spKey.key()+"_type")};

◆ m_streamName

std::string AthHistogramming::m_streamName
privateinherited

Name of the ROOT output stream (file).

Definition at line 220 of file AthHistogramming.h.

◆ m_tree

MuonVal::MuonTesterTree MuonValR4::MuonFastRecoTester::m_tree {"MuonFastRecoTest","FastRecoTester"}
private

Definition at line 105 of file MuonFastRecoTester.h.

105{"MuonFastRecoTest","FastRecoTester"};

◆ m_treeMap

TreeMap_t AthHistogramming::m_treeMap
privateinherited

The map of TTree names to their pointers.

Definition at line 209 of file AthHistogramming.h.

◆ m_truthSegmentKey

SG::ReadHandleKey<xAOD::MuonSegmentContainer> MuonValR4::MuonFastRecoTester::m_truthSegmentKey {this, "TruthSegmentKey","MuonTruthSegments", "truth segment container"}
private

Definition at line 118 of file MuonFastRecoTester.h.

118{this, "TruthSegmentKey","MuonTruthSegments", "truth segment container"};

◆ m_varHandleArraysDeclared

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

Definition at line 387 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 386 of file AthCommonDataStore.h.

◆ m_writeSpacePoints

BooleanProperty MuonValR4::MuonFastRecoTester::m_writeSpacePoints
private
Initial value:
{this, "writeSpacePoints", false,
"Toggle whether the particular space poitns shall be written"}

Definition at line 130 of file MuonFastRecoTester.h.

130 {this, "writeSpacePoints", false,
131 "Toggle whether the particular space poitns shall be written"};

The documentation for this class was generated from the following files: