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

#include <MuonSegmentReader.h>

Inheritance diagram for MuonCalib::MuonSegmentReader:
Collaboration diagram for MuonCalib::MuonSegmentReader:

Public Member Functions

virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
virtual StatusCode finalize () override
 
unsigned int cardinality () const override final
 
 AthHistogramAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 Constructor with parameters: More...
 
virtual StatusCode sysInitialize ()
 Initialization method invoked by the framework. More...
 
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. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

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

Private Types

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

Private Member Functions

void storeMeasurement (const EventContext &ctx, const MuonGM::MuonDetectorManager *MuonDetMgr, unsigned int itrk, const Trk::TrackStateOnSurface *trk_state, const Trk::MeasurementBase *measurement)
 
void storeHole (const Trk::TrackStateOnSurface *trk_state, unsigned int itrk)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 
void buildBookingString (std::string &bookingString, std::string &histName, std::string &tDir, std::string &stream, bool usePrefixPostfix=false)
 Method to build individual booking string. More...
 
void myReplace (std::string &str, const std::string &oldStr, const std::string &newStr)
 Helper method to replace sub-string. More...
 
hash_t hash (const std::string &histName) const
 Method to calculate a 32-bit hash from a string. More...
 

Private Attributes

SG::ReadHandleKey< xAOD::EventInfo > m_evtKey {this, "EventInfoKey", "EventInfo", "xAOD::EventInfo ReadHandleKey"}
 
SG::ReadHandleKey< TrackCollection > m_TrkKey {this, "MuonTrackLocations", "MuonSpectrometerTracks"}
 
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_MdtPrepDataKey {this, "MdtPrepData", "MDT_DriftCircles","MDT DriftCircles"}
 
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_RpcPrepDataKey {this,"RpcPrdCollection","RPC_Measurements","RPC PRD Container"}
 
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_TgcPrepDataKey {this,"TgcPrdCollection","TGC_Measurements","TGC PRD Container"}
 
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
 
ServiceHandle< Muon::IMuonIdHelperSvc > m_MuonIdHelper
 
ToolHandle< IMdtCalibrationTool > m_calibrationTool {this, "CalibrationTool", "MdtCalibrationTool"}
 pointer to MdtCalibSvc More...
 
PublicToolHandle< Trk::IResidualPullCalculator > m_pullCalculator
 
ToolHandle< MuonCalib::IIdToFixedIdTool > m_idToFixedIdTool {this, "IdToFixedIdTool", "MuonCalib::IdToFixedIdTool/MuonCalib_IdToFixedIdTool"}
 
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
 
MuonTesterTree m_tree {"Segments", "CALIBNTUPLESTREAM"}
 
ScalarBranch< int > & m_runNumber {m_tree.newScalar<int>("event_runNumber")}
 
ScalarBranch< int > & m_eventNumber {m_tree.newScalar<int>("event_eventNumber")}
 
ScalarBranch< int > & m_lumiBlock {m_tree.newScalar<int>("event_lumiBlock")}
 
ScalarBranch< int > & m_bcId {m_tree.newScalar<int>("event_bcId")}
 
ScalarBranch< int > & m_timeStamp {m_tree.newScalar<int>("event_timeStamp")}
 
ScalarBranch< float > & m_pt {m_tree.newScalar<float>("event_LVL2Pt")}
 
ScalarBranch< int > & m_rawMdt_nRMdt {m_tree.newScalar<int>("rawMdt_nRMdt")}
 
VectorBranch< unsigned int > & m_rawMdt_id {m_tree.newVector<unsigned int>("rawMdt_id")}
 
VectorBranch< int > & m_rawMdt_tdc {m_tree.newVector<int>("rawMdt_tdc")}
 
VectorBranch< int > & m_rawMdt_adc {m_tree.newVector<int>("rawMdt_adc")}
 
ThreeVectorBranch m_rawMdt_gPos {m_tree,"rawMdt_gPos"}
 
ScalarBranch< int > & m_rawRpc_nRRpc {m_tree.newScalar<int>("rawRpc_nRRpc")}
 
VectorBranch< unsigned int > & m_rawRpc_id {m_tree.newVector<unsigned int>("rawRpc_id")}
 
VectorBranch< float > & m_rawRpc_time {m_tree.newVector<float>("rawRpc_time")}
 
ThreeVectorBranch m_rawRpc_gPos {m_tree,"rawRpc_gPos"}
 
ScalarBranch< int > & m_rawTgc_nRTgc {m_tree.newScalar<int>("rawTgc_nRTgc")}
 
VectorBranch< unsigned int > & m_rawTgc_id {m_tree.newVector<unsigned int>("rawTgc_id")}
 
VectorBranch< int > & m_rawTgc_bcBitMap {m_tree.newVector<int>("rawTgc_bcBitMap")}
 
ThreeVectorBranch m_rawTgc_gPos {m_tree,"rawTgc_gPos"}
 
ScalarBranch< int > & m_trk_nTracks {m_tree.newScalar<int>("trk_nTracks")}
 
VectorBranch< float > & m_trk_d0 {m_tree.newVector<float>("trk_d0")}
 
VectorBranch< float > & m_trk_z0 {m_tree.newVector<float>("trk_z0")}
 
VectorBranch< float > & m_trk_phi {m_tree.newVector<float>("trk_phi")}
 
VectorBranch< float > & m_trk_theta {m_tree.newVector<float>("trk_theta")}
 
VectorBranch< float > & m_trk_eta {m_tree.newVector<float>("trk_eta")}
 
VectorBranch< float > & m_trk_qOverP {m_tree.newVector<float>("trk_qOverP")}
 
VectorBranch< float > & m_trk_pt {m_tree.newVector<float>("trk_pt")}
 
VectorBranch< float > & m_trk_chi2 {m_tree.newVector<float>("trk_chi2")}
 
VectorBranch< int > & m_trk_ndof {m_tree.newVector<int>("trk_ndof")}
 
VectorBranch< int > & m_trk_author {m_tree.newVector<int>("trk_author")}
 
ThreeVectorBranch m_trk_perigee {m_tree,"trk_perigee"}
 
VectorBranch< int > & m_trk_nMdtHits {m_tree.newVector<int>("trk_nMdtHits")}
 
VectorBranch< int > & m_trk_nMdtHoles {m_tree.newVector<int>("trk_nMdtHoles")}
 
VectorBranch< int > & m_trk_nOutliersHits {m_tree.newVector<int>("trk_nOutliersHits")}
 
VectorBranch< int > & m_trk_nRpcPhiHits {m_tree.newVector<int>("trk_nRpcPhiHits")}
 
VectorBranch< int > & m_trk_nRpcEtaHits {m_tree.newVector<int>("trk_nRpcEtaHits")}
 
VectorBranch< int > & m_trk_nTgcPhiHits {m_tree.newVector<int>("trk_nTgcPhiHits")}
 
VectorBranch< int > & m_trk_nTgcEtaHits {m_tree.newVector<int>("trk_nTgcEtaHits")}
 
ScalarBranch< int > & m_trkHit_nMdtHits {m_tree.newScalar<int>("trkHit_nMdtHits")}
 
VectorBranch< int > & m_trkHit_trackIndex {m_tree.newVector<int>("trkHit_trackIndex")}
 
ThreeVectorBranch m_trkHit_gPos {m_tree,"trkHit_gPos"}
 
ThreeVectorBranch m_trkHit_pos {m_tree,"trkHit_pos"}
 
ThreeVectorBranch m_trkHit_closestApproach {m_tree,"trkHit_closestApproach"}
 
ThreeVectorBranch m_trkHit_gClosestApproach {m_tree,"trkHit_gClosestApproach"}
 
ThreeVectorBranch m_trkHit_center {m_tree,"trkHit_center"}
 
VectorBranch< int > & m_trkHit_adc {m_tree.newVector<int>("trkHit_adc")}
 
VectorBranch< int > & m_trkHit_type {m_tree.newVector<int>("trkHit_type")}
 
VectorBranch< int > & m_trkHit_tdc {m_tree.newVector<int>("trkHit_tdc")}
 
VectorBranch< float > & m_trkHit_resi {m_tree.newVector<float>("trkHit_resi")}
 
VectorBranch< float > & m_trkHit_pull {m_tree.newVector<float>("trkHit_pull")}
 
VectorBranch< unsigned int > & m_trkHit_id {m_tree.newVector<unsigned int>("trkHit_id")}
 
VectorBranch< float > & m_trkHit_driftRadius {m_tree.newVector<float>("trkHit_driftRadius")}
 
VectorBranch< float > & m_trkHit_error {m_tree.newVector<float>("trkHit_error")}
 
VectorBranch< float > & m_trkHit_rTrk {m_tree.newVector<float>("trkHit_rTrk")}
 
VectorBranch< float > & m_trkHit_driftTime {m_tree.newVector<float>("trkHit_driftTime")}
 
VectorBranch< float > & m_trkHit_distRO {m_tree.newVector<float>("trkHit_distRO")}
 
VectorBranch< float > & m_trkHit_localAngle {m_tree.newVector<float>("trkHit_localAngle")}
 
VectorBranch< float > & m_trkHit_tubeT0 {m_tree.newVector<float>("trkHit_tubeT0")}
 
VectorBranch< float > & m_trkHit_triggerTime {m_tree.newVector<float>("trkHit_triggerTime")}
 
VectorBranch< float > & m_trkHit_tubeMeanAdc {m_tree.newVector<float>("trkHit_tubeMeanAdc")}
 
VectorBranch< float > & m_trkHit_slewTime {m_tree.newVector<float>("trkHit_slewTime")}
 
VectorBranch< float > & m_trkHit_lorTime {m_tree.newVector<float>("trkHit_lorTime")}
 
VectorBranch< float > & m_trkHit_propTime {m_tree.newVector<float>("trkHit_propTime")}
 
VectorBranch< float > & m_trkHit_tempTime {m_tree.newVector<float>("trkHit_tempTime")}
 
VectorBranch< float > & m_trkHit_bkgTime {m_tree.newVector<float>("trkHit_bkgTime")}
 
VectorBranch< float > & m_trkHit_tof {m_tree.newVector<float>("trkHit_tof")}
 
VectorBranch< int > & m_trkHit_calibStatus {m_tree.newVector<int>("trkHit_calibStatus")}
 
ScalarBranch< int > & m_trkHole_nHoles {m_tree.newScalar<int>("trkHole_nHoles")}
 
VectorBranch< int > & m_trkHole_trackIndex {m_tree.newVector<int>("trkHole_trackIndex")}
 
VectorBranch< int > & m_trkHole_type {m_tree.newVector<int>("trkHole_type")}
 
ThreeVectorBranch m_trkHole_gPos {m_tree,"trkHole_gPos"}
 
VectorBranch< unsigned int > & m_trkHole_id {m_tree.newVector<unsigned int>("trkHole_id")}
 
VectorBranch< float > & m_trkHole_driftRadius {m_tree.newVector<float>("trkHole_driftRadius")}
 
ScalarBranch< int > & m_trkTriggerHit_nHits {m_tree.newScalar<int>("trkTriggerHit_nHits")}
 
VectorBranch< int > & m_trkTriggerHit_trackIndex {m_tree.newVector<int>("trkTriggerHit_trackIndex")}
 
VectorBranch< int > & m_trkTriggerHit_type {m_tree.newVector<int>("trkTriggerHit_type")}
 
ThreeVectorBranch m_trkTriggerHit_gPos {m_tree,"trkTriggerHit_gPos"}
 
VectorBranch< unsigned int > & m_trkTriggerHit_id {m_tree.newVector<unsigned int>("trkTriggerHit_id")}
 
VectorBranch< float > & m_trkTriggerHit_time {m_tree.newVector<float>("trkTriggerHit_time")}
 
ServiceHandle< ITHistSvc > m_histSvc
 Default constructor: AthHistogramAlgorithm();. More...
 
std::string m_prefix
 Name of the ROOT output stream (file) More...
 
std::string m_rootDir
 Name of the ROOT directory. More...
 
std::string m_histNamePrefix
 The prefix for the histogram THx name. More...
 
std::string m_histNamePostfix
 The postfix for the histogram THx name. More...
 
std::string m_histTitlePrefix
 The prefix for the histogram THx title. More...
 
std::string m_histTitlePostfix
 The postfix for the histogram THx title. More...
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 
HistMap_t m_histMap
 The map of histogram names to their pointers. More...
 
EffMap_t m_effMap
 The map of histogram names to their pointers. More...
 
TreeMap_t m_treeMap
 The map of TTree names to their pointers. More...
 
GraphMap_t m_graphMap
 The map of TGraph names to their pointers. More...
 
std::string m_streamName
 Name of the ROOT output stream (file) More...
 
std::string m_name
 Instance name. More...
 
MsgStream m_msg
 Cached Message Stream. More...
 

Detailed Description

Definition at line 52 of file MuonSegmentReader.h.

Member Typedef Documentation

◆ EffMap_t

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

Typedef for convenience.

Definition at line 205 of file AthHistogramming.h.

◆ GraphMap_t

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

Typedef for convenience.

Definition at line 219 of file AthHistogramming.h.

◆ hash_t

typedef uint32_t AthHistogramming::hash_t
privateinherited

typedef for the internal hash

Definition at line 169 of file AthHistogramming.h.

◆ HistMap_t

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

Typedef for convenience.

Definition at line 198 of file AthHistogramming.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ TreeMap_t

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

Typedef for convenience.

Definition at line 212 of file AthHistogramming.h.

Member Function Documentation

◆ AthHistogramAlgorithm()

AthHistogramAlgorithm::AthHistogramAlgorithm

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 }

◆ book() [1/8]

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

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

Definition at line 335 of file AthHistogramming.h.

336 {
337  // We need to create a non-const clone
338  TEfficiency* effClone = dynamic_cast< TEfficiency* >( eff.Clone() );
339  if ( !effClone ) {
340  m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone" << endmsg;
341  return StatusCode::FAILURE;
342  }
343  return this->book( *effClone, tDir, stream );
344 }

◆ book() [2/8]

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

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

◆ book() [3/8]

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

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

Definition at line 303 of file AthHistogramming.h.

304 {
305  // We need to create a non-const clone
306  TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
307  if ( !histClone ) {
308  m_msg << MSG::ERROR << "Couldn't create a TH1 clone" << endmsg;
309  return StatusCode::FAILURE;
310  }
311  return this->book( *histClone, tDir, stream );
312 }

◆ book() [4/8]

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

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

Definition at line 403 of file AthHistogramming.h.

404 {
405  // Call the other Book method and see if it returns a valid pointer
406  TTree* treePointer = this->bookGetPointer( treeRef, tDir, stream );
407  if ( treePointer )
408  {
409  return StatusCode::SUCCESS;
410  }
411  else
412  {
413  return StatusCode::FAILURE;
414  }
415 }

◆ book() [5/8]

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

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

Definition at line 356 of file AthHistogramming.h.

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

◆ book() [6/8]

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

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

Definition at line 346 of file AthHistogramming.h.

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

◆ book() [7/8]

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

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

Definition at line 324 of file AthHistogramming.h.

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

◆ book() [8/8]

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

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

Definition at line 314 of file AthHistogramming.h.

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

◆ bookGetPointer() [1/8]

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

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

Definition at line 281 of file AthHistogramming.h.

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

◆ bookGetPointer() [2/8]

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

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

Definition at line 427 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [3/8]

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

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

Definition at line 260 of file AthHistogramming.h.

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

◆ bookGetPointer() [4/8]

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

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

Definition at line 312 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [5/8]

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

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

Definition at line 146 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [6/8]

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

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

Definition at line 293 of file AthHistogramming.h.

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

◆ bookGetPointer() [7/8]

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

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

Definition at line 98 of file AthHistogramming.cxx.

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

◆ bookGetPointer() [8/8]

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

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

Definition at line 272 of file AthHistogramming.h.

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

◆ buildBookingString()

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

Method to build individual booking string.

Definition at line 560 of file AthHistogramming.cxx.

565 {
566  // Massage the final string to book things
567  if(tDir.empty()) tDir = m_rootDir;
568  size_t pos = histName.rfind('/');
569  if(pos != std::string::npos){
570  tDir+='/';
571  tDir.append(histName, 0,pos);
572  histName.erase(0,pos+1);
573  };
574  if(stream.empty()) stream = m_streamName;
575 
576  if(usePrefixPostfix){
577  bookingString = "/"+stream+"/"+tDir+"/"+m_histNamePrefix+histName+m_histNamePostfix;
578  } else {
579  bookingString = "/"+stream+"/"+tDir+"/"+histName;
580  }
581  while(bookingString.find("//") != std::string::npos){
582  this->myReplace(bookingString,"//","/");
583  }
584 
585  return;
586 }

◆ cardinality()

unsigned int MuonCalib::MuonSegmentReader::cardinality ( ) const
inlinefinaloverride

Definition at line 63 of file MuonSegmentReader.h.

63 { return 1; } ;

◆ configAthHistogramming()

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

To be called by the derived classes to fill the internal configuration.

Definition at line 66 of file AthHistogramming.cxx.

70 {
71  m_histSvc = histSvc;
72  m_streamName = prefix;
73  m_rootDir = rootDir;
74  m_histNamePrefix = histNamePrefix;
75  m_histNamePostfix = histNamePostfix;
76  m_histTitlePrefix = histTitlePrefix;
77  m_histTitlePostfix = histTitlePostfix;
78 
79  return StatusCode::SUCCESS;
80 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ efficiency()

TEfficiency * AthHistogramming::efficiency ( const std::string &  effName,
const std::string &  tDir = "",
const std::string &  stream = "" 
)
protectedinherited

Simplify the retrieval of registered TEfficiency.

Definition at line 250 of file AthHistogramming.cxx.

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

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode MuonCalib::MuonSegmentReader::execute ( )
overridevirtual

< number of measurements flaged as outliers in TSOS

Definition at line 46 of file MuonSegmentReader.cxx.

47 {
48 
49  // fill eventInfo branches
50  const EventContext& ctx = Gaudi::Hive::currentContext();
51  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_evtKey,ctx);
52  if (!eventInfo.isValid()) {
53  ATH_MSG_ERROR("Did not find xAOD::EventInfo");
54  return StatusCode::FAILURE;
55  }
56 
57  m_runNumber = eventInfo->runNumber();
58  m_eventNumber = eventInfo->eventNumber();
59  m_lumiBlock = eventInfo->lumiBlock();
60  m_bcId = eventInfo->bcid();
61  m_timeStamp = eventInfo->timeStamp();
62  m_pt = eventInfo->timeStampNSOffset(); // special treatment in eventInfo for muon calibration stream data
63 
64  // load Geo
65  SG::ReadCondHandle<MuonGM::MuonDetectorManager> DetectorManagerHandle{m_DetectorManagerKey, ctx};
66  const MuonGM::MuonDetectorManager* MuonDetMgr = DetectorManagerHandle.cptr();
67  if (!MuonDetMgr) {
68  ATH_MSG_ERROR("Null pointer to the read MuonDetectorManager conditions object");
69  return StatusCode::FAILURE;
70  }
71 
72  // fill the rawMdt Hit branches
73  SG::ReadHandle<Muon::MdtPrepDataContainer> mdtPrepRawData(m_MdtPrepDataKey, ctx);
74  ATH_MSG_DEBUG("Size of MdtPrepDataContainer : "<<mdtPrepRawData->size());
75  // Loop MdtPrepDataContainer
76  for( auto mdtColl : *mdtPrepRawData){
77  for (const Muon::MdtPrepData* prd : *mdtColl) {
78  MuonFixedId fixid = m_idToFixedIdTool->idToFixedId(prd->identify());
79  m_rawMdt_id.push_back(fixid.getIdInt()) ;
80  m_rawMdt_tdc.push_back(prd->tdc());
81  m_rawMdt_adc.push_back(prd->adc());
82  m_rawMdt_gPos.push_back(prd->globalPosition());
83  ATH_MSG_DEBUG("Mdt FixedId "<<fixid.getIdInt()<<" prd phi "<<prd->globalPosition().phi()<<" prd theta "<<prd->globalPosition().theta());
84  } // end of MdtPrepDataCollection
85  } // end of MdtPrepDataContainer
86  m_rawMdt_nRMdt = m_rawMdt_id.size() ;
87  ATH_MSG_DEBUG("Number of MDT raw Hits : "<<m_rawMdt_nRMdt);
88 
89  // fill the rawRpc Hit branches
90  SG::ReadHandle<Muon::RpcPrepDataContainer> rpcPrepRawData(m_RpcPrepDataKey, ctx);
91  ATH_MSG_DEBUG("Size of RpcPrepDataContainer : "<<rpcPrepRawData->size());
92  // Loop RpcPrepDataContainer
93  for( auto rpcColl : *rpcPrepRawData) {
94  for (const Muon::RpcPrepData* prd : *rpcColl) {
95  MuonFixedId fixid = m_idToFixedIdTool->idToFixedId(prd->identify());
96  m_rawRpc_id.push_back(fixid.getIdInt()) ;
97  m_rawRpc_time.push_back(prd->time());
98  m_rawRpc_gPos.push_back(prd->globalPosition());
99  ATH_MSG_DEBUG("Rpc FixedId "<<fixid.getIdInt()<<" prd phi "<<prd->globalPosition().phi()<<" prd theta "<<prd->globalPosition().theta());
100  } // end of RpcPrepDataCollection
101  } // end of RpcPrepDataContainer
102  m_rawRpc_nRRpc = m_rawRpc_id.size() ;
103  ATH_MSG_DEBUG("Number of Rpc raw Hits : "<<m_rawRpc_nRRpc);
104 
105  // fill the rawTgc Hit branches
106  SG::ReadHandle<Muon::TgcPrepDataContainer> tgcPrepRawData(m_TgcPrepDataKey, ctx);
107  ATH_MSG_DEBUG("Size of TgcPrepDataContainer : "<<tgcPrepRawData->size());
108  // Loop TgcPrepDataContainer
109  for (auto tgcColl : *tgcPrepRawData) {
110  for (const Muon::TgcPrepData* prd : *tgcColl) {
111  MuonFixedId fixid = m_idToFixedIdTool->idToFixedId(prd->identify());
112  m_rawTgc_id.push_back(fixid.getIdInt()) ;
113  m_rawTgc_bcBitMap.push_back(prd->getBcBitMap());
114  m_rawTgc_gPos.push_back(prd->globalPosition());
115  ATH_MSG_DEBUG("Tgc FixedId "<<fixid.getIdInt()<<" prd phi "<<prd->globalPosition().phi()<<" prd theta "<<prd->globalPosition().theta());
116  } // end of TgcPrepDataCollection
117  } // end of TgcPrepDataContainer
118  m_rawTgc_nRTgc = m_rawTgc_id.size() ;
119  ATH_MSG_DEBUG("Number of Tgc raw Hits : "<<m_rawTgc_nRTgc);
120 
121  // fill the muon standalone tracks branches
122  SG::ReadHandle<TrackCollection> muTrks(m_TrkKey, ctx);
123  ATH_MSG_INFO("Number of Muon StandAlone Tracks : "<<muTrks->size());
124  m_trk_nTracks = muTrks->size() ;
125  // if tracks were found, print MDT track hits
126  for (unsigned int itrk = 0; itrk < muTrks->size(); ++itrk) {
127 
128  const Trk::Track* trkSA = muTrks->at(itrk) ;
129 
130  ATH_MSG_DEBUG(m_printer->print(*trkSA));
131  ATH_MSG_DEBUG("Track author : "<<m_printer->printPatRec(*trkSA));
132  ATH_MSG_DEBUG("TrackHit measurements : "<<m_printer->printMeasurements(*trkSA));
133  //Trk::TrackInfo trkInfo = trkSA->info();
134  //ATH_MSG_DEBUG("Track Author = " << int(trkInfo.m_patternRecognition.test(Trk::TrackInfo::Moore)));
135  m_trk_author.push_back(208); // Hardcode 208 as Moore for MuonStandaloneTrack
136 
137  // get trackSummary
138  const Trk::MuonTrackSummary* summary = nullptr;
139  // check if the track already has a MuonTrackSummary, if not calculate it using the helper
140  const Trk::TrackSummary* trkSummary = trkSA->trackSummary();
141  m_trk_nMdtHits.push_back(trkSummary->get(Trk::numberOfMdtHits));
143  m_trk_nOutliersHits.push_back(trkSummary->get(Trk::numberOfOutliersOnTrack));
144  m_trk_nRpcPhiHits.push_back(trkSummary->get(Trk::numberOfRpcPhiHits));
145  m_trk_nTgcPhiHits.push_back(trkSummary->get(Trk::numberOfTgcPhiHits));
146  m_trk_nRpcEtaHits.push_back(trkSummary->get(Trk::numberOfRpcEtaHits));
147  m_trk_nTgcEtaHits.push_back(trkSummary->get(Trk::numberOfTgcEtaHits));
148  m_trk_nMdtHoles.push_back(trkSummary->get(Trk::numberOfMdtHoles));
149 
150  ATH_MSG_DEBUG("Mdt Hits " << trkSummary->get(Trk::numberOfMdtHits)
151  <<" Mdt Holes "<< trkSummary->get(Trk::numberOfMdtHoles)
152  << "Mdt Outliers " << trkSummary->get(Trk::numberOfOutliersOnTrack)
153  << " TGC Phi Eta Hits "<<trkSummary->get(Trk::numberOfTgcPhiHits)<<" "<<trkSummary->get(Trk::numberOfTgcEtaHits)
154  << " RPC Phi Eta Hits "<<trkSummary->get(Trk::numberOfRpcPhiHits)<<" "<<trkSummary->get(Trk::numberOfRpcEtaHits));
155 
156  if (trkSummary) summary = trkSummary->muonTrackSummary();
157  if (!summary) {
158  ATH_MSG_WARNING("No muon summary is present");
159  }
160  else {
161  ATH_MSG_DEBUG("print MuonSummary : "<<m_printer->print(*summary));
162  }
163 
164  // Trk perigee
165  const Trk::Perigee* perigee = trkSA->perigeeParameters();
166  if (!perigee) {
167  ATH_MSG_WARNING(" was expecting a perigee here... ");
168  return StatusCode::FAILURE;
169  }
170  // track direction vector
171  const Amg::Vector3D dir = perigee->momentum().unit();
172  m_trk_perigee.push_back(dir);
173  m_trk_d0.push_back(perigee->parameters()[Trk::d0]);
174  m_trk_z0.push_back(perigee->parameters()[Trk::z0]);
175  m_trk_phi.push_back(perigee->parameters()[Trk::phi0]);
176  m_trk_theta.push_back(perigee->parameters()[Trk::theta]);
177  m_trk_qOverP.push_back(perigee->parameters()[Trk::qOverP]);
178  m_trk_eta.push_back(perigee->eta());
179  m_trk_pt.push_back(perigee->pT());
180 
181  // Trk fit quality
182  const Trk::FitQuality* fq = trkSA->fitQuality();
183  if (!fq) {
184  ATH_MSG_WARNING(" was expecting a FitQuality here... ");
185  return StatusCode::FAILURE;
186  }
187  m_trk_chi2.push_back(fq->chiSquared()) ;
188  m_trk_ndof.push_back(fq->numberDoF());
189 
190  // Loop track hits by trk_states and store the measure
191  const DataVector<const Trk::TrackStateOnSurface>* trk_states = trkSA->trackStateOnSurfaces();
192  if (!trk_states) {
193  ATH_MSG_WARNING(" track without states, discarding track ");
194  return StatusCode::FAILURE;
195  }
196 
197  unsigned int nMeasurement = 0, nHole = 0;
198  for (const Trk::TrackStateOnSurface* trk_state : *trk_states) {
199  // First handle the case of mdtHole
200  if (trk_state->type(Trk::TrackStateOnSurface::Hole)) {
201  storeHole(trk_state, itrk);
202  nHole ++;
203  continue;
204  }
205 
206  const Trk::MeasurementBase* measurement = trk_state->measurementOnTrack();
207  if (!measurement) continue;
208  storeMeasurement(ctx, MuonDetMgr, itrk, trk_state, measurement);
209  nMeasurement ++;
210  } // end of track hit loop
211  ATH_MSG_DEBUG("Total recorded hits in the track "<<itrk<<" #Mesurement "<<nMeasurement<<" #Hole "<<nHole) ;
212  } // end of track loop
213  m_trkHit_nMdtHits=m_trkHit_type.size();
214  m_trkTriggerHit_nHits=m_trkTriggerHit_type.size();
215  m_trkHole_nHoles=m_trkHole_type.size();
216  ATH_MSG_DEBUG("Total recorded "<<m_trkHit_type.size()<<" MDT hits, "<<m_trkTriggerHit_type.size()<<" Trigger hits and "<<m_trkHole_type.size()<<" hole hits in all tracks!") ;
217 
218 
219  if (!m_tree.fill(ctx)) return StatusCode::FAILURE;
220  return StatusCode::SUCCESS;
221 }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ finalize()

StatusCode MuonCalib::MuonSegmentReader::finalize ( )
overridevirtual

Definition at line 459 of file MuonSegmentReader.cxx.

460 {
461  ATH_MSG_INFO("MuonSegmentReader :: Finalize + Matching");
462  ATH_CHECK(m_tree.write());
463  return StatusCode::SUCCESS;
464 }

◆ graph()

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

Simplify the retrieval of registered TGraphs.

Definition at line 492 of file AthHistogramming.cxx.

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

◆ hash()

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

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

Definition at line 428 of file AthHistogramming.h.

429 {
430  const uint64_t hash64 = CxxUtils::crc64( histName );
431  return (hash_t)(hash64 & 0xFFFFFFFF);
432 }

◆ hist()

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

Simplify the retrieval of registered histograms of any type.

Definition at line 198 of file AthHistogramming.cxx.

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

◆ hist2d()

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

Simplify the retrieval of registered 2-d histograms.

Definition at line 369 of file AthHistogramming.h.

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

◆ hist3d()

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

Simplify the retrieval of registered 3-d histograms.

Definition at line 386 of file AthHistogramming.h.

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

◆ histSvc()

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

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

Definition at line 113 of file AthHistogramAlgorithm.h.

114 {
115  return m_histSvc;
116 }

◆ initialize()

StatusCode MuonCalib::MuonSegmentReader::initialize ( )
overridevirtual

Definition at line 17 of file MuonSegmentReader.cxx.

18 {
19 
20  ATH_CHECK(m_evtKey.initialize() );
21  //ATH_CHECK(m_TrkSegKey.initialize());
22  ATH_CHECK(m_TrkKey.initialize());
23  //ATH_CHECK(m_CbTrkKey.initialize());
24  //ATH_CHECK(m_EMEO_TrkKey.initialize()); // run3 only EM EO MS tracks
25  ATH_CHECK(m_MdtPrepDataKey.initialize());
26  ATH_CHECK(m_RpcPrepDataKey.initialize());
27  ATH_CHECK(m_TgcPrepDataKey.initialize());
28  ATH_CHECK(m_calibrationTool.retrieve());
29  ATH_MSG_VERBOSE("MdtCalibrationTool retrieved with pointer = " << m_calibrationTool);
30 
31  ATH_CHECK(m_DetectorManagerKey.initialize());
32  ATH_CHECK(m_idToFixedIdTool.retrieve());
33  ATH_CHECK(m_pullCalculator.retrieve());
34  // ATH_CHECK(m_assocTool.retrieve());
35  // ATH_CHECK(m_idHelperSvc.retrieve());
36  ATH_CHECK(m_MuonIdHelper.retrieve());
37  ATH_CHECK(m_printer.retrieve());
38  //ATH_CHECK(histSvc.retrieve() );
39  ATH_CHECK(m_tree.init(this));
40 
41 
42 
43  return StatusCode::SUCCESS;
44 }

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ myReplace()

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

Helper method to replace sub-string.

Definition at line 590 of file AthHistogramming.cxx.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ storeHole()

void MuonCalib::MuonSegmentReader::storeHole ( const Trk::TrackStateOnSurface *  trk_state,
unsigned int  itrk 
)
private

Definition at line 223 of file MuonSegmentReader.cxx.

223  {
224  ATH_MSG_DEBUG(" MDT Hole on track ");
225  const Trk::TrackParameters *trackPars = trk_state->trackParameters();
226  if (!trackPars) return;
227  Amg::Vector3D pos = trackPars->position();
228  m_trkHole_gPos.push_back(pos);
229 
230  const Identifier idHole = trk_state->trackParameters()->associatedSurface().associatedDetectorElementIdentifier();
231  MuonFixedId fixid = m_idToFixedIdTool->idToFixedId(idHole);
232  m_trkHole_id.push_back(fixid.getIdInt()) ;
233  ATH_MSG_DEBUG(" Hole stored at position x " << pos.x() << " y " << pos.y() << " z " << pos.z());
234  // check the hit type (1 MDT /2 RPC/3 TGC)
235  if (m_MuonIdHelper->isMdt(idHole)) m_trkHole_type.push_back(1);
236  else if (m_MuonIdHelper->isRpc(idHole)) m_trkHole_type.push_back(2);
237  else if (m_MuonIdHelper->isTgc(idHole)) m_trkHole_type.push_back(3);
238  else {
239  m_trkHole_type.push_back(0);
240  ATH_MSG_DEBUG("None of MDT/RPC/TGC Identifier match, something wrong!");
241  }
242 
243  m_trkHole_driftRadius.push_back(std::abs(trackPars->parameters()[Trk::locR]));
244  m_trkHole_trackIndex.push_back(itrk);
245 
246 } // end storeHole

◆ storeMeasurement()

void MuonCalib::MuonSegmentReader::storeMeasurement ( const EventContext &  ctx,
const MuonGM::MuonDetectorManager *  MuonDetMgr,
unsigned int  itrk,
const Trk::TrackStateOnSurface *  trk_state,
const Trk::MeasurementBase *  measurement 
)
private

Definition at line 249 of file MuonSegmentReader.cxx.

249  {
250 
251  const Trk::TrackParameters *trackPars = trk_state->trackParameters();
252  const Trk::RIO_OnTrack* rot = dynamic_cast<const Trk::RIO_OnTrack*>(measurement);
253 
254  if (rot) { // case of measurement exist
255  Identifier rot_id = rot->identify();
256  if (m_MuonIdHelper->isMdt(rot_id)) {
257  const Muon::MdtDriftCircleOnTrack* mrot = dynamic_cast<const Muon::MdtDriftCircleOnTrack*>(rot);
258  if (!mrot) {
259  ATH_MSG_DEBUG("This is not a MdtDriftCircleOnTrack!!! ");
260  return;
261  }
262  int hitType = 0;
263  if (trk_state->type(Trk::TrackStateOnSurface::Measurement)) {
264  hitType = 1;
265  }
266  else if (trk_state->type(Trk::TrackStateOnSurface::Outlier)) {
267  hitType = 4;
268  }
269  else ATH_MSG_WARNING("This hit is not measurement o outlier, hit type wrong!");
270  m_trkHit_type.push_back(hitType);
271 
272  // get PRD
273  const Muon::MdtPrepData* prd = mrot->prepRawData();
274  Identifier id = prd->identify();
275  int adc = prd->adc();
276  int tdc = prd->tdc();
277  Amg::Vector3D prd_pos = prd->globalPosition();
278  ATH_MSG_DEBUG("PRD ADC "<<adc<<" PRD TDC "<<tdc<<" PRD gPos "<<prd_pos);
279  // add the implement of calibrationTool, initialize global position by mrot
280  MdtCalibInput calibIn{*prd};
281  calibIn.setClosestApproach(mrot->globalPosition());
282  calibIn.setTrackDirection(trackPars->momentum().unit());
283  const MdtCalibOutput calibResult{m_calibrationTool->calibrate(ctx, calibIn, false)};
284  ATH_MSG_DEBUG("print "<<calibIn << " calibResult : "<<calibResult);
285  m_trkHit_tubeT0.push_back(calibResult.tubeT0());
286  m_trkHit_tubeMeanAdc.push_back(calibResult.meanAdc());
287  m_trkHit_lorTime.push_back(calibResult.lorentzTime());
288  m_trkHit_slewTime.push_back(calibResult.slewingTime());
289  m_trkHit_propTime.push_back(calibResult.signalPropagationTime());
290  m_trkHit_tempTime.push_back(calibResult.temperatureTime());
291  m_trkHit_bkgTime.push_back(calibResult.backgroundTime());
292  m_trkHit_tof.push_back(calibIn.timeOfFlight());
293  m_trkHit_triggerTime.push_back(calibIn.triggerTime());
294  m_trkHit_calibStatus.push_back(calibResult.status());
295 
296  // fill the trkHit branches
297  m_trkHit_adc.push_back(adc) ;
298  m_trkHit_tdc.push_back(tdc) ;
299  m_trkHit_trackIndex.push_back(itrk) ;
300  m_trkHit_driftTime.push_back(mrot->driftTime());
301 
302  float localAngle = mrot->localAngle() ;
303  float driftRadius = mrot->driftRadius() ;
304  float error = std::sqrt(mrot->localCovariance()(0, 0));
305  m_trkHit_error.push_back(error) ;
306  m_trkHit_localAngle.push_back(localAngle);
307  m_trkHit_driftRadius.push_back(driftRadius) ;
308 
309  const MuonGM::MdtReadoutElement* detEl = MuonDetMgr->getMdtReadoutElement(id);
310  if( !detEl ) {
311  ATH_MSG_WARNING( "getGlobalToStation failed to retrieve detEL byebye" );
312  return;
313  }
314 
315  // get the 2nd coordinator from the track hit measurement
316  Amg::Vector3D trkHitPos = trackPars->position();
317  // global to local transformation for chamber coordination
318  Amg::Transform3D gToStation = detEl->GlobalToAmdbLRSTransform();
319 
320  Amg::Vector3D trkHitPosLoc = gToStation* trkHitPos;
321  m_trkHit_closestApproach.push_back(trkHitPosLoc);
322  m_trkHit_gClosestApproach.push_back(trkHitPos);
323 
324  // get trkHit local position from measurement
325  Amg::Vector3D mrot_gPos = mrot->globalPosition(); // equal to Amg::Vector3D mb_pos = it->globalPosition();
326  Amg::Vector3D mrot_pos = gToStation* mrot_gPos;
327 
328  //distion to readout 2nd coordinators
329  float distRo_det = detEl->distanceFromRO(trkHitPos, id);
330  m_trkHit_distRO.push_back(distRo_det) ;
331 
332  // save the local postion of hit center for local refitting, set x = 0, y = coordinator along the Ntube, z = coordinator along the Nlayer
333  Amg::Vector3D wireCenter = gToStation*detEl->tubePos(id);
334  wireCenter.x() = 0;
335  ATH_MSG_DEBUG(m_MuonIdHelper->mdtIdHelper().stationNameString(int(m_MuonIdHelper->mdtIdHelper().stationName(id)))<<" "<<m_MuonIdHelper->stationEta(id)<<" "<<m_MuonIdHelper->stationPhi(id)
336  <<" "<<"ml: "<<m_MuonIdHelper->mdtIdHelper().multilayer(id)<<" lb: "<<m_MuonIdHelper->mdtIdHelper().tubeLayer(id)<<" tube: "<<m_MuonIdHelper->mdtIdHelper().tube(id)
337  << " detEl wireLocalCenter " << " x : "<<wireCenter.x()<< " y : " << wireCenter.y()<< " z : "<<wireCenter.z());
338 
339  m_trkHit_center.push_back(wireCenter);
340  m_trkHit_gPos.push_back(mrot_gPos);
341  m_trkHit_pos.push_back(mrot_pos);
342 
343  // residual calculator
344  float residualBiased = -999.;
345  float pullBiased = -999.;
346  {
347  std::optional<Trk::ResidualPull> resPullBiased = m_pullCalculator->residualPull(measurement, trackPars, Trk::ResidualPull::Biased );
348  if(resPullBiased.has_value()){
349  residualBiased = resPullBiased.value().residual().front();
350  pullBiased = resPullBiased.value().pull().front();
351  }
352  }
353  // residual definition double residual = measurement->localParameters()[Trk::loc1] - trkPar->parameters()[Trk::loc1];
354  m_trkHit_resi.push_back(residualBiased) ;
355  m_trkHit_pull.push_back(pullBiased) ;
356  m_trkHit_rTrk.push_back(trackPars->parameters()[Trk::loc1]) ;
357 
358  MuonFixedId fixid = m_idToFixedIdTool->idToFixedId(id);
359  m_trkHit_id.push_back(fixid.getIdInt()) ;
360 
361  // debugging printout
362  ATH_MSG_DEBUG("trackHit distRO " << distRo_det<<" positionAlongWire "<<mrot->positionAlongWire()<<" tubeLength "<<detEl->tubeLength(id));
363  ATH_MSG_DEBUG("prd hit global position measurement " <<" x : "<< prd_pos.x()<<" y : "<< prd_pos.y()<<" z : "<<prd_pos.z());
364  ATH_MSG_DEBUG("MdtDriftCircleOnTrack hit global position measurement " << " x : " <<mrot_gPos.x()<<" y : "<< mrot_gPos.y() <<" z : "<<mrot_gPos.z());
365  ATH_MSG_DEBUG("trackHitPos from trackPars " << " x : "<<trkHitPos.x() <<" y : "<<trkHitPos.y() <<" z : "<< trkHitPos.z() );
366  ATH_MSG_DEBUG("trackHit Local Pos from globaltolocalCoords " <<" x : "<< trkHitPosLoc.x() <<" y : "<< trkHitPosLoc.y() <<" z : "<< trkHitPosLoc.z());
367  ATH_MSG_DEBUG("mrod Local Pos from globaltolocalCoords " <<" x : "<< mrot_pos.x() <<" y : "<< mrot_pos.y() <<" z : "<< mrot_pos.z());
368  ATH_MSG_DEBUG("TrackIndex "<<itrk<<" station " << fixid.stationNumberToFixedStationString(fixid.stationName()) << " eta " << fixid.eta() << " phi " << fixid.phi() << " ML " << fixid.mdtMultilayer() << " Layer " << fixid.mdtTubeLayer()
369  <<" Tube "<<fixid.mdtTube()<< " MROT drift R " << mrot->driftRadius() << " errDriftRadius " << error<< " drift Time "
370  << mrot->driftTime() <<" ADC "<<adc<<" TDC "<<tdc);
371  ATH_MSG_DEBUG(" driftRadius from driftRadius func "<<driftRadius<<" rTrk track fit to wire "<<trackPars->parameters()[Trk::loc1]<<" residualBiased " << residualBiased << " pullBiased " << pullBiased);
372 
373  } // finish mdt hit loop
374 
375  else if (m_MuonIdHelper->isRpc(rot_id)) {
376 
377  ATH_MSG_DEBUG("Found the RPC ROT "<<rot_id<<" !");
378  MuonFixedId fixid = m_idToFixedIdTool->idToFixedId(rot_id);
379  m_trkTriggerHit_id.push_back(fixid.getIdInt()) ;
380  m_trkTriggerHit_trackIndex.push_back(itrk);
381  m_trkTriggerHit_type.push_back(1); // RPC ROT
382  const Muon::RpcClusterOnTrack* rpc = dynamic_cast<const Muon::RpcClusterOnTrack*>(rot);
383  const Muon::RpcPrepData* rpcPRD = rpc->prepRawData();
384  m_trkTriggerHit_time.push_back(rpcPRD->time());
385  m_trkTriggerHit_gPos.push_back(rpcPRD->globalPosition());
386 
387  } // end of RPC rot
388  else if (m_MuonIdHelper->isTgc(rot_id)) {
389 
390  ATH_MSG_DEBUG("Found the TGC ROT "<<rot_id<<" !");
391  MuonFixedId fixid = m_idToFixedIdTool->idToFixedId(rot_id);
392  m_trkTriggerHit_id.push_back(fixid.getIdInt()) ;
393  m_trkTriggerHit_trackIndex.push_back(itrk);
394  m_trkTriggerHit_type.push_back(3); // tgc ROT
395  const Muon::TgcClusterOnTrack* tgc = dynamic_cast<const Muon::TgcClusterOnTrack*>(rot);
396  const Muon::TgcPrepData* tgcPRD = tgc->prepRawData() ;
397  m_trkTriggerHit_time.push_back(tgcPRD->getBcBitMap());
398  m_trkTriggerHit_gPos.push_back(tgcPRD->globalPosition());
399 
400  } //end of TGC rot
401  else {
402  ATH_MSG_DEBUG("Couldn't find track ROT ID "<<rot_id);
403  }
404 
405  } // end of rot case
406  else {
407  ATH_MSG_DEBUG("No ROT! Check the competingROT");
408  // use competingROT from RPC and TGC
409  const Muon::CompetingMuonClustersOnTrack* crot = dynamic_cast<const Muon::CompetingMuonClustersOnTrack*>(measurement);
410  if (crot) {
411  const std::vector<const Muon::MuonClusterOnTrack*>& rots = crot->containedROTs();
412  if (rots.size() > 0) {
413  std::vector<const Muon::MuonClusterOnTrack*>::const_iterator itR = rots.begin(), itR_end = rots.end();
414  for (; itR != itR_end; ++itR) {
415  Identifier crot_id = (*itR)->identify() ;
416  MuonFixedId fixid = m_idToFixedIdTool->idToFixedId(crot_id);
417  m_trkTriggerHit_id.push_back(fixid.getIdInt());
418  m_trkTriggerHit_trackIndex.push_back(itrk);
419  if (m_MuonIdHelper->isTgc(crot_id)) {
420  ATH_MSG_DEBUG("This is TGC competing hits on track!") ;
421  if (m_MuonIdHelper->tgcIdHelper().isStrip(crot_id)) m_trkTriggerHit_type.push_back(5); // tgc strip hit, measuresPhi
422  else m_trkTriggerHit_type.push_back(4); // tgc wire hit
423  const Muon::TgcClusterOnTrack* tgc = dynamic_cast<const Muon::TgcClusterOnTrack*>(*itR);
424  const Muon::TgcPrepData* tgcPRD = tgc ? tgc->prepRawData() : nullptr;
425  if (tgcPRD) {
426  m_trkTriggerHit_time.push_back(tgcPRD->getBcBitMap());
427  m_trkTriggerHit_gPos.push_back(tgcPRD->globalPosition());
428  }
429  else {
430  m_trkTriggerHit_time.push_back(0);
431  m_trkTriggerHit_gPos.push_back(Amg::Vector3D(0,0,0));
432  }
433  } // tgc case
434  else if (m_MuonIdHelper->isRpc(crot_id)) {
435  ATH_MSG_DEBUG("This is RPC competing hits on track!") ;
436  m_trkTriggerHit_type.push_back(2);
437  const Muon::RpcClusterOnTrack* rpc = dynamic_cast<const Muon::RpcClusterOnTrack*>(*itR);
438  const Muon::RpcPrepData* rpcPRD = rpc ? rpc->prepRawData() : nullptr;
439  if (rpcPRD) {
440  m_trkTriggerHit_time.push_back(rpcPRD->time());
441  m_trkTriggerHit_gPos.push_back(rpcPRD->globalPosition());
442  }
443  else {
444  m_trkTriggerHit_time.push_back(0);
445  m_trkTriggerHit_gPos.push_back(Amg::Vector3D(0,0,0));
446  } // rpc case
447  } // rpc case
448  else {
449  m_trkTriggerHit_type.push_back(0);
450  m_trkTriggerHit_time.push_back(0);
451  m_trkTriggerHit_gPos.push_back(Amg::Vector3D(0,0,0));
452  }
453  } // end of crots loop
454  } // end of crots size check
455  } // end of crot check
456  } // end of CompetingROT
457 } // end of store measurement

◆ sysInitialize()

StatusCode AthHistogramAlgorithm::sysInitialize ( )
virtualinherited

Initialization method invoked by the framework.

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

Reimplemented from AthAlgorithm.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 75 of file AthHistogramAlgorithm.cxx.

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

◆ sysStart()

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

Handle START transition.

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

◆ tree()

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

Simplify the retrieval of registered TTrees.

Definition at line 378 of file AthHistogramming.cxx.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_bcId

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_bcId {m_tree.newScalar<int>("event_bcId")}
private

Definition at line 98 of file MuonSegmentReader.h.

◆ m_calibrationTool

ToolHandle<IMdtCalibrationTool> MuonCalib::MuonSegmentReader::m_calibrationTool {this, "CalibrationTool", "MdtCalibrationTool"}
private

pointer to MdtCalibSvc

Definition at line 84 of file MuonSegmentReader.h.

◆ m_DetectorManagerKey

SG::ReadCondHandleKey<MuonGM::MuonDetectorManager> MuonCalib::MuonSegmentReader::m_DetectorManagerKey
private
Initial value:
{this, "DetectorManagerKey", "MuonDetectorManager",
"Key of input MuonDetectorManager condition data"}

Definition at line 77 of file MuonSegmentReader.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_effMap

EffMap_t AthHistogramming::m_effMap
privateinherited

The map of histogram names to their pointers.

Definition at line 208 of file AthHistogramming.h.

◆ m_eventNumber

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_eventNumber {m_tree.newScalar<int>("event_eventNumber")}
private

Definition at line 96 of file MuonSegmentReader.h.

◆ m_evtKey

SG::ReadHandleKey<xAOD::EventInfo> MuonCalib::MuonSegmentReader::m_evtKey {this, "EventInfoKey", "EventInfo", "xAOD::EventInfo ReadHandleKey"}
private

Definition at line 67 of file MuonSegmentReader.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_graphMap

GraphMap_t AthHistogramming::m_graphMap
privateinherited

The map of TGraph names to their pointers.

Definition at line 222 of file AthHistogramming.h.

◆ m_histMap

HistMap_t AthHistogramming::m_histMap
privateinherited

The map of histogram names to their pointers.

Definition at line 201 of file AthHistogramming.h.

◆ m_histNamePostfix

std::string AthHistogramAlgorithm::m_histNamePostfix
privateinherited

The postfix for the histogram THx name.

Definition at line 97 of file AthHistogramAlgorithm.h.

◆ m_histNamePrefix

std::string AthHistogramAlgorithm::m_histNamePrefix
privateinherited

The prefix for the histogram THx name.

Definition at line 94 of file AthHistogramAlgorithm.h.

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

ToolHandle<MuonCalib::IIdToFixedIdTool> MuonCalib::MuonSegmentReader::m_idToFixedIdTool {this, "IdToFixedIdTool", "MuonCalib::IdToFixedIdTool/MuonCalib_IdToFixedIdTool"}
private

Definition at line 89 of file MuonSegmentReader.h.

◆ m_lumiBlock

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_lumiBlock {m_tree.newScalar<int>("event_lumiBlock")}
private

Definition at line 97 of file MuonSegmentReader.h.

◆ m_MdtPrepDataKey

SG::ReadHandleKey<Muon::MdtPrepDataContainer> MuonCalib::MuonSegmentReader::m_MdtPrepDataKey {this, "MdtPrepData", "MDT_DriftCircles","MDT DriftCircles"}
private

Definition at line 72 of file MuonSegmentReader.h.

◆ m_msg

MsgStream AthHistogramming::m_msg
privateinherited

Cached Message Stream.

Definition at line 248 of file AthHistogramming.h.

◆ m_MuonIdHelper

ServiceHandle<Muon::IMuonIdHelperSvc> MuonCalib::MuonSegmentReader::m_MuonIdHelper
private
Initial value:
{this, "MuonIdHelper", "Muon::MuonIdHelperSvc/MuonIdHelperSvc",
"Handle to the MuonIdHelperSvc"}

Definition at line 80 of file MuonSegmentReader.h.

◆ m_name

std::string AthHistogramming::m_name
privateinherited

Instance name.

Definition at line 245 of file AthHistogramming.h.

◆ m_prefix

std::string AthHistogramAlgorithm::m_prefix
privateinherited

Name of the ROOT output stream (file)

Definition at line 88 of file AthHistogramAlgorithm.h.

◆ m_printer

PublicToolHandle<Muon::MuonEDMPrinterTool> MuonCalib::MuonSegmentReader::m_printer {this, "Printer", "Muon::MuonEDMPrinterTool/MuonEDMPrinterTool"}
private

Definition at line 91 of file MuonSegmentReader.h.

◆ m_pt

ScalarBranch<float>& MuonCalib::MuonSegmentReader::m_pt {m_tree.newScalar<float>("event_LVL2Pt")}
private

Definition at line 100 of file MuonSegmentReader.h.

◆ m_pullCalculator

PublicToolHandle<Trk::IResidualPullCalculator> MuonCalib::MuonSegmentReader::m_pullCalculator
private
Initial value:
{this, "PullCalculator",
"Trk::ResidualPullCalculator/ResidualPullCalculator"}

Definition at line 86 of file MuonSegmentReader.h.

◆ m_rawMdt_adc

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_rawMdt_adc {m_tree.newVector<int>("rawMdt_adc")}
private

Definition at line 108 of file MuonSegmentReader.h.

◆ m_rawMdt_gPos

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_rawMdt_gPos {m_tree,"rawMdt_gPos"}
private

Definition at line 109 of file MuonSegmentReader.h.

◆ m_rawMdt_id

VectorBranch<unsigned int>& MuonCalib::MuonSegmentReader::m_rawMdt_id {m_tree.newVector<unsigned int>("rawMdt_id")}
private

Definition at line 106 of file MuonSegmentReader.h.

◆ m_rawMdt_nRMdt

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_rawMdt_nRMdt {m_tree.newScalar<int>("rawMdt_nRMdt")}
private

Definition at line 105 of file MuonSegmentReader.h.

◆ m_rawMdt_tdc

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_rawMdt_tdc {m_tree.newVector<int>("rawMdt_tdc")}
private

Definition at line 107 of file MuonSegmentReader.h.

◆ m_rawRpc_gPos

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_rawRpc_gPos {m_tree,"rawRpc_gPos"}
private

Definition at line 115 of file MuonSegmentReader.h.

◆ m_rawRpc_id

VectorBranch<unsigned int>& MuonCalib::MuonSegmentReader::m_rawRpc_id {m_tree.newVector<unsigned int>("rawRpc_id")}
private

Definition at line 113 of file MuonSegmentReader.h.

◆ m_rawRpc_nRRpc

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_rawRpc_nRRpc {m_tree.newScalar<int>("rawRpc_nRRpc")}
private

Definition at line 112 of file MuonSegmentReader.h.

◆ m_rawRpc_time

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_rawRpc_time {m_tree.newVector<float>("rawRpc_time")}
private

Definition at line 114 of file MuonSegmentReader.h.

◆ m_rawTgc_bcBitMap

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_rawTgc_bcBitMap {m_tree.newVector<int>("rawTgc_bcBitMap")}
private

Definition at line 120 of file MuonSegmentReader.h.

◆ m_rawTgc_gPos

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_rawTgc_gPos {m_tree,"rawTgc_gPos"}
private

Definition at line 121 of file MuonSegmentReader.h.

◆ m_rawTgc_id

VectorBranch<unsigned int>& MuonCalib::MuonSegmentReader::m_rawTgc_id {m_tree.newVector<unsigned int>("rawTgc_id")}
private

Definition at line 119 of file MuonSegmentReader.h.

◆ m_rawTgc_nRTgc

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_rawTgc_nRTgc {m_tree.newScalar<int>("rawTgc_nRTgc")}
private

Definition at line 118 of file MuonSegmentReader.h.

◆ m_rootDir

std::string AthHistogramAlgorithm::m_rootDir
privateinherited

Name of the ROOT directory.

Definition at line 91 of file AthHistogramAlgorithm.h.

◆ m_RpcPrepDataKey

SG::ReadHandleKey<Muon::RpcPrepDataContainer> MuonCalib::MuonSegmentReader::m_RpcPrepDataKey {this,"RpcPrdCollection","RPC_Measurements","RPC PRD Container"}
private

Definition at line 73 of file MuonSegmentReader.h.

◆ m_runNumber

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_runNumber {m_tree.newScalar<int>("event_runNumber")}
private

Definition at line 95 of file MuonSegmentReader.h.

◆ m_streamName

std::string AthHistogramming::m_streamName
privateinherited

Name of the ROOT output stream (file)

Definition at line 226 of file AthHistogramming.h.

◆ m_TgcPrepDataKey

SG::ReadHandleKey<Muon::TgcPrepDataContainer> MuonCalib::MuonSegmentReader::m_TgcPrepDataKey {this,"TgcPrdCollection","TGC_Measurements","TGC PRD Container"}
private

Definition at line 74 of file MuonSegmentReader.h.

◆ m_timeStamp

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_timeStamp {m_tree.newScalar<int>("event_timeStamp")}
private

Definition at line 99 of file MuonSegmentReader.h.

◆ m_tree

MuonTesterTree MuonCalib::MuonSegmentReader::m_tree {"Segments", "CALIBNTUPLESTREAM"}
private

Definition at line 93 of file MuonSegmentReader.h.

◆ m_treeMap

TreeMap_t AthHistogramming::m_treeMap
privateinherited

The map of TTree names to their pointers.

Definition at line 215 of file AthHistogramming.h.

◆ m_trk_author

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_author {m_tree.newVector<int>("trk_author")}
private

Definition at line 134 of file MuonSegmentReader.h.

◆ m_trk_chi2

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trk_chi2 {m_tree.newVector<float>("trk_chi2")}
private

Definition at line 132 of file MuonSegmentReader.h.

◆ m_trk_d0

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trk_d0 {m_tree.newVector<float>("trk_d0")}
private

Definition at line 125 of file MuonSegmentReader.h.

◆ m_trk_eta

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trk_eta {m_tree.newVector<float>("trk_eta")}
private

Definition at line 129 of file MuonSegmentReader.h.

◆ m_trk_ndof

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_ndof {m_tree.newVector<int>("trk_ndof")}
private

Definition at line 133 of file MuonSegmentReader.h.

◆ m_trk_nMdtHits

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_nMdtHits {m_tree.newVector<int>("trk_nMdtHits")}
private

Definition at line 137 of file MuonSegmentReader.h.

◆ m_trk_nMdtHoles

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_nMdtHoles {m_tree.newVector<int>("trk_nMdtHoles")}
private

Definition at line 138 of file MuonSegmentReader.h.

◆ m_trk_nOutliersHits

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_nOutliersHits {m_tree.newVector<int>("trk_nOutliersHits")}
private

Definition at line 139 of file MuonSegmentReader.h.

◆ m_trk_nRpcEtaHits

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_nRpcEtaHits {m_tree.newVector<int>("trk_nRpcEtaHits")}
private

Definition at line 141 of file MuonSegmentReader.h.

◆ m_trk_nRpcPhiHits

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_nRpcPhiHits {m_tree.newVector<int>("trk_nRpcPhiHits")}
private

Definition at line 140 of file MuonSegmentReader.h.

◆ m_trk_nTgcEtaHits

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_nTgcEtaHits {m_tree.newVector<int>("trk_nTgcEtaHits")}
private

Definition at line 143 of file MuonSegmentReader.h.

◆ m_trk_nTgcPhiHits

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trk_nTgcPhiHits {m_tree.newVector<int>("trk_nTgcPhiHits")}
private

Definition at line 142 of file MuonSegmentReader.h.

◆ m_trk_nTracks

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_trk_nTracks {m_tree.newScalar<int>("trk_nTracks")}
private

Definition at line 124 of file MuonSegmentReader.h.

◆ m_trk_perigee

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_trk_perigee {m_tree,"trk_perigee"}
private

Definition at line 135 of file MuonSegmentReader.h.

◆ m_trk_phi

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trk_phi {m_tree.newVector<float>("trk_phi")}
private

Definition at line 127 of file MuonSegmentReader.h.

◆ m_trk_pt

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trk_pt {m_tree.newVector<float>("trk_pt")}
private

Definition at line 131 of file MuonSegmentReader.h.

◆ m_trk_qOverP

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trk_qOverP {m_tree.newVector<float>("trk_qOverP")}
private

Definition at line 130 of file MuonSegmentReader.h.

◆ m_trk_theta

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trk_theta {m_tree.newVector<float>("trk_theta")}
private

Definition at line 128 of file MuonSegmentReader.h.

◆ m_trk_z0

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trk_z0 {m_tree.newVector<float>("trk_z0")}
private

Definition at line 126 of file MuonSegmentReader.h.

◆ m_trkHit_adc

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkHit_adc {m_tree.newVector<int>("trkHit_adc")}
private

Definition at line 154 of file MuonSegmentReader.h.

◆ m_trkHit_bkgTime

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_bkgTime {m_tree.newVector<float>("trkHit_bkgTime")}
private

Definition at line 175 of file MuonSegmentReader.h.

◆ m_trkHit_calibStatus

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkHit_calibStatus {m_tree.newVector<int>("trkHit_calibStatus")}
private

Definition at line 177 of file MuonSegmentReader.h.

◆ m_trkHit_center

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_trkHit_center {m_tree,"trkHit_center"}
private

Definition at line 152 of file MuonSegmentReader.h.

◆ m_trkHit_closestApproach

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_trkHit_closestApproach {m_tree,"trkHit_closestApproach"}
private

Definition at line 150 of file MuonSegmentReader.h.

◆ m_trkHit_distRO

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_distRO {m_tree.newVector<float>("trkHit_distRO")}
private

Definition at line 164 of file MuonSegmentReader.h.

◆ m_trkHit_driftRadius

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_driftRadius {m_tree.newVector<float>("trkHit_driftRadius")}
private

Definition at line 160 of file MuonSegmentReader.h.

◆ m_trkHit_driftTime

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_driftTime {m_tree.newVector<float>("trkHit_driftTime")}
private

Definition at line 163 of file MuonSegmentReader.h.

◆ m_trkHit_error

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_error {m_tree.newVector<float>("trkHit_error")}
private

Definition at line 161 of file MuonSegmentReader.h.

◆ m_trkHit_gClosestApproach

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_trkHit_gClosestApproach {m_tree,"trkHit_gClosestApproach"}
private

Definition at line 151 of file MuonSegmentReader.h.

◆ m_trkHit_gPos

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_trkHit_gPos {m_tree,"trkHit_gPos"}
private

Definition at line 148 of file MuonSegmentReader.h.

◆ m_trkHit_id

VectorBranch<unsigned int>& MuonCalib::MuonSegmentReader::m_trkHit_id {m_tree.newVector<unsigned int>("trkHit_id")}
private

Definition at line 159 of file MuonSegmentReader.h.

◆ m_trkHit_localAngle

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_localAngle {m_tree.newVector<float>("trkHit_localAngle")}
private

Definition at line 165 of file MuonSegmentReader.h.

◆ m_trkHit_lorTime

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_lorTime {m_tree.newVector<float>("trkHit_lorTime")}
private

Definition at line 172 of file MuonSegmentReader.h.

◆ m_trkHit_nMdtHits

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_trkHit_nMdtHits {m_tree.newScalar<int>("trkHit_nMdtHits")}
private

Definition at line 146 of file MuonSegmentReader.h.

◆ m_trkHit_pos

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_trkHit_pos {m_tree,"trkHit_pos"}
private

Definition at line 149 of file MuonSegmentReader.h.

◆ m_trkHit_propTime

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_propTime {m_tree.newVector<float>("trkHit_propTime")}
private

Definition at line 173 of file MuonSegmentReader.h.

◆ m_trkHit_pull

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_pull {m_tree.newVector<float>("trkHit_pull")}
private

Definition at line 158 of file MuonSegmentReader.h.

◆ m_trkHit_resi

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_resi {m_tree.newVector<float>("trkHit_resi")}
private

Definition at line 157 of file MuonSegmentReader.h.

◆ m_trkHit_rTrk

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_rTrk {m_tree.newVector<float>("trkHit_rTrk")}
private

Definition at line 162 of file MuonSegmentReader.h.

◆ m_trkHit_slewTime

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_slewTime {m_tree.newVector<float>("trkHit_slewTime")}
private

Definition at line 171 of file MuonSegmentReader.h.

◆ m_trkHit_tdc

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkHit_tdc {m_tree.newVector<int>("trkHit_tdc")}
private

Definition at line 156 of file MuonSegmentReader.h.

◆ m_trkHit_tempTime

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_tempTime {m_tree.newVector<float>("trkHit_tempTime")}
private

Definition at line 174 of file MuonSegmentReader.h.

◆ m_trkHit_tof

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_tof {m_tree.newVector<float>("trkHit_tof")}
private

Definition at line 176 of file MuonSegmentReader.h.

◆ m_trkHit_trackIndex

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkHit_trackIndex {m_tree.newVector<int>("trkHit_trackIndex")}
private

Definition at line 147 of file MuonSegmentReader.h.

◆ m_trkHit_triggerTime

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_triggerTime {m_tree.newVector<float>("trkHit_triggerTime")}
private

Definition at line 169 of file MuonSegmentReader.h.

◆ m_trkHit_tubeMeanAdc

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_tubeMeanAdc {m_tree.newVector<float>("trkHit_tubeMeanAdc")}
private

Definition at line 170 of file MuonSegmentReader.h.

◆ m_trkHit_tubeT0

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHit_tubeT0 {m_tree.newVector<float>("trkHit_tubeT0")}
private

Definition at line 168 of file MuonSegmentReader.h.

◆ m_trkHit_type

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkHit_type {m_tree.newVector<int>("trkHit_type")}
private

Definition at line 155 of file MuonSegmentReader.h.

◆ m_trkHole_driftRadius

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkHole_driftRadius {m_tree.newVector<float>("trkHole_driftRadius")}
private

Definition at line 185 of file MuonSegmentReader.h.

◆ m_trkHole_gPos

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_trkHole_gPos {m_tree,"trkHole_gPos"}
private

Definition at line 183 of file MuonSegmentReader.h.

◆ m_trkHole_id

VectorBranch<unsigned int>& MuonCalib::MuonSegmentReader::m_trkHole_id {m_tree.newVector<unsigned int>("trkHole_id")}
private

Definition at line 184 of file MuonSegmentReader.h.

◆ m_trkHole_nHoles

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_trkHole_nHoles {m_tree.newScalar<int>("trkHole_nHoles")}
private

Definition at line 180 of file MuonSegmentReader.h.

◆ m_trkHole_trackIndex

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkHole_trackIndex {m_tree.newVector<int>("trkHole_trackIndex")}
private

Definition at line 181 of file MuonSegmentReader.h.

◆ m_trkHole_type

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkHole_type {m_tree.newVector<int>("trkHole_type")}
private

Definition at line 182 of file MuonSegmentReader.h.

◆ m_TrkKey

SG::ReadHandleKey<TrackCollection> MuonCalib::MuonSegmentReader::m_TrkKey {this, "MuonTrackLocations", "MuonSpectrometerTracks"}
private

Definition at line 70 of file MuonSegmentReader.h.

◆ m_trkTriggerHit_gPos

ThreeVectorBranch MuonCalib::MuonSegmentReader::m_trkTriggerHit_gPos {m_tree,"trkTriggerHit_gPos"}
private

Definition at line 191 of file MuonSegmentReader.h.

◆ m_trkTriggerHit_id

VectorBranch<unsigned int>& MuonCalib::MuonSegmentReader::m_trkTriggerHit_id {m_tree.newVector<unsigned int>("trkTriggerHit_id")}
private

Definition at line 192 of file MuonSegmentReader.h.

◆ m_trkTriggerHit_nHits

ScalarBranch<int>& MuonCalib::MuonSegmentReader::m_trkTriggerHit_nHits {m_tree.newScalar<int>("trkTriggerHit_nHits")}
private

Definition at line 188 of file MuonSegmentReader.h.

◆ m_trkTriggerHit_time

VectorBranch<float>& MuonCalib::MuonSegmentReader::m_trkTriggerHit_time {m_tree.newVector<float>("trkTriggerHit_time")}
private

Definition at line 193 of file MuonSegmentReader.h.

◆ m_trkTriggerHit_trackIndex

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkTriggerHit_trackIndex {m_tree.newVector<int>("trkTriggerHit_trackIndex")}
private

Definition at line 189 of file MuonSegmentReader.h.

◆ m_trkTriggerHit_type

VectorBranch<int>& MuonCalib::MuonSegmentReader::m_trkTriggerHit_type {m_tree.newVector<int>("trkTriggerHit_type")}
private

Definition at line 190 of file MuonSegmentReader.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
AthHistogramming::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition: AthHistogramming.h:229
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
AthHistogramming::histSvc
const ServiceHandle< ITHistSvc > & histSvc() const
The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a...
Definition: AthHistogramming.h:421
MuonCalib::MuonSegmentReader::storeMeasurement
void storeMeasurement(const EventContext &ctx, const MuonGM::MuonDetectorManager *MuonDetMgr, unsigned int itrk, const Trk::TrackStateOnSurface *trk_state, const Trk::MeasurementBase *measurement)
Definition: MuonSegmentReader.cxx:249
AthHistogramAlgorithm::histSvc
const ServiceHandle< ITHistSvc > & histSvc() const
The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a...
Definition: AthHistogramAlgorithm.h:113
MuonCalib::MuonSegmentReader::m_trkHit_trackIndex
VectorBranch< int > & m_trkHit_trackIndex
Definition: MuonSegmentReader.h:147
MuonCalib::MuonSegmentReader::m_trkHole_type
VectorBranch< int > & m_trkHole_type
Definition: MuonSegmentReader.h:182
Trk::TrackStateOnSurface::trackParameters
const TrackParameters * trackParameters() const
return ptr to trackparameters const overload
MuonCalib::MuonSegmentReader::m_rawTgc_bcBitMap
VectorBranch< int > & m_rawTgc_bcBitMap
Definition: MuonSegmentReader.h:120
MuonCalib::MuonSegmentReader::m_rawMdt_gPos
ThreeVectorBranch m_rawMdt_gPos
Definition: MuonSegmentReader.h:109
MuonCalib::MuonSegmentReader::m_trk_perigee
ThreeVectorBranch m_trk_perigee
Definition: MuonSegmentReader.h:135
AthHistogramming::myReplace
void myReplace(std::string &str, const std::string &oldStr, const std::string &newStr)
Helper method to replace sub-string.
Definition: AthHistogramming.cxx:590
AthHistogramming::m_msg
MsgStream m_msg
Cached Message Stream.
Definition: AthHistogramming.h:248
MuonCalib::MuonSegmentReader::m_rawRpc_nRRpc
ScalarBranch< int > & m_rawRpc_nRRpc
Definition: MuonSegmentReader.h:112
Trk::Track::fitQuality
const FitQuality * fitQuality() const
return a pointer to the fit quality const-overload
AthHistogramming::m_histMap
HistMap_t m_histMap
The map of histogram names to their pointers.
Definition: AthHistogramming.h:201
Trk::numberOfMdtHoles
@ numberOfMdtHoles
number of MDT measurements missing from the track
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:120
MuonGM::MdtReadoutElement::tubeLength
double tubeLength(const int tubeLayer, const int tube) const
MuonCalib::MuonSegmentReader::m_trk_nTracks
ScalarBranch< int > & m_trk_nTracks
Definition: MuonSegmentReader.h:124
MuonCalib::MuonSegmentReader::m_trk_nTgcPhiHits
VectorBranch< int > & m_trk_nTgcPhiHits
Definition: MuonSegmentReader.h:142
AddEmptyComponent.histName
string histName
Definition: AddEmptyComponent.py:64
AthHistogramAlgorithm::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Default constructor: AthHistogramAlgorithm();.
Definition: AthHistogramAlgorithm.h:83
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Muon::MdtDriftCircleOnTrack::prepRawData
virtual const MdtPrepData * prepRawData() const override final
Returns the PrepRawData used to create this corrected measurement.
Definition: MdtDriftCircleOnTrack.h:257
MuonVal::MuonTesterTree::init
StatusCode init(OWNER *instance)
Initialize method.
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
MdtCalibInput
Definition: MdtCalibInput.h:35
MuonCalib::MuonSegmentReader::m_rawRpc_id
VectorBranch< unsigned int > & m_rawRpc_id
Definition: MuonSegmentReader.h:113
AthHistogramming::book
StatusCode book(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition: AthHistogramming.h:303
MuonCalib::MuonSegmentReader::m_rawRpc_gPos
ThreeVectorBranch m_rawRpc_gPos
Definition: MuonSegmentReader.h:115
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
MuonCalib::MuonSegmentReader::m_rawTgc_nRTgc
ScalarBranch< int > & m_rawTgc_nRTgc
Definition: MuonSegmentReader.h:118
MuonCalib::MuonSegmentReader::m_trkHit_rTrk
VectorBranch< float > & m_trkHit_rTrk
Definition: MuonSegmentReader.h:162
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
Trk::ParametersBase::associatedSurface
virtual const Surface & associatedSurface() const override=0
Access to the Surface associated to the Parameters.
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Muon::RpcPrepData::globalPosition
virtual const Amg::Vector3D & globalPosition() const override
Returns the global position.
Definition: RpcPrepData.h:218
Trk::Track::trackStateOnSurfaces
const Trk::TrackStates * trackStateOnSurfaces() const
return a pointer to a const DataVector of const TrackStateOnSurfaces.
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
MuonCalib::MuonSegmentReader::m_MdtPrepDataKey
SG::ReadHandleKey< Muon::MdtPrepDataContainer > m_MdtPrepDataKey
Definition: MuonSegmentReader.h:72
Trk::Surface::associatedDetectorElementIdentifier
Identifier associatedDetectorElementIdentifier() const
return Identifier of the associated Detector Element
MuonCalib::MuonSegmentReader::storeHole
void storeHole(const Trk::TrackStateOnSurface *trk_state, unsigned int itrk)
Definition: MuonSegmentReader.cxx:223
MuonCalib::MuonSegmentReader::m_rawTgc_id
VectorBranch< unsigned int > & m_rawTgc_id
Definition: MuonSegmentReader.h:119
MuonGM::MuonReadoutElement::GlobalToAmdbLRSTransform
virtual Amg::Transform3D GlobalToAmdbLRSTransform() const
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonReadoutElement.cxx:153
MuonCalib::MuonSegmentReader::m_TgcPrepDataKey
SG::ReadHandleKey< Muon::TgcPrepDataContainer > m_TgcPrepDataKey
Definition: MuonSegmentReader.h:74
MuonCalib::MuonSegmentReader::m_trkHit_resi
VectorBranch< float > & m_trkHit_resi
Definition: MuonSegmentReader.h:157
MuonCalib::MuonSegmentReader::m_trk_qOverP
VectorBranch< float > & m_trk_qOverP
Definition: MuonSegmentReader.h:130
skel.it
it
Definition: skel.GENtoEVGEN.py:396
MuonCalib::MuonSegmentReader::m_trkTriggerHit_trackIndex
VectorBranch< int > & m_trkTriggerHit_trackIndex
Definition: MuonSegmentReader.h:189
MuonCalib::MuonSegmentReader::m_trkHole_driftRadius
VectorBranch< float > & m_trkHole_driftRadius
Definition: MuonSegmentReader.h:185
MuonCalib::MuonSegmentReader::m_trkTriggerHit_nHits
ScalarBranch< int > & m_trkTriggerHit_nHits
Definition: MuonSegmentReader.h:188
AthHistogramAlgorithm::m_prefix
std::string m_prefix
Name of the ROOT output stream (file)
Definition: AthHistogramAlgorithm.h:88
Muon::TgcClusterOnTrack
Class to represent calibrated clusters formed from TGC strips.
Definition: TgcClusterOnTrack.h:46
MuonCalib::MuonSegmentReader::m_trkHit_distRO
VectorBranch< float > & m_trkHit_distRO
Definition: MuonSegmentReader.h:164
MuonCalib::MuonSegmentReader::m_trkHit_localAngle
VectorBranch< float > & m_trkHit_localAngle
Definition: MuonSegmentReader.h:165
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
MuonCalib::MuonSegmentReader::m_pullCalculator
PublicToolHandle< Trk::IResidualPullCalculator > m_pullCalculator
Definition: MuonSegmentReader.h:86
Trk::z0
@ z0
Definition: ParamDefs.h:64
MuonCalib::MuonSegmentReader::m_rawRpc_time
VectorBranch< float > & m_rawRpc_time
Definition: MuonSegmentReader.h:114
MuonCalib::MuonSegmentReader::m_lumiBlock
ScalarBranch< int > & m_lumiBlock
Definition: MuonSegmentReader.h:97
AthHistogramAlgorithm::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition: AthHistogramAlgorithm.h:94
MuonCalib::MuonSegmentReader::m_trkHit_tempTime
VectorBranch< float > & m_trkHit_tempTime
Definition: MuonSegmentReader.h:174
MuonCalib::MuonSegmentReader::m_trkHit_gClosestApproach
ThreeVectorBranch m_trkHit_gClosestApproach
Definition: MuonSegmentReader.h:151
Trk::RIO_OnTrack
Definition: RIO_OnTrack.h:70
Trk::numberOfOutliersOnTrack
@ numberOfOutliersOnTrack
100 times the standard deviation of the chi2 from the surfaces
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:148
AthHistogramAlgorithm::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition: AthHistogramAlgorithm.h:100
MuonCalib::MuonSegmentReader::m_DetectorManagerKey
SG::ReadCondHandleKey< MuonGM::MuonDetectorManager > m_DetectorManagerKey
Definition: MuonSegmentReader.h:77
Muon::RpcClusterOnTrack
Class to represent calibrated clusters formed from RPC strips.
Definition: RpcClusterOnTrack.h:35
Trk::numberOfTgcPhiHits
@ numberOfTgcPhiHits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:105
Trk::locR
@ locR
Definition: ParamDefs.h:44
MuonCalib::MuonSegmentReader::m_trk_nMdtHits
VectorBranch< int > & m_trk_nMdtHits
Definition: MuonSegmentReader.h:137
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
MuonCalib::MuonSegmentReader::m_trk_nRpcEtaHits
VectorBranch< int > & m_trk_nRpcEtaHits
Definition: MuonSegmentReader.h:141
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Muon::CompetingMuonClustersOnTrack
Definition: CompetingMuonClustersOnTrack.h:54
MuonCalib::MuonSegmentReader::m_trkHit_tubeMeanAdc
VectorBranch< float > & m_trkHit_tubeMeanAdc
Definition: MuonSegmentReader.h:170
Muon::MdtPrepData::adc
int adc() const
Returns the ADC (typically range is 0 to 250)
Definition: MdtPrepData.h:146
MuonCalib::MuonSegmentReader::m_trkHit_tubeT0
VectorBranch< float > & m_trkHit_tubeT0
Definition: MuonSegmentReader.h:168
MuonCalib::MuonSegmentReader::m_trkHit_type
VectorBranch< int > & m_trkHit_type
Definition: MuonSegmentReader.h:155
AthHistogramming::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition: AthHistogramming.h:235
MuonCalib::MuonSegmentReader::m_tree
MuonTesterTree m_tree
Definition: MuonSegmentReader.h:93
MuonCalib::MuonSegmentReader::m_rawTgc_gPos
ThreeVectorBranch m_rawTgc_gPos
Definition: MuonSegmentReader.h:121
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
MuonCalib::MuonSegmentReader::m_trkHit_pos
ThreeVectorBranch m_trkHit_pos
Definition: MuonSegmentReader.h:149
H5Utils::getTree
std::string getTree(const std::string &file_name)
Definition: getTree.cxx:36
MuonCalib::MuonSegmentReader::m_trkHit_nMdtHits
ScalarBranch< int > & m_trkHit_nMdtHits
Definition: MuonSegmentReader.h:146
Muon::MdtDriftCircleOnTrack::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
Returns the global Position.
Definition: MdtDriftCircleOnTrack.cxx:108
Muon::MdtDriftCircleOnTrack::driftTime
double driftTime() const
Returns the value of the drift time used to obtain the drift radius.
Definition: MdtDriftCircleOnTrack.h:280
MuonCalib::MuonSegmentReader::m_trkHit_calibStatus
VectorBranch< int > & m_trkHit_calibStatus
Definition: MuonSegmentReader.h:177
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
MuonGM::MdtReadoutElement::distanceFromRO
double distanceFromRO(const Amg::Vector3D &GlobalHitPosition, const Identifier &id) const
Trk::TrackStateOnSurface::Outlier
@ Outlier
This TSoS contains an outlier, that is, it contains a MeasurementBase/RIO_OnTrack which was not used ...
Definition: TrackStateOnSurface.h:122
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
MuonCalib::MuonSegmentReader::m_trkHole_gPos
ThreeVectorBranch m_trkHole_gPos
Definition: MuonSegmentReader.h:183
MuonCalib::MuonSegmentReader::m_trk_z0
VectorBranch< float > & m_trk_z0
Definition: MuonSegmentReader.h:126
Muon::RpcPrepData::time
float time() const
Returns the time.
Definition: RpcPrepData.h:197
Muon::TgcClusterOnTrack::prepRawData
virtual const TgcPrepData * prepRawData() const
Returns the TgcPrepData - is a TRT_DriftCircle in this scope.
Definition: TgcClusterOnTrack.h:129
MuonVal::ThreeVectorBranch::push_back
void push_back(const Amg::Vector3D &vec)
interface using the Amg::Vector3D
Definition: ThreeVectorBranch.cxx:23
MuonCalib::MuonSegmentReader::m_rawMdt_tdc
VectorBranch< int > & m_rawMdt_tdc
Definition: MuonSegmentReader.h:107
MuonCalib::MuonSegmentReader::m_trkHit_id
VectorBranch< unsigned int > & m_trkHit_id
Definition: MuonSegmentReader.h:159
Trk::TrackStateOnSurface::type
bool type(const TrackStateOnSurfaceType type) const
Use this method to find out if the TSoS is of a certain type: i.e.
MuonCalib::MuonSegmentReader::m_trkHit_slewTime
VectorBranch< float > & m_trkHit_slewTime
Definition: MuonSegmentReader.h:171
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
MuonCalib::MuonSegmentReader::m_trkHit_lorTime
VectorBranch< float > & m_trkHit_lorTime
Definition: MuonSegmentReader.h:172
AthCommonDataStore
Definition: AthCommonDataStore.h:52
Muon::TgcPrepData::getBcBitMap
uint16_t getBcBitMap() const
Returns the bcBitMap of this PRD bit2 for Previous BC, bit1 for Current BC, bit0 for Next BC.
Definition: TgcPrepData.cxx:75
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
MuonCalib::MuonSegmentReader::m_pt
ScalarBranch< float > & m_pt
Definition: MuonSegmentReader.h:100
MuonGM::MuonDetectorManager::getMdtReadoutElement
const MdtReadoutElement * getMdtReadoutElement(const Identifier &id) const
access via extended identifier (requires unpacking)
Definition: MuonDetDescr/MuonReadoutGeometry/src/MuonDetectorManager.cxx:204
MuonGM::MdtReadoutElement
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MdtReadoutElement.h:51
Trk::TrackStateOnSurface::Hole
@ Hole
A hole on the track - this is defined in the following way.
Definition: TrackStateOnSurface.h:128
Muon::RpcPrepData
Class to represent RPC measurements.
Definition: RpcPrepData.h:35
Trk::theta
@ theta
Definition: ParamDefs.h:66
MuonCalib::MuonSegmentReader::m_trk_nOutliersHits
VectorBranch< int > & m_trk_nOutliersHits
Definition: MuonSegmentReader.h:139
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trk::driftRadius
@ driftRadius
trt, straws
Definition: ParamDefs.h:53
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
MuonCalib::MuonSegmentReader::m_trkHit_gPos
ThreeVectorBranch m_trkHit_gPos
Definition: MuonSegmentReader.h:148
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
dumpFileToPlots.treeName
string treeName
Definition: dumpFileToPlots.py:20
Muon::MdtPrepData::globalPosition
virtual const Amg::Vector3D & globalPosition() const
Returns the global position of the CENTER of the drift tube (i.e.
Definition: MdtPrepData.h:133
MuonCalib::MuonSegmentReader::m_trkHit_driftRadius
VectorBranch< float > & m_trkHit_driftRadius
Definition: MuonSegmentReader.h:160
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
Muon::MdtDriftCircleOnTrack::localAngle
double localAngle() const
Returns the local angle, as determined by the extrapolation used when creating this Trk::RIO_OnTrack.
Definition: MdtDriftCircleOnTrack.h:282
MuonCalib::MuonSegmentReader::m_trkTriggerHit_gPos
ThreeVectorBranch m_trkTriggerHit_gPos
Definition: MuonSegmentReader.h:191
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MuonCalib::MuonSegmentReader::m_eventNumber
ScalarBranch< int > & m_eventNumber
Definition: MuonSegmentReader.h:96
Trk::MuonTrackSummary
Detailed track summary for the muon system Give access to hit counts per chamber.
Definition: MuonTrackSummary.h:26
AthHistogramming::m_graphMap
GraphMap_t m_graphMap
The map of TGraph names to their pointers.
Definition: AthHistogramming.h:222
Trk::FitQuality
Class to represent and store fit qualities from track reconstruction in terms of and number of degre...
Definition: FitQuality.h:97
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
Muon::MdtDriftCircleOnTrack::positionAlongWire
double positionAlongWire() const
Returns the position along the wire, as determined by the extrapolation used when creating this Trk::...
Definition: MdtDriftCircleOnTrack.h:281
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
AthHistogramming::m_streamName
std::string m_streamName
Name of the ROOT output stream (file)
Definition: AthHistogramming.h:226
Muon::MdtDriftCircleOnTrack::driftRadius
double driftRadius() const
Returns the value of the drift radius.
Definition: MdtDriftCircleOnTrack.h:277
AthHistogramming::configAthHistogramming
StatusCode configAthHistogramming(const ServiceHandle< ITHistSvc > &histSvc, const std::string &prefix, const std::string &rootDir, const std::string &histNamePrefix, const std::string &histNamePostfix, const std::string &histTitlePrefix, const std::string &histTitlePostfix)
To be called by the derived classes to fill the internal configuration.
Definition: AthHistogramming.cxx:66
MdtCalibOutput
Definition: MdtCalibOutput.h:10
DataVector< const Trk::TrackStateOnSurface >
AthHistogramming::hash_t
uint32_t hash_t
typedef for the internal hash
Definition: AthHistogramming.h:169
CxxUtils::crc64
uint64_t crc64(const CRCTable &table, const char *data, size_t data_len)
Find the CRC-64 of a string,.
Definition: crc64.cxx:696
AthHistogramming::m_histTitlePostfix
std::string m_histTitlePostfix
The postfix for the histogram THx title.
Definition: AthHistogramming.h:241
Trk::numberOfTgcEtaHits
@ numberOfTgcEtaHits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:106
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
beamspotman.dir
string dir
Definition: beamspotman.py:623
MuonVal::VectorBranch::push_back
void push_back(const T &value)
Adds a new element at the end of the vector.
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
Trk::MeasurementBase
Definition: MeasurementBase.h:58
Muon::RpcClusterOnTrack::prepRawData
virtual const RpcPrepData * prepRawData() const override final
Returns the RpcPrepData - is a TRT_DriftCircle in this scope.
Definition: RpcClusterOnTrack.h:127
Trk::PrepRawData::identify
Identifier identify() const
return the identifier
MuonCalib::MuonSegmentReader::m_trk_theta
VectorBranch< float > & m_trk_theta
Definition: MuonSegmentReader.h:128
Trk::Track::perigeeParameters
const Perigee * perigeeParameters() const
return Perigee.
Definition: Tracking/TrkEvent/TrkTrack/src/Track.cxx:163
Trk::numberOfRpcPhiHits
@ numberOfRpcPhiHits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:109
MuonCalib::MuonSegmentReader::m_MuonIdHelper
ServiceHandle< Muon::IMuonIdHelperSvc > m_MuonIdHelper
Definition: MuonSegmentReader.h:80
MuonCalib::MuonSegmentReader::m_rawMdt_id
VectorBranch< unsigned int > & m_rawMdt_id
Definition: MuonSegmentReader.h:106
MuonCalib::MuonSegmentReader::m_trk_chi2
VectorBranch< float > & m_trk_chi2
Definition: MuonSegmentReader.h:132
MuonCalib::MuonSegmentReader::m_TrkKey
SG::ReadHandleKey< TrackCollection > m_TrkKey
Definition: MuonSegmentReader.h:70
Muon::MdtPrepData::tdc
int tdc() const
Returns the TDC (typically range is 0 to 2500).
Definition: MdtPrepData.h:145
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
MuonCalib::MuonSegmentReader::m_trk_nRpcPhiHits
VectorBranch< int > & m_trk_nRpcPhiHits
Definition: MuonSegmentReader.h:140
MuonCalib::MuonSegmentReader::m_trkTriggerHit_time
VectorBranch< float > & m_trkTriggerHit_time
Definition: MuonSegmentReader.h:193
Trk::TrackSummary
A summary of the information contained by a track.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
Trk::d0
@ d0
Definition: ParamDefs.h:63
MuonCalib::MuonSegmentReader::m_evtKey
SG::ReadHandleKey< xAOD::EventInfo > m_evtKey
Definition: MuonSegmentReader.h:67
MuonCalib::MuonSegmentReader::m_trkHit_adc
VectorBranch< int > & m_trkHit_adc
Definition: MuonSegmentReader.h:154
Muon::MdtDriftCircleOnTrack
This class represents the corrected MDT measurements, where the corrections include the effects of wi...
Definition: MdtDriftCircleOnTrack.h:37
AthHistogramming::hash
hash_t hash(const std::string &histName) const
Method to calculate a 32-bit hash from a string.
Definition: AthHistogramming.h:428
MuonCalib::MuonSegmentReader::m_trk_nMdtHoles
VectorBranch< int > & m_trk_nMdtHoles
Definition: MuonSegmentReader.h:138
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
module_driven_slicing.getHist
def getHist(name, makehist)
Definition: module_driven_slicing.py:121
MuonCalib::MuonSegmentReader::m_trk_author
VectorBranch< int > & m_trk_author
Definition: MuonSegmentReader.h:134
Muon::MdtPrepData
Class to represent measurements from the Monitored Drift Tubes.
Definition: MdtPrepData.h:33
Muon::CompetingMuonClustersOnTrack::containedROTs
const std::vector< const MuonClusterOnTrack * > & containedROTs() const
returns the vector of SCT_ClusterOnTrack objects .
Definition: CompetingMuonClustersOnTrack.h:184
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
MuonCalib::MuonSegmentReader::m_RpcPrepDataKey
SG::ReadHandleKey< Muon::RpcPrepDataContainer > m_RpcPrepDataKey
Definition: MuonSegmentReader.h:73
MuonCalib::MuonSegmentReader::m_bcId
ScalarBranch< int > & m_bcId
Definition: MuonSegmentReader.h:98
MuonCalib::MuonSegmentReader::m_runNumber
ScalarBranch< int > & m_runNumber
Definition: MuonSegmentReader.h:95
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
MuonCalib::MuonSegmentReader::m_trk_d0
VectorBranch< float > & m_trk_d0
Definition: MuonSegmentReader.h:125
xxh3::hash64
std::uint64_t hash64(const void *data, std::size_t size)
Passthrough to XXH3_64bits.
Definition: XXH.cxx:9
AthHistogramming::AthHistogramming
AthHistogramming(const std::string &name)
Constructor with parameters:
Definition: AthHistogramming.cxx:41
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
MuonCalib::MuonSegmentReader::m_printer
PublicToolHandle< Muon::MuonEDMPrinterTool > m_printer
Definition: MuonSegmentReader.h:91
MuonCalib::MuonSegmentReader::m_trkHole_id
VectorBranch< unsigned int > & m_trkHole_id
Definition: MuonSegmentReader.h:184
Trk::ResidualPull::Biased
@ Biased
RP with track state including the hit.
Definition: ResidualPull.h:55
MuonCalib::MuonSegmentReader::m_trk_ndof
VectorBranch< int > & m_trk_ndof
Definition: MuonSegmentReader.h:133
MuonGM::MdtReadoutElement::tubePos
Amg::Vector3D tubePos(const Identifier &id) const
Returns the global position of the given tube.
a
TList * a
Definition: liststreamerinfos.cxx:10
AthHistogramming::m_effMap
EffMap_t m_effMap
The map of histogram names to their pointers.
Definition: AthHistogramming.h:208
MuonCalib::MuonSegmentReader::m_trkHit_propTime
VectorBranch< float > & m_trkHit_propTime
Definition: MuonSegmentReader.h:173
h
MuonCalib::MuonSegmentReader::m_trkHole_nHoles
ScalarBranch< int > & m_trkHole_nHoles
Definition: MuonSegmentReader.h:180
MuonCalib::MuonSegmentReader::m_calibrationTool
ToolHandle< IMdtCalibrationTool > m_calibrationTool
pointer to MdtCalibSvc
Definition: MuonSegmentReader.h:84
AthHistogramming::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition: AthHistogramming.h:238
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
MuonGM::MuonDetectorManager
The MuonDetectorManager stores the transient representation of the Muon Spectrometer geometry and pro...
Definition: MuonDetDescr/MuonReadoutGeometry/MuonReadoutGeometry/MuonDetectorManager.h:50
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonCalib::MuonSegmentReader::m_trk_pt
VectorBranch< float > & m_trk_pt
Definition: MuonSegmentReader.h:131
Trk::Track::trackSummary
const Trk::TrackSummary * trackSummary() const
Returns a pointer to the const Trk::TrackSummary owned by this const track (could be nullptr)
MuonCalib::MuonSegmentReader::m_trkHit_triggerTime
VectorBranch< float > & m_trkHit_triggerTime
Definition: MuonSegmentReader.h:169
AthHistogramAlgorithm::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition: AthHistogramAlgorithm.h:97
MuonCalib::MuonSegmentReader::m_trkHit_tof
VectorBranch< float > & m_trkHit_tof
Definition: MuonSegmentReader.h:176
Trk::RIO_OnTrack::identify
Identifier identify() const
return the identifier -extends MeasurementBase
Definition: RIO_OnTrack.h:152
AthHistogramming::m_treeMap
TreeMap_t m_treeMap
The map of TTree names to their pointers.
Definition: AthHistogramming.h:215
AthHistogramming::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition: AthHistogramming.h:232
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
Muon::TgcPrepData
Class to represent TGC measurements.
Definition: TgcPrepData.h:32
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
MuonVal::MuonTesterTree::fill
bool fill(const EventContext &ctx)
Fills the tree per call.
Definition: MuonTesterTree.cxx:89
MuonVal::MuonTesterTree::write
StatusCode write()
Finally write the TTree objects.
Definition: MuonTesterTree.cxx:178
AthHistogramAlgorithm::m_histTitlePostfix
std::string m_histTitlePostfix
The postfix for the histogram THx title.
Definition: AthHistogramAlgorithm.h:103
AthHistogramming::hist
TH1 * hist(const std::string &histName, const std::string &tDir="", const std::string &stream="")
Simplify the retrieval of registered histograms of any type.
Definition: AthHistogramming.cxx:198
Trk::FitQuality::chiSquared
double chiSquared() const
returns the of the overall track fit
Definition: FitQuality.h:56
AthHistogramming::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Pointer to the THistSvc (event store by default)
Definition: AthHistogramming.h:194
MuonCalib::MuonSegmentReader::m_trkHit_closestApproach
ThreeVectorBranch m_trkHit_closestApproach
Definition: MuonSegmentReader.h:150
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
MuonCalib::MuonSegmentReader::m_trkHit_tdc
VectorBranch< int > & m_trkHit_tdc
Definition: MuonSegmentReader.h:156
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
Muon::TgcPrepData::globalPosition
virtual const Amg::Vector3D & globalPosition() const override final
Returns the global position.
Definition: TgcPrepData.h:125
str
Definition: BTagTrackIpAccessor.cxx:11
MuonVal::VectorBranch::size
size_t size() const
Returns the number of actual saved elements.
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
Trk::FitQuality::numberDoF
int numberDoF() const
returns the number of degrees of freedom of the overall track or vertex fit as integer
Definition: FitQuality.h:60
MuonCalib::MuonSegmentReader::m_trkHole_trackIndex
VectorBranch< int > & m_trkHole_trackIndex
Definition: MuonSegmentReader.h:181
MuonCalib::MuonSegmentReader::m_trk_phi
VectorBranch< float > & m_trk_phi
Definition: MuonSegmentReader.h:127
MuonCalib::MuonSegmentReader::m_idToFixedIdTool
ToolHandle< MuonCalib::IIdToFixedIdTool > m_idToFixedIdTool
Definition: MuonSegmentReader.h:89
Trk::numberOfRpcEtaHits
@ numberOfRpcEtaHits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:110
Trk::TrackSummary::get
int get(const SummaryType &type) const
returns the summary information for the passed SummaryType.
MuonCalib::MuonSegmentReader::m_trk_nTgcEtaHits
VectorBranch< int > & m_trk_nTgcEtaHits
Definition: MuonSegmentReader.h:143
MuonCalib::MuonSegmentReader::m_trkHit_bkgTime
VectorBranch< float > & m_trkHit_bkgTime
Definition: MuonSegmentReader.h:175
Trk::TrackSummary::muonTrackSummary
const MuonTrackSummary * muonTrackSummary() const
returns a pointer to the MuonTrackSummary if available
MuonCalib::MuonSegmentReader::m_trkTriggerHit_id
VectorBranch< unsigned int > & m_trkTriggerHit_id
Definition: MuonSegmentReader.h:192
MuonCalib::MuonSegmentReader::m_trk_eta
VectorBranch< float > & m_trk_eta
Definition: MuonSegmentReader.h:129
Trk::loc1
@ loc1
Definition: ParamDefs.h:34
AthHistogramming::m_name
std::string m_name
Instance name.
Definition: AthHistogramming.h:245
MuonCalib::MuonSegmentReader::m_rawMdt_nRMdt
ScalarBranch< int > & m_rawMdt_nRMdt
Definition: MuonSegmentReader.h:105
MuonCalib::MuonSegmentReader::m_rawMdt_adc
VectorBranch< int > & m_rawMdt_adc
Definition: MuonSegmentReader.h:108
MuonCalib::MuonSegmentReader::m_trkHit_pull
VectorBranch< float > & m_trkHit_pull
Definition: MuonSegmentReader.h:158
error
Definition: IImpactPoint3dEstimator.h:70
AthHistogramAlgorithm::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition: AthHistogramAlgorithm.h:91
MuonCalib::MuonSegmentReader::m_trkHit_error
VectorBranch< float > & m_trkHit_error
Definition: MuonSegmentReader.h:161
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
MuonCalib::MuonSegmentReader::m_timeStamp
ScalarBranch< int > & m_timeStamp
Definition: MuonSegmentReader.h:99
Trk::phi0
@ phi0
Definition: ParamDefs.h:65
Trk::TrackStateOnSurface::Measurement
@ Measurement
This is a measurement, and will at least contain a Trk::MeasurementBase.
Definition: TrackStateOnSurface.h:101
MuonCalib::MuonSegmentReader::m_trkHit_driftTime
VectorBranch< float > & m_trkHit_driftTime
Definition: MuonSegmentReader.h:163
MuonCalib::MuonSegmentReader::m_trkTriggerHit_type
VectorBranch< int > & m_trkTriggerHit_type
Definition: MuonSegmentReader.h:190
Trk::numberOfMdtHits
@ numberOfMdtHits
number of mdt hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:103
fitman.k
k
Definition: fitman.py:528
MuonCalib::MuonSegmentReader::m_trkHit_center
ThreeVectorBranch m_trkHit_center
Definition: MuonSegmentReader.h:152
AthHistogramming::buildBookingString
void buildBookingString(std::string &bookingString, std::string &histName, std::string &tDir, std::string &stream, bool usePrefixPostfix=false)
Method to build individual booking string.
Definition: AthHistogramming.cxx:560
ServiceHandle< ITHistSvc >
AthHistogramming::bookGetPointer
TH1 * bookGetPointer(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition: AthHistogramming.h:260
Identifier
Definition: IdentifierFieldParser.cxx:14
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65
Generated on Sun Dec 22 2024 22:05:13 for ATLAS Offline Software by   doxygen 1.8.18