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

#include <MuonPhysValMonitoringTool.h>

Inheritance diagram for MuonPhysValMonitoring::MuonPhysValMonitoringTool:

Public Types

enum  Interval_t {
  file = 0 , eventsBlock , lumiBlock , lowStat ,
  medStat , higStat , run , fill ,
  all
}
 An enumeration describing how detailed a particular monitoring object is. More...
enum  MgmtAttr_t { ATTRIB_MANAGED = 0 , ATTRIB_UNMANAGED = 1 , ATTRIB_X_VS_LB = 2 }
 An enumeration describing how the class handles the histogram. More...

Public Member Functions

virtual ~MuonPhysValMonitoringTool ()=default
 Destructor:
virtual StatusCode initialize () override
virtual StatusCode bookHistograms () override
 An inheriting class should either override this function or bookHists().
virtual StatusCode fillHistograms () override
 An inheriting class should either override this function or fillHists().
virtual StatusCode procHistograms () override
 An inheriting class should either override this function or finalHists().
 ManagedMonitorToolBase (const std::string &type, const std::string &name, const IInterface *parent)
 Constructor with parameters:
virtual StreamNameFcn * streamNameFunction ()
 Returns the function object that converts logical paramters into a physical stream name.
virtual StatusCode bookHists ()
 Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.
virtual StatusCode fillHists ()
 Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ).
virtual StatusCode finalHists ()
 Calls procHists( true, true, true ).
virtual StatusCode bookHistogramsRecurrent ()
 An inheriting class should either override this function, bookHists() or bookHistograms().
virtual void setMonManager (AthenaMonManager *manager)
 Takes a pointer to a managing object to get information from it when needed.
virtual StatusCode regHist (TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.
virtual StatusCode regHist (TH1 *h, const MonGroup &group)
 Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.
virtual StatusCode getHist (TH1 *&h, const std::string &hName, const std::string &system, Interval_t interval)
 Returns a TH1 via the pointer passed as the first argument.
virtual StatusCode getHist (TH1 *&h, const std::string &hName, const MonGroup &group)
 Returns a TH1 via the pointer passed as the first argument.
virtual StatusCode getHist (TH2 *&h, const std::string &hName, const std::string &system, Interval_t interval)
 Returns a TH2 via the pointer passed as the first argument.
virtual StatusCode getHist (TH2 *&h, const std::string &hName, const MonGroup &group)
 Returns a TH2 via the pointer passed as the first argument.
virtual StatusCode regEfficiency (TEfficiency *e, const MonGroup &group)
 Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot.
virtual StatusCode regGraph (TGraph *g, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Registers a TGraph to be included in the output stream using logical parameters that describe the graph.
virtual StatusCode regGraph (TGraph *g, const MonGroup &group)
 Registers a TGraph to be included in the output stream using logical parameters that describe the graph.
virtual StatusCode regTree (TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
 Registers a TTree to be included in the output stream using logical parameters that describe it.
virtual StatusCode regTree (TTree *t, const MonGroup &group)
 Registers a TTree to be included in the output stream using logical parameters that describe it.
virtual StatusCode writeAndDelete (TH1 *h, const MonGroup &group)
 Write out histogram and delete it.
virtual StatusCode deregHist (TH1 *h)
 De-registers a TH1 from the THistSvc, but does NOT delete the object.
virtual StatusCode deregGraph (TGraph *g)
 De-registers a TGraph from the THistSvc, but does NOT delete the object.
virtual StatusCode deregObject (const std::string &objName, const std::string &system, Interval_t interval)
 De-registers a TObject from the THistSvc, but does NOT delete the object.
virtual StatusCode deregObject (const std::string &objName, const MonGroup &group)
 De-registers a TObject from the THistSvc, but does NOT delete the object.
virtual StatusCode setupOutputStreams (std::vector< std::string > Mapping=std::vector< std::string >())
 This implementation does nothing—streams in this class should be managed by the AthenaMonManager.
virtual StatusCode runStat ()
 This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ).
virtual StatusCode checkHists (bool calledFromFinalize)
 This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.
virtual bool preSelector ()
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average mu, i.e.
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Instantaneous number of interactions, i.e.
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Instantaneous luminosity.
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Luminosity block time (in seconds)
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average luminosity livefraction.
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Livefraction per bunch crossing ID.
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Average Integrated Luminosity Live Fraction.
 MMTB_DEPRECATED (newLowStatInterval)
 MMTB_DEPRECATED (newMedStatInterval)
 MMTB_DEPRECATED (newHigStatInterval)
 MMTB_DEPRECATED (newLowStat)
 MMTB_DEPRECATED (newLumiBlock)
 MMTB_DEPRECATED (newRun)
 MMTB_DEPRECATED (newEventsBlock)
 MMTB_DEPRECATED (endOfEventsBlock)
 MMTB_DEPRECATED (endOfLowStat)
 MMTB_DEPRECATED (endOfLumiBlock)
 MMTB_DEPRECATED (endOfRun)
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm.
virtual StatusCode sysStart () override
 Handle START transition.
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles.
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
void updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream & msg () const
bool msgLvl (const MSG::Level lvl) const

Static Public Member Functions

static std::string intervalEnumToString (Interval_t interval)
 Converts a LevelOfDetail_t to a string of the same name.
static Interval_t intervalStringToEnum (const std::string &str)
 Converts a string to the corresponding Interval_t.
static const InterfaceID & interfaceID ()

Protected Types

typedef std::map< std::string, OutputMetadata * > MDMap_t

Protected Member Functions

StatusCode regManagedHistograms (std::vector< MgmtParams< TH1 > > &templateHistograms)
StatusCode regManagedGraphs (std::vector< MgmtParams< TGraph > > &templateGraphs)
StatusCode regManagedTrees (std::vector< MgmtParams< TTree > > &templateTrees)
StatusCode regManagedEfficiencies (std::vector< MgmtParams< TEfficiency > > &templateEfficiencies)
StatusCode parseList (const std::string &, std::vector< std::string > &)
void updateTriggersForGroups (std::vector< std::string > &)
StatusCode registerMetadata (const std::string &streamName, const std::string &hName, const MonGroup &group)
StatusCode THistSvc_deReg_fixTGraph (TFile *file, TGraph *theGraph, std::string &directoryName)
 Fixes THistSvc->deReg(obj) when obj is TGraph instance.
unsigned int get_nEvents () const
long get_procNEventsProp () const
virtual bool trigChainsArePassed (std::vector< std::string > &)
virtual StreamNameFcn * getNewStreamNameFcn () const
bool newLowStatIntervalFlag () const
 Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called.
bool newMedStatIntervalFlag () const
bool newHigStatIntervalFlag () const
bool newLowStatFlag () const
bool newLumiBlockFlag () const
bool newRunFlag () const
bool newEventsBlockFlag () const
bool endOfEventsBlockFlag () const
bool endOfLowStatFlag () const
bool endOfLumiBlockFlag () const
bool endOfRunFlag () const
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed.

Protected Attributes

std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
std::vector< std::string > m_vTrigChainNames
std::vector< std::string > m_vTrigGroupNames
MDMap_t m_metadataMap
AthenaMonManager * m_manager
std::string m_managerNameProp
std::string m_fileKey
std::string m_dataTypeStr
std::string m_environmentStr
unsigned int m_detailLevel
AthenaMonManager::DataType_t m_dataType
AthenaMonManager::Environment_t m_environment
StreamNameFcn * m_streamNameFcn
ServiceHandle< ITHistSvc > m_THistSvc
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool {this, "TrigDecisionTool",""}
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator {this,"TriggerTranslatorTool",""}
ToolHandleArray< IDQFilterTool > m_DQFilterTools {this,"FilterTools",{}}
long m_procNEventsProp
std::string m_path
long m_preScaleProp
std::string m_triggerChainProp
std::string m_triggerGroupProp
bool m_useTrigger
unsigned int m_lastLumiBlock
unsigned int m_lastRun
int m_lastLowStatInterval
int m_lastMedStatInterval
int m_lastHigStatInterval
unsigned int m_nEvents
unsigned int m_nEventsIgnoreTrigger
unsigned int m_nLumiBlocks
bool m_haveClearedLastEventBlock

Private Types

enum  MUCATEGORY {
  ALL = 0 , PROMPT , INFLIGHT , NONISO ,
  REST
}
using TrackContKey_t = SG::ReadHandleKey<xAOD::TrackParticleContainer>
using MuonContKey_t = SG::ReadHandleKey<xAOD::MuonContainer>
using SegmentContKey_t = SG::ReadHandleKey<xAOD::MuonSegmentContainer>
using MuonROIContKey_t = SG::ReadHandleKey<xAOD::MuonRoIContainer>
using L2SAContKey_t = SG::ReadHandleKey<xAOD::L2StandAloneMuonContainer>
using L2CBContKey_t = SG::ReadHandleKey<xAOD::L2CombinedMuonContainer>
using SlowContKey_t = SG::ReadHandleKey<xAOD::SlowMuonContainer>
using TruthPartKey_t = SG::ReadHandleKey<xAOD::TruthParticleContainer>
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

void handleMuon (const xAOD::Muon *mu, const xAOD::SlowMuon *smu=nullptr, float weight=1.0)
void handleSlowMuon (const xAOD::SlowMuon *smu, float weight=1.0)
void handleTruthMuon (const xAOD::TruthParticle *truthMu, float weight=1.0)
void handleMuonTrack (const xAOD::TrackParticle *tp, xAOD::Muon::TrackParticleType type, float weight=1.0)
void handleMuonSegment (const xAOD::MuonSegment *muSeg, float weight=1.0)
void handleTruthMuonSegment (const xAOD::MuonSegment *truthMuSeg, const xAOD::TruthParticleContainer *muonTruthContainer, float weight=1.0)
void handleMuonL1Trigger (const xAOD::MuonRoI *TrigL1mu)
void handleMuonL2Trigger (const xAOD::L2StandAloneMuon *L2SAMu)
void handleMuonL2Trigger (const xAOD::L2CombinedMuon *L2CBMu)
void handleMuonTrigger (const xAOD::Muon *mu)
void L2SATriggerResolution ()
void L2CBTriggerResolution ()
void EFTriggerResolution ()
void printMuonDebug (const xAOD::Muon *mu)
void printTruthMuonDebug (const xAOD::TruthParticle *truthMu, const xAOD::Muon *mu)
StatusCode bookValidationPlots (PlotBase &valPlots)
const xAOD::Muon * findRecoMuon (const xAOD::TruthParticle *truthMu)
const xAOD::SlowMuon * findRecoSlowMuon (const xAOD::TruthParticle *truthMu)
const xAOD::MuonSegment * findRecoMuonSegment (const xAOD::MuonSegment *truthMuSeg)
std::unique_ptr< xAOD::Muon > getCorrectedMuon (const xAOD::Muon &mu)
TH1F * findHistogram (const std::vector< HistData > &hists, const std::string &hnameTag, const std::string &hdirTag, const std::string &hNewName)
void modifyHistogram (TH1 *hist)
MuonPhysValMonitoringTool::MUCATEGORY getMuonSegmentTruthCategory (const xAOD::MuonSegment *truthMuSeg, const xAOD::TruthParticleContainer *muonTruthContainer)
MuonPhysValMonitoringTool::MUCATEGORY getMuonTruthCategory (const xAOD::IParticle *prt)
bool passesAcceptanceCuts (const xAOD::IParticle *prt)
void SplitString (TString x, const TString &delim, std::vector< TString > &v)
template<class ContType>
StatusCode retrieveContainer (const EventContext &ctx, const SG::ReadHandleKey< ContType > &key, const ContType *&container) const
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

const xAOD::TrackParticleContainer * m_MSTracks {nullptr}
std::map< std::string, int > m_counterBits
std::vector< std::string > m_muonItems
std::vector< std::string > m_L1Seed
int m_SelectedAuthor {0}
TrackContKey_t m_tracksName {this, "TrackContainerName", "InDetTrackParticles"}
TrackContKey_t m_fwdtracksName {this, "FwdTrackContainerName", ""}
MuonContKey_t m_muonsName {this, "MuonContainerName", "Muons"}
SlowContKey_t m_slowMuonsName {this, "SlowMuonContainerName", "SlowMuons"}
TruthPartKey_t m_muonsTruthName {this, "MuonTruthParticleContainerName", "MuonTruthParticles"}
TrackContKey_t m_muonTracksName {this, "MuonTrackContainerName", "MuonSpectrometerTrackParticles"}
TrackContKey_t m_muonExtrapolatedTracksName {this, "MuonExtrapolatedTrackContainerName", "ExtrapolatedMuonTrackParticles"}
TrackContKey_t m_muonMSOnlyExtrapolatedTracksName
SegmentContKey_t m_muonSegmentsName {this, "MuonSegmentContainerName", "MuonSegments"}
SegmentContKey_t m_muonSegmentsTruthName {this, "MuonTruthSegmentContainerName", "MuonTruthSegments"}
MuonROIContKey_t m_muonL1TrigName {this, "L1TrigMuonContainerName", "LVL1MuonRoIs"}
L2SAContKey_t m_muonL2SAName {this, "L2SAMuonContainerName", "HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo"}
L2CBContKey_t m_muonL2CBName {this, "L2CBMuonContainerName", "HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfo"}
MuonContKey_t m_muonEFCombTrigName {this, "EFCombTrigMuonContainerName", "HLT_xAOD__MuonContainer_MuonEFInfo"}
SG::ReadDecorHandleKeyArray< xAOD::IParticleContainer > m_decorDep {this, "DecorDependencies", {}}
Gaudi::Property< std::vector< int > > m_selectMuonWPs
Gaudi::Property< std::vector< unsigned int > > m_selectMuonAuthors
Gaudi::Property< bool > m_selectComissioning {this, "SelectComissioningMuons", false}
 Flag to tell whether muons with the comissioning author will be selected or not.
Gaudi::Property< std::vector< std::vector< std::string > > > m_selectHLTMuonItems {this, "SelectHLTMuonItems", {}}
Gaudi::Property< std::vector< std::string > > m_L1MuonItems {this, "SelectL1MuonItems", {}}
Gaudi::Property< std::vector< unsigned int > > m_selectMuonCategories
Gaudi::Property< bool > m_doBinnedResolutionPlots {this, "DoBinnedResolutionPlots", true}
Gaudi::Property< bool > m_doTrigMuonValidation {this, "DoTrigMuonValidation", false}
Gaudi::Property< bool > m_doTrigMuonL1Validation {this, "DoTrigMuonL1Validation", false}
Gaudi::Property< bool > m_doTrigMuonL2Validation {this, "DoTrigMuonL2Validation", false}
Gaudi::Property< bool > m_doTrigMuonEFValidation {this, "DoTrigMuonEFValidation", false}
Gaudi::Property< bool > m_isData {this, "IsData", false}
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo {this, "EventInfo", "EventInfo", "event info"}
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool {this, "MuonSelector", "CP::MuonSelectionTool/MuonSelectionTool"}
ToolHandle< Rec::IMuonPrintingTool > m_muonPrinter {this, "MuonPrinter", "Rec::MuonPrintingTool/MuonPrintingTool"}
ToolHandle< Trig::TrigDecisionTool > m_trigDec {this, "TrigDecTool", "Trig::TrigDecisionTool/TrigDecisionTool"}
ToolHandle< Trk::ITrackSelectorTool > m_trackSelector {this, "TrackSelector", "InDet::InDetDetailedTrackSelectorTool/MuonCombinedInDetDetailedTrackSelectorTool"}
ToolHandle< CP::IIsolationSelectionTool > m_isoTool {this, "IsoTool", ""}
std::vector< std::string > m_selectMuonCategoriesStr
std::vector< std::unique_ptr< MuonValidationPlots > > m_muonValidationPlots
std::vector< std::unique_ptr< TriggerMuonValidationPlots > > m_TriggerMuonValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSOnlyMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDSelectedTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDForwardTrackValidationPlots
std::vector< std::unique_ptr< MuonSegmentValidationPlots > > m_muonSegmentValidationPlots
std::unique_ptr< Muon::RecoMuonPlotOrganizer > m_oUnmatchedRecoMuonPlots
std::unique_ptr< Muon::TruthMuonPlotOrganizer > m_oUnmatchedTruthMuonPlots
std::unique_ptr< Muon::RecoMuonTrackPlotOrganizer > m_oUnmatchedRecoMuonTrackPlots
std::unique_ptr< Muon::MuonSegmentPlots > m_oUnmatchedRecoMuonSegmentPlots
std::vector< std::unique_ptr< SlowMuonValidationPlots > > m_slowMuonValidationPlots
std::vector< TH1F * > m_h_overview_nObjects
TH1F * m_h_overview_reco_category {nullptr}
std::vector< TH1F * > m_h_overview_reco_authors
TH1F * m_h_overview_Z_mass {nullptr}
TH1F * m_h_overview_Z_mass_ME {nullptr}
TH1F * m_h_overview_Z_mass_ID {nullptr}
std::vector< const xAOD::TruthParticle * > m_vMatchedTruthMuons
std::vector< const xAOD::Muon * > m_vMatchedMuons
std::vector< const xAOD::SlowMuon * > m_vMatchedSlowMuons
std::vector< const xAOD::TrackParticle * > m_vMatchedMuonTracks
std::vector< const xAOD::MuonSegment * > m_vMatchedMuonSegments
std::vector< const xAOD::TrackParticle * > m_vZmumuIDTracks
std::vector< const xAOD::TrackParticle * > m_vZmumuMETracks
std::vector< const xAOD::Muon * > m_vZmumuMuons
std::vector< const xAOD::Muon * > m_vEFMuons
std::vector< const xAOD::Muon * > m_vEFMuonsSelected
std::vector< const xAOD::L2StandAloneMuon * > m_vL2SAMuons
std::vector< const xAOD::L2StandAloneMuon * > m_vL2SAMuonsSelected
std::vector< const xAOD::L2CombinedMuon * > m_vL2CBMuons
std::vector< const xAOD::L2CombinedMuon * > m_vL2CBMuonsSelected
std::vector< const xAOD::Muon * > m_vRecoMuons
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen_CB
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen_MS
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen
bool m_newLowStatInterval
bool m_newMedStatInterval
bool m_newHigStatInterval
bool m_newLowStat
bool m_newLumiBlock
bool m_newRun
bool m_newEventsBlock
bool m_endOfEventsBlock
bool m_endOfLowStat
bool m_endOfLumiBlock
bool m_endOfRun
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
bool m_bookHistogramsInitial
bool m_useLumi
float m_defaultLBDuration
std::set< Interval_t > m_supportedIntervalsForRebooking
Imp * m_d
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default)
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 57 of file MuonPhysValMonitoringTool.h.

Member Typedef Documentation

◆ L2CBContKey_t

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2CBContKey_t = SG::ReadHandleKey<xAOD::L2CombinedMuonContainer>
private

Definition at line 120 of file MuonPhysValMonitoringTool.h.

◆ L2SAContKey_t

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2SAContKey_t = SG::ReadHandleKey<xAOD::L2StandAloneMuonContainer>
private

Definition at line 119 of file MuonPhysValMonitoringTool.h.

◆ MDMap_t

typedef std::map<std::string,OutputMetadata*> ManagedMonitorToolBase::MDMap_t
protectedinherited

Definition at line 826 of file ManagedMonitorToolBase.h.

◆ MuonContKey_t

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::MuonContKey_t = SG::ReadHandleKey<xAOD::MuonContainer>
private

Definition at line 116 of file MuonPhysValMonitoringTool.h.

◆ MuonROIContKey_t

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::MuonROIContKey_t = SG::ReadHandleKey<xAOD::MuonRoIContainer>
private

Definition at line 118 of file MuonPhysValMonitoringTool.h.

◆ SegmentContKey_t

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::SegmentContKey_t = SG::ReadHandleKey<xAOD::MuonSegmentContainer>
private

Definition at line 117 of file MuonPhysValMonitoringTool.h.

◆ SlowContKey_t

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::SlowContKey_t = SG::ReadHandleKey<xAOD::SlowMuonContainer>
private

Definition at line 121 of file MuonPhysValMonitoringTool.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

◆ TrackContKey_t

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::TrackContKey_t = SG::ReadHandleKey<xAOD::TrackParticleContainer>
private

Definition at line 115 of file MuonPhysValMonitoringTool.h.

◆ TruthPartKey_t

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::TruthPartKey_t = SG::ReadHandleKey<xAOD::TruthParticleContainer>
private

Definition at line 122 of file MuonPhysValMonitoringTool.h.

Member Enumeration Documentation

◆ Interval_t

enum ManagedMonitorToolBase::Interval_t
inherited

An enumeration describing how detailed a particular monitoring object is.

summary: used to summarize the state of the system

runstat: same as summary

shift: used to flag potential problems

expert: essential for diagnosing problems identified by shift-level objects

debug: useful for standalone debugging, but not for routine monitoring; not essential for diagnosing problems during normal running

transient: too detailed to ever be written; always summarized by the user by means of another object An enumeration describing the interval over which a particular monitoring object is filled (i.e., interval over which the method Fill(...) is called). This information may be stored with the monitoring object if an application is only able to partially fill the object (i.e., a job sees only part of a run or fill). This information may be ignored in some running Environments. The 'fill' interval corresponds to a fill of the LHC. The 'all' interval corresponds to all available data. The 'lumiBlock' and 'fill' intervals are only valid for the 'collisions' DataType_t.

Enumerator
file 
eventsBlock 
lumiBlock 
lowStat 
medStat 
higStat 
run 
fill 
all 

Definition at line 113 of file ManagedMonitorToolBase.h.

113 { file = 0, eventsBlock, lumiBlock,
114 lowStat, medStat, higStat,
115 run, fill, all };

◆ MgmtAttr_t

enum ManagedMonitorToolBase::MgmtAttr_t
inherited

An enumeration describing how the class handles the histogram.

attrib_unmanaged: histograms with this attribute will not be rebooked automatically and must be managed by the user code.

attrib_x_is_lb: indicates that the x-axis of the histogram is the luminosity block number and that the histogram should be rebooked as necessary if the current LB exceeds the range.

Enumerator
ATTRIB_MANAGED 
ATTRIB_UNMANAGED 
ATTRIB_X_VS_LB 

Definition at line 130 of file ManagedMonitorToolBase.h.

130{ ATTRIB_MANAGED = 0, ATTRIB_UNMANAGED = 1, ATTRIB_X_VS_LB = 2};

◆ MUCATEGORY

enum MuonPhysValMonitoring::MuonPhysValMonitoringTool::MUCATEGORY
private
Enumerator
ALL 
PROMPT 
INFLIGHT 
NONISO 
REST 

Definition at line 79 of file MuonPhysValMonitoringTool.h.

79{ ALL = 0, PROMPT, INFLIGHT, NONISO, REST };

Constructor & Destructor Documentation

◆ ~MuonPhysValMonitoringTool()

virtual MuonPhysValMonitoring::MuonPhysValMonitoringTool::~MuonPhysValMonitoringTool ( )
virtualdefault

Destructor:

Member Function Documentation

◆ bookHistograms()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::bookHistograms ( )
overridevirtual

An inheriting class should either override this function or bookHists().

Reimplemented from ManagedMonitorToolBase.

Definition at line 133 of file MuonPhysValMonitoringTool.cxx.

133 {
134 ATH_MSG_INFO("Booking hists " << name() << "...");
135
136 if (m_selectMuonWPs.size() == 1 && m_selectMuonWPs[0] < 0) m_selectMuonWPs.clear();
137
138 if (m_selectMuonAuthors.size() == 1 && m_selectMuonAuthors[0] == 0) m_selectMuonAuthors.clear();
139
140 static const std::map<int,std::string> theMuonCategories = {
141 {ALL, "All"},
142 {PROMPT, "Prompt"},
143 {INFLIGHT, "InFlight"},
144 {NONISO, "NonIsolated"},
145 {REST, "Rest"}
146 };
147
148 for (const auto& category : m_selectMuonCategories) m_selectMuonCategoriesStr.emplace_back(theMuonCategories.at(category));
149
150 // no such muons in case of SlowMuon reco
151 bool separateSAFMuons = m_slowMuonsName.empty();
152
153 std::string muonContainerName = m_muonsName.key();
154 for (const auto& category : m_selectMuonCategoriesStr) {
155 std::string categoryPath = muonContainerName + "/" + category + "/";
156
157 m_muonValidationPlots.emplace_back(std::make_unique<MuonValidationPlots>(
158 nullptr, categoryPath, m_selectMuonWPs, m_selectMuonAuthors, m_isData,
159 (category == theMuonCategories.at(ALL) ? false : m_doBinnedResolutionPlots.value()), separateSAFMuons, false));
160
161 if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots.emplace_back(std::make_unique<SlowMuonValidationPlots>(nullptr, categoryPath, m_isData));
162 if (m_doTrigMuonValidation) {
163 if (category == "All") {
164 m_TriggerMuonValidationPlots.emplace_back(std::make_unique<TriggerMuonValidationPlots>(
165 nullptr, categoryPath, m_selectMuonAuthors, m_isData, m_doTrigMuonL1Validation, m_doTrigMuonL2Validation,
166 m_doTrigMuonEFValidation, m_selectHLTMuonItems, m_L1MuonItems));
167 }
168 }
169 if (!m_muonTracksName.empty()) {
170 m_muonMSTrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "MSTrackParticles", m_isData));
171 if (!m_isData)
172 m_oUnmatchedRecoMuonTrackPlots = std::make_unique<Muon::RecoMuonTrackPlotOrganizer>(nullptr, muonContainerName + "/UnmatchedRecoMuonTracks/");
173 }
174 if (!m_muonExtrapolatedTracksName.empty())
175 m_muonMETrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "METrackParticles", m_isData));
176 if (!m_muonMSOnlyExtrapolatedTracksName.empty())
177 m_muonMSOnlyMETrackValidationPlots.emplace_back(
178 std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "MSOnlyMETrackParticles", m_isData));
179
180 if (!m_tracksName.empty()) {
181 m_muonIDTrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDTrackParticles", m_isData));
182 m_muonIDSelectedTrackValidationPlots.emplace_back(
183 std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDSelectedTrackParticles", m_isData));
184 }
185 if (!m_fwdtracksName.empty())
186 m_muonIDForwardTrackValidationPlots.emplace_back(
187 std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDForwardTrackParticles", m_isData));
188
189 if (!m_muonSegmentsName.empty()) {
190 if (category != theMuonCategories.at(ALL)) continue; // cannot identify the truth origin of segments...
191 m_muonSegmentValidationPlots.emplace_back(std::make_unique<MuonSegmentValidationPlots>(nullptr, categoryPath, m_isData));
192 if (!m_isData)
193 m_oUnmatchedRecoMuonSegmentPlots.reset(
194 new Muon::MuonSegmentPlots(nullptr, Form("%s/UnmatchedRecoMuonSegments/", muonContainerName.c_str())));
195 }
196 }
197
198 if (!m_isData) {
199 m_oUnmatchedRecoMuonPlots = std::make_unique<Muon::RecoMuonPlotOrganizer>(nullptr, muonContainerName +"/UnmatchedRecoMuons/");
200 m_oUnmatchedTruthMuonPlots = std::make_unique<Muon::TruthMuonPlotOrganizer>(nullptr, muonContainerName +"/UnmatchedTruthMuons/");
201 }
202
203 for (const auto& plots : m_muonValidationPlots) bookValidationPlots(*plots).ignore();
204 for (const auto& plots : m_slowMuonValidationPlots) bookValidationPlots(*plots).ignore();
205 for (const auto& plots : m_TriggerMuonValidationPlots) bookValidationPlots(*plots).ignore();
206 for (const auto& plots : m_muonIDTrackValidationPlots) bookValidationPlots(*plots).ignore();
207 for (const auto& plots : m_muonIDSelectedTrackValidationPlots) bookValidationPlots(*plots).ignore();
208 for (const auto& plots : m_muonIDForwardTrackValidationPlots) bookValidationPlots(*plots).ignore();
209 for (const auto& plots : m_muonMSTrackValidationPlots) bookValidationPlots(*plots).ignore();
210 for (const auto& plots : m_muonMETrackValidationPlots) bookValidationPlots(*plots).ignore();
211 for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) bookValidationPlots(*plots).ignore();
212 if (!m_isData) {
213 bookValidationPlots(*m_oUnmatchedRecoMuonPlots).ignore();
214 bookValidationPlots(*m_oUnmatchedTruthMuonPlots).ignore();
215 if (m_oUnmatchedRecoMuonTrackPlots) bookValidationPlots(*m_oUnmatchedRecoMuonTrackPlots).ignore();
216 for (const auto& plots : m_muonSegmentValidationPlots) bookValidationPlots(*plots).ignore();
217 if (m_oUnmatchedRecoMuonSegmentPlots) bookValidationPlots(*m_oUnmatchedRecoMuonSegmentPlots).ignore();
218 }
219 // book overview hists
220 m_h_overview_Z_mass = new TH1F(Form("%s_Overview_Z_mass", muonContainerName.c_str()), "", 20, 76, 106);
221 ATH_CHECK(regHist(m_h_overview_Z_mass, Form("%s/Overview", muonContainerName.c_str()), all));
222 m_h_overview_Z_mass_ME = new TH1F(Form("%s_Overview_Z_mass_ME", muonContainerName.c_str()), "", 20, 76, 106);
223 ATH_CHECK(regHist(m_h_overview_Z_mass_ME, Form("%s/Overview", muonContainerName.c_str()), all));
224 m_h_overview_Z_mass_ID = new TH1F(Form("%s_Overview_Z_mass_ID", muonContainerName.c_str()), "", 20, 76, 106);
225 ATH_CHECK(regHist(m_h_overview_Z_mass_ID, Form("%s/Overview", muonContainerName.c_str()), all));
226
227 m_h_overview_nObjects.clear();
228 m_h_overview_nObjects.emplace_back(new TH1F(Form("%s_Overview_N_perevent_truth_muons", muonContainerName.c_str()),
229 "Number of truth Muons per event", 20, -0.5, 19.5));
230 m_h_overview_nObjects.emplace_back(
231 new TH1F(Form("%s_Overview_N_perevent_muons", muonContainerName.c_str()), "Number of Muons per event", 20, -0.5, 19.5));
232 m_h_overview_nObjects.emplace_back(
233 new TH1F(Form("%s_Overview_N_perevent_tracks", muonContainerName.c_str()), "Number of Tracks per event", 50, -0.5, 49.5));
234 m_h_overview_nObjects.emplace_back(new TH1F(Form("%s_Overview_N_perevent_truth_segments", muonContainerName.c_str()),
235 "Number of truth Segments per event", 200, -0.5, 199.5));
236 m_h_overview_nObjects.emplace_back(
237 new TH1F(Form("%s_Overview_N_perevent_segments", muonContainerName.c_str()), "Number of Segments per event", 200, -0.5, 199.5));
238 for (const auto& hist : m_h_overview_nObjects) {
239 if (hist) ATH_CHECK(regHist(hist, Form("%s/Overview", muonContainerName.c_str()), all));
240 }
241
242 m_h_overview_reco_category =
243 new TH1F(Form("%s_Overview_reco_category", muonContainerName.c_str()), "", 4, 0, 4); // prompt/in-flight/non-isolated/other
244 for (int i = 1; i < 4; i++) { // skip 'All'
245 m_h_overview_reco_category->GetXaxis()->SetBinLabel(i, theMuonCategories.at(i).c_str());
246 }
247 m_h_overview_reco_category->GetXaxis()->SetBinLabel(4, "Other"); // of some other origin or fakes
248 ATH_CHECK(regHist(m_h_overview_reco_category, Form("%s/Overview", muonContainerName.c_str()), all));
249
250 int nAuth = xAOD::Muon::NumberOfMuonAuthors;
251 for (int i = 1; i < 4; i++) {
252 m_h_overview_reco_authors.emplace_back(new TH1F((muonContainerName + "_" + theMuonCategories.at(i) + "_reco_authors").c_str(),
253 (muonContainerName + "_" + theMuonCategories.at(i) + "_reco_authors").c_str(),
254 nAuth + 1, -0.5, nAuth + 0.5));
255 }
256 m_h_overview_reco_authors.emplace_back(new TH1F((muonContainerName + "_Overview_Other_reco_authors").c_str(),
257 (muonContainerName + "_Other_reco_authors").c_str(), nAuth + 1, -0.5, nAuth + 0.5));
258
259 for (const auto& hist : m_h_overview_reco_authors) {
260 if (hist) ATH_CHECK(regHist(hist, Form("%s/Overview", muonContainerName.c_str()), all));
261 }
262
263 return StatusCode::SUCCESS;
264 }//bookHistograms*/
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ManagedMonitorToolBase::regHist
virtual StatusCode regHist(TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical ...
Definition ManagedMonitorToolBase.cxx:1344
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonSegmentPlots
std::unique_ptr< Muon::MuonSegmentPlots > m_oUnmatchedRecoMuonSegmentPlots
Definition MuonPhysValMonitoringTool.h:194
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentValidationPlots
std::vector< std::unique_ptr< MuonSegmentValidationPlots > > m_muonSegmentValidationPlots
Definition MuonPhysValMonitoringTool.h:190
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedTruthMuonPlots
std::unique_ptr< Muon::TruthMuonPlotOrganizer > m_oUnmatchedTruthMuonPlots
Definition MuonPhysValMonitoringTool.h:192
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonValidationPlots
std::vector< std::unique_ptr< SlowMuonValidationPlots > > m_slowMuonValidationPlots
Definition MuonPhysValMonitoringTool.h:196
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonPlots
std::unique_ptr< Muon::RecoMuonPlotOrganizer > m_oUnmatchedRecoMuonPlots
Definition MuonPhysValMonitoringTool.h:191
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonTrackPlots
std::unique_ptr< Muon::RecoMuonTrackPlotOrganizer > m_oUnmatchedRecoMuonTrackPlots
Definition MuonPhysValMonitoringTool.h:193
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDForwardTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDForwardTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:189
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMETrackValidationPlots
Definition MuonPhysValMonitoringTool.h:185
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_TriggerMuonValidationPlots
std::vector< std::unique_ptr< TriggerMuonValidationPlots > > m_TriggerMuonValidationPlots
Definition MuonPhysValMonitoringTool.h:183
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:184
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonAuthors
Gaudi::Property< std::vector< unsigned int > > m_selectMuonAuthors
Definition MuonPhysValMonitoringTool.h:145
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_L1MuonItems
Gaudi::Property< std::vector< std::string > > m_L1MuonItems
Definition MuonPhysValMonitoringTool.h:152
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategories
Gaudi::Property< std::vector< unsigned int > > m_selectMuonCategories
Definition MuonPhysValMonitoringTool.h:153
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonValidationPlots
std::vector< std::unique_ptr< MuonValidationPlots > > m_muonValidationPlots
Definition MuonPhysValMonitoringTool.h:182
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonWPs
Gaudi::Property< std::vector< int > > m_selectMuonWPs
Definition MuonPhysValMonitoringTool.h:143
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectHLTMuonItems
Gaudi::Property< std::vector< std::vector< std::string > > > m_selectHLTMuonItems
Definition MuonPhysValMonitoringTool.h:151
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSOnlyMETrackValidationPlots
Definition MuonPhysValMonitoringTool.h:186
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:187
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDSelectedTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDSelectedTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:188
python.TrigEgammaMonitorHelper.TH1F
TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition TrigEgammaMonitorHelper.py:24

◆ bookHistogramsRecurrent()

StatusCode ManagedMonitorToolBase::bookHistogramsRecurrent ( )
virtualinherited

An inheriting class should either override this function, bookHists() or bookHistograms().

Reimplemented in ManagedMonitorToolTest, MdtVsRpcRawDataValAlg, and MdtVsTgcRawDataValAlg.

Definition at line 1284 of file ManagedMonitorToolBase.cxx.

1286{
1287 if( m_newEventsBlock ) { }
1288 if( m_newLumiBlock ) { }
1289 if( m_newRun ) { }
1290
1291 return StatusCode::SUCCESS;
1292}

◆ bookHists()

StatusCode ManagedMonitorToolBase::bookHists ( )
virtualinherited

Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.

Implements IMonitorToolBase.

Reimplemented in TileDigitsMonTool, and TileRawChannelMonTool.

Definition at line 729 of file ManagedMonitorToolBase.cxx.

731{
732 // The Run/LumiBlock numbers are not set when beginRun() is called. Therefore,
733 // book histograms on the first call to fillHists(), which is called from execute().
734 return StatusCode::SUCCESS;
735}

◆ bookValidationPlots()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::bookValidationPlots ( PlotBase & valPlots)
private

Definition at line 266 of file MuonPhysValMonitoringTool.cxx.

266 {
267 valPlots.initialize();
268 std::vector<HistData> hists = valPlots.retrieveBookedHistograms();
269
270 for (auto& hist : hists) {
271 TString sHistName = hist.first->GetName();
272 ATH_MSG_VERBOSE("Initializing " << hist.first << " " << sHistName << " " << hist.second << "...");
273
274 // check for histograms that are useless and skip regHist:
275 if (sHistName.Contains("momentumPulls")) {
276 if (sHistName.Contains(Muon::EnumDefs::toString(xAOD::Muon::MuidSA))) continue; // empty for standalone muons
277 if (!(sHistName.Contains("Prompt") && (sHistName.Contains("AllMuons") || sHistName.Contains("SiAssocForward"))))
278 continue; // don't need binned eloss plots for separate muon types, keep only for Prompt AllMuons
279 }
280 if ((sHistName.Contains("resolution") || sHistName.Contains("pulls")) && !sHistName.Contains("Prompt"))
281 continue; // don't need resolution plots except for prompt muons
282 if (sHistName.Contains("trigger") && sHistName.Contains("wrt") && sHistName.Contains("Features")) continue;
283 modifyHistogram(hist.first);
284 ATH_CHECK(regHist(hist.first, hist.second, all));
285 }
286
287 // register trees
288 std::vector<TreeData> trees = valPlots.retrieveBookedTrees();
289 for (auto& tree : trees) {
290 std::string sTreeName = tree.first->GetName();
291 ATH_MSG_VERBOSE("Initializing " << tree.first << " " << sTreeName << " " << tree.second << "...");
292 ATH_CHECK(regTree(tree.first, tree.second, all));
293 }
294
295 return StatusCode::SUCCESS;
296 }
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ManagedMonitorToolBase::regTree
virtual StatusCode regTree(TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TTree to be included in the output stream using logical parameters that describe it.
Definition ManagedMonitorToolBase.cxx:1545
PlotBase::retrieveBookedHistograms
std::vector< HistData > retrieveBookedHistograms()
Retrieve all booked histograms.
Definition PlotBase.cxx:63
PlotBase::initialize
void initialize()
Definition PlotBase.cxx:39
PlotBase::retrieveBookedTrees
std::vector< TreeData > retrieveBookedTrees()
Retrieve all booked trees.
Definition PlotBase.cxx:73
Muon::EnumDefs::toString
static const char * toString(Muon::EnumDefs::DetRegion reg)
Definition MuonEnumDefs.h:14
tree
TChain * tree
Definition tile_monitor.h:30

◆ checkHists()

StatusCode ManagedMonitorToolBase::checkHists ( bool calledFromFinalize)
virtualinherited

This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.

Implements IMonitorToolBase.

Reimplemented in CscCalibMonToolBase, TileCellNoiseMonTool, TileDigitsMonTool, and TileRawChannelMonTool.

Definition at line 1669 of file ManagedMonitorToolBase.cxx.

1671{
1672 // Histograms will be checked using the data-quality monitoring framework (DQMF)
1673
1674 return StatusCode::SUCCESS;
1675}

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph * g)
virtualinherited

De-registers a TGraph from the THistSvc, but does NOT delete the object.

Definition at line 1623 of file ManagedMonitorToolBase.cxx.

1625{
1626 return m_THistSvc->deReg( g );
1627}
ManagedMonitorToolBase::m_THistSvc
ServiceHandle< ITHistSvc > m_THistSvc
Definition ManagedMonitorToolBase.h:843

◆ deregHist()

StatusCode ManagedMonitorToolBase::deregHist ( TH1 * h)
virtualinherited

De-registers a TH1 from the THistSvc, but does NOT delete the object.

Definition at line 1615 of file ManagedMonitorToolBase.cxx.

1617{
1618 return m_THistSvc->deReg( h );
1619}

◆ deregObject() [1/2]

StatusCode ManagedMonitorToolBase::deregObject ( const std::string & objName,
const MonGroup & group )
virtualinherited

De-registers a TObject from the THistSvc, but does NOT delete the object.

(NB: LightWeight histograms are not even registered until readout).

Definition at line 1641 of file ManagedMonitorToolBase.cxx.

1643{
1644 std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
1645 return m_THistSvc->deReg( streamName );
1646}
ManagedMonitorToolBase::StreamNameFcn::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)=0
A function that converts a MonGroup of logical parameters into a physical output stream name.
ManagedMonitorToolBase::streamNameFunction
virtual StreamNameFcn * streamNameFunction()
Returns the function object that converts logical paramters into a physical stream name.
Definition ManagedMonitorToolBase.cxx:451

◆ deregObject() [2/2]

StatusCode ManagedMonitorToolBase::deregObject ( const std::string & objName,
const std::string & system,
Interval_t interval )
virtualinherited

De-registers a TObject from the THistSvc, but does NOT delete the object.

(NB: LightWeight histograms are not even registered until readout).

Definition at line 1631 of file ManagedMonitorToolBase.cxx.

1634{
1635 MonGroup group( this, system, interval );
1636 return deregObject( objName, group );
1637}
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition ManagedMonitorToolBase.h:137
ManagedMonitorToolBase::deregObject
virtual StatusCode deregObject(const std::string &objName, const std::string &system, Interval_t interval)
De-registers a TObject from the THistSvc, but does NOT delete the object.
Definition ManagedMonitorToolBase.cxx:1632
CaloLCW_tf.group
group
Definition CaloLCW_tf.py:28

◆ detStore()

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

◆ EFTriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::EFTriggerResolution ( )
private

Definition at line 1232 of file MuonPhysValMonitoringTool.cxx.

1232 {
1233 int k_EFMu_MinDeltaR = -1;
1234 float MinDeltaR = 0.;
1235 std::vector<int> vAvailableAuthors;
1236 vAvailableAuthors.clear();
1237 vAvailableAuthors.emplace_back(m_vEFMuons[0]->author());
1238 unsigned int iter = 0;
1239 for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1240 iter = 0;
1241 for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1242 if (m_vEFMuons[k]->author() != vAvailableAuthors[l]) iter++;
1243 }
1244 if (iter == vAvailableAuthors.size()) vAvailableAuthors.emplace_back(m_vEFMuons[k]->author());
1245 }
1246 ATH_MSG_DEBUG(" m_vEFMuons.size()" << m_vEFMuons.size());
1247 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1248 ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1249 << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1250 }
1251 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1252 if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1253 ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1254 << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1255 for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1256 k_EFMu_MinDeltaR = -1;
1257 MinDeltaR = 1000;
1258 for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1259 ATH_MSG_DEBUG(" :::::::: TEST: EF pt=" << m_vEFMuons.at(k)->pt() << " eta=" << m_vEFMuons.at(k)->eta()
1260 << " phi=" << m_vEFMuons.at(k)->phi()
1261 << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k))
1262 << " author=" << m_vEFMuons.at(k)->author());
1263 if (m_vEFMuons.at(k)->author() == vAvailableAuthors.at(l) &&
1264 (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < 0.1 &&
1265 (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < MinDeltaR))) {
1266 k_EFMu_MinDeltaR = k;
1267 MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k));
1268 }
1269 }
1270 if (k_EFMu_MinDeltaR == -1) continue;
1271 for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1272 if (m_selectMuonCategories[c] == ALL) {
1273 m_TriggerMuonValidationPlots[c]->fill(*m_vEFMuons.at(k_EFMu_MinDeltaR), *m_vRecoMuons.at(i));
1274 }
1275 }
1276 }
1277 }
1278 }
deltaR
Scalar deltaR(const MatrixBase< Derived > &vec) const
Definition AmgMatrixBasePlugin.h:105
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
CaloCondBlobAlgs_fillNoiseFromASCII.author
str author
Definition CaloCondBlobAlgs_fillNoiseFromASCII.py:25
PrintTrkAnaSummary.l
l
Printing final latex table to .tex output file.
Definition PrintTrkAnaSummary.py:370

◆ endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 794 of file ManagedMonitorToolBase.h.

794{ return m_endOfEventsBlock; }

◆ endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 795 of file ManagedMonitorToolBase.h.

795{ return m_endOfLowStat; }

◆ endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 796 of file ManagedMonitorToolBase.h.

796{ return m_endOfLumiBlock; }

◆ endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const
inlineprotectedinherited

Definition at line 797 of file ManagedMonitorToolBase.h.

797{ return m_endOfRun; }

◆ evtStore()

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

◆ extraDeps_update_handler()

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

◆ fillHistograms()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::fillHistograms ( )
overridevirtual

An inheriting class should either override this function or fillHists().

Reimplemented from ManagedMonitorToolBase.

Definition at line 298 of file MuonPhysValMonitoringTool.cxx.

298 {
299 ATH_MSG_DEBUG("Filling hists " << name() << "...");
300 m_vMatchedTruthMuons.clear();
301 m_vMatchedMuons.clear();
302 m_vMatchedSlowMuons.clear();
303 m_vMatchedMuonTracks.clear();
304 m_vMatchedMuonSegments.clear();
305 m_vZmumuIDTracks.clear();
306 m_vZmumuMETracks.clear();
307 m_vZmumuMuons.clear();
308 m_vEFMuons.clear();
309 m_vEFMuonsSelected.clear();
310 m_vL2SAMuons.clear();
311 m_vL2SAMuonsSelected.clear();
312 m_vL2CBMuons.clear();
313 m_vL2CBMuonsSelected.clear();
314 m_vRecoMuons.clear();
315 m_vRecoMuons_EffDen.clear();
316 m_vRecoMuons_EffDen_CB.clear();
317 m_vRecoMuons_EffDen_MS.clear();
318
319 const EventContext& ctx{Gaudi::Hive::currentContext()};
320 const xAOD::EventInfo* eventInfo{nullptr};
321 ATH_CHECK(retrieveContainer(ctx, m_eventInfo, eventInfo));
322
323 float beamSpotWeight = eventInfo->beamSpotWeight();
324
325 const xAOD::TruthParticleContainer* TruthMuons{nullptr};
326 ATH_CHECK(retrieveContainer(ctx, m_muonsTruthName, TruthMuons));
327
328 if (!m_isData) {
329 m_h_overview_nObjects[0]->Fill(TruthMuons->size(), beamSpotWeight);
330 }
331
332 const xAOD::MuonContainer* Muons = nullptr;
333 const xAOD::SlowMuonContainer* SlowMuons{nullptr};
334 ATH_CHECK(retrieveContainer(ctx, m_slowMuonsName, SlowMuons));
335 ATH_CHECK(retrieveContainer(ctx, m_muonsName, Muons));
336 if (SlowMuons) {
337 ATH_MSG_DEBUG("Retrieved slow muons " << SlowMuons->size());
338 m_h_overview_nObjects[1]->Fill(SlowMuons->size(), beamSpotWeight);
339 }
340 if (Muons) {
341 ATH_MSG_DEBUG("Retrieved muons " << Muons->size());
342 m_h_overview_nObjects[1]->Fill(Muons->size(), beamSpotWeight);
343 }
344
346 // @@@ Temp hack to get the MuonSpectrometerTrackParticle (@MS Entry, not extrapolated), needed for eloss plots
347 // Remove when the link to the real MuonSpectrometerTrackParticle appears in the xAOD muon
348 ATH_CHECK(retrieveContainer(ctx, m_muonTracksName, m_MSTracks));
350
351 // Do resonance selection
352 std::vector<std::pair<const xAOD::Muon*, const xAOD::Muon*> > pairs;
353 if (Muons) {
354 // Use iterator loop to avoid double counting
355 for (xAOD::MuonContainer::const_iterator mu1_itr = Muons->begin(); mu1_itr != Muons->end(); ++mu1_itr) {
356 const xAOD::Muon* mu1 = (*mu1_itr);
357 if (!m_selectComissioning && mu1->allAuthors() & comm_bit) continue;
358 for (xAOD::MuonContainer::const_iterator mu2_itr = Muons->begin(); mu2_itr != mu1_itr; ++mu2_itr) {
359 const xAOD::Muon* mu2 = (*mu2_itr);
360 if (!m_selectComissioning && mu2->allAuthors() & comm_bit) continue;
361 if (mu1->charge() * mu2->charge() >= 0) continue;
362 pairs.emplace_back(std::make_pair(mu1, mu2));
363 }
364 }
365 }
366
367 float dMmin {1e10}, mZ{0.};
368 for (std::pair<const xAOD::Muon*, const xAOD::Muon*>& x : pairs) {
369 // select best Z
370 const TLorentzVector mu1{x.first->p4()}, mu2{x.second->p4()};
371 const float M = (mu1 + mu2).M();
372 if (M < 66000. || M > 116000.) continue;
373
374 // choose the Z candidate closest to the Z pole - if multiple exist
375 float dM = std::abs(M - 91187.);
376 if (dM > dMmin) continue;
377 dMmin = dM;
378 mZ = M;
379
380 m_vZmumuMuons.clear();
381 m_vZmumuMuons.emplace_back(x.first);
382 m_vZmumuMuons.emplace_back(x.second);
383 }
384
385 if (m_vZmumuMuons.size() == 2) {
386 m_h_overview_Z_mass->Fill(mZ / 1000., beamSpotWeight);
387
388 const xAOD::TrackParticle* metr1 = m_vZmumuMuons[0]->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
389 const xAOD::TrackParticle* metr2 = m_vZmumuMuons[1]->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
390 if (metr1 && metr2) {
391 const TLorentzVector mu1ME{metr1->p4()}, mu2ME{metr2->p4()};
392 m_h_overview_Z_mass_ME->Fill((mu1ME + mu2ME).M() / 1000., beamSpotWeight);
393 if (m_isData) {
394 m_vZmumuMETracks.clear();
395 m_vZmumuMETracks.emplace_back(metr1);
396 m_vZmumuMETracks.emplace_back(metr2);
397 }
398 }
399
400 const xAOD::TrackParticle* tr1 = m_vZmumuMuons[0]->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
401 const xAOD::TrackParticle* tr2 = m_vZmumuMuons[1]->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
402 if (tr1 && tr2) {
403 const TLorentzVector mu1ID{tr1->p4()}, mu2ID{tr2->p4()};
404 m_h_overview_Z_mass_ID->Fill((mu1ID + mu2ID).M() / 1000., beamSpotWeight);
405 if (m_isData) {
406 m_vZmumuIDTracks.clear();
407 m_vZmumuIDTracks.emplace_back(tr1);
408 m_vZmumuIDTracks.emplace_back(tr2);
409 }
410 }
411 }
412
413 if (!m_isData) {
414 for (const auto truthMu : *TruthMuons) handleTruthMuon(truthMu, beamSpotWeight);
415 }
416
417 if (SlowMuons) {
418 for (const auto smu : *SlowMuons) {
419 if (!smu) continue;
420 const MuonLink link = smu->muonLink();
421 if (!link.isValid()) continue;
422 handleMuon(*link, smu, beamSpotWeight);
423 }
424 }
425 if (Muons) {
426 for (const xAOD::Muon* mu : *Muons) {
427 handleMuon(mu, nullptr, beamSpotWeight);
428 }
429 }
430
431 const xAOD::TrackParticleContainer* IDTracks{nullptr};
432 ATH_CHECK(retrieveContainer(ctx, m_tracksName, IDTracks));
433 if (IDTracks) {
434 ATH_MSG_DEBUG("handling " << IDTracks->size() << " " << m_tracksName);
435 for (const auto tp : *IDTracks) handleMuonTrack(tp, xAOD::Muon::InnerDetectorTrackParticle, beamSpotWeight);
436 }
437 const xAOD::TrackParticleContainer* FwdIDTracks{nullptr};
438 ATH_CHECK(retrieveContainer(ctx, m_fwdtracksName, IDTracks));
439 if (FwdIDTracks) {
440 ATH_MSG_DEBUG("handling " << FwdIDTracks->size() << " " << m_fwdtracksName);
441 for (const auto tp : *FwdIDTracks) handleMuonTrack(tp, xAOD::Muon::InnerDetectorTrackParticle, beamSpotWeight);
442 }
443 const xAOD::TrackParticleContainer* MuonTracks{nullptr};
444 ATH_CHECK(retrieveContainer(ctx, m_muonTracksName, MuonTracks));
445 if (MuonTracks) {
446 ATH_MSG_DEBUG("handling " << MuonTracks->size() << " " << m_muonTracksName);
447 m_h_overview_nObjects[2]->Fill(MuonTracks->size(), beamSpotWeight);
448 for (const auto tp : *MuonTracks) handleMuonTrack(tp, xAOD::Muon::MuonSpectrometerTrackParticle, beamSpotWeight);
449 }
450 const xAOD::TrackParticleContainer* MuonExtrapolatedTracks{nullptr};
451 ATH_CHECK(retrieveContainer(ctx, m_muonExtrapolatedTracksName, MuonExtrapolatedTracks));
452 if (MuonExtrapolatedTracks) {
453 ATH_MSG_DEBUG("handling " << MuonExtrapolatedTracks->size() << " " << m_muonExtrapolatedTracksName);
454 for (const auto tp : *MuonExtrapolatedTracks)
455 handleMuonTrack(tp, xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, beamSpotWeight);
456 }
457 const xAOD::TrackParticleContainer* MSOnlyMuonExtrapolatedTracks{nullptr};
458 ATH_CHECK(retrieveContainer(ctx, m_muonMSOnlyExtrapolatedTracksName, MSOnlyMuonExtrapolatedTracks));
459
460 if (MSOnlyMuonExtrapolatedTracks) {
461 ATH_MSG_DEBUG("handling " << MSOnlyMuonExtrapolatedTracks->size() << " " << m_muonMSOnlyExtrapolatedTracksName);
462 for (const auto tp : *MSOnlyMuonExtrapolatedTracks)
463 handleMuonTrack(tp, xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle, beamSpotWeight);
464 }
465
466 const xAOD::MuonSegmentContainer* TruthMuonSegments{nullptr};
467 ATH_CHECK(retrieveContainer(ctx, m_muonSegmentsTruthName, TruthMuonSegments));
468 if (TruthMuonSegments) {
469 m_h_overview_nObjects[3]->Fill(TruthMuonSegments->size(), beamSpotWeight);
470 ATH_MSG_DEBUG("handling " << TruthMuonSegments->size() << " " << m_muonSegmentsTruthName);
471 for (const auto truthMuSeg : *TruthMuonSegments) handleTruthMuonSegment(truthMuSeg, TruthMuons, beamSpotWeight);
472 }
473
474 const xAOD::MuonSegmentContainer* MuonSegments{nullptr};
475 ATH_CHECK(retrieveContainer(ctx, m_muonSegmentsName, MuonSegments));
476 if (MuonSegments) {
477 m_h_overview_nObjects[4]->Fill(MuonSegments->size(), beamSpotWeight);
478 ATH_MSG_DEBUG("handling " << MuonSegments->size() << " " << m_muonSegmentsName);
479 for (const auto muSeg : *MuonSegments) handleMuonSegment(muSeg, beamSpotWeight);
480 }
481
482 //@@@@@@@@@@@@@@@@ TRIGGER MONITORING IMPLEMENTATION @@@@@@@@@@@@@@@@@
483 if (m_doTrigMuonValidation) {
484 auto chainGroups = m_trigDec->getChainGroup("HLT_.*mu.*");
485 for (auto& trig : chainGroups->getListOfTriggers()) {
486 if (m_trigDec->isPassed(trig, TrigDefs::EF_passedRaw)) {
487 ATH_MSG_DEBUG("Chain " << trig << " is passed: YES");
488 } else
489 ATH_MSG_DEBUG("Chain " << trig << " is passed: NO");
490 }
491 auto L1chainGroups = m_trigDec->getChainGroup("L1_MU.*");
492 for (auto& L1trig : L1chainGroups->getListOfTriggers()) {
493 if (m_trigDec->isPassed(L1trig, TrigDefs::EF_passedRaw))
494 ATH_MSG_DEBUG("Chain " << L1trig << " is passed: YES");
495 else
496 ATH_MSG_DEBUG("Chain " << L1trig << " is passed: NO");
497 }
498 for (auto mu : m_vRecoMuons) {
499 if (passesAcceptanceCuts(mu) && std::abs(mu->eta()) < 2.4) {
500 if (mu->author() == 1) {
501 m_vRecoMuons_EffDen_CB.emplace_back(mu);
502 ATH_MSG_DEBUG("##### m_vRecoMuons_EffDen_CB pt:" << mu->pt() << " phi:" << mu->phi() << " eta:" << mu->eta());
503 } else if (mu->author() == 5) {
504 m_vRecoMuons_EffDen_MS.emplace_back(mu);
505 ATH_MSG_DEBUG("##### m_vRecoMuons_EffDen_MS pt:" << mu->pt() << " phi:" << mu->phi() << " eta:" << mu->eta());
506 }
507 }
508 }
509
510 //@@@@@ L1 @@@@@
511 if (m_doTrigMuonL1Validation) {
512 const xAOD::MuonRoIContainer* L1TrigMuons{nullptr};
513 ATH_CHECK(retrieveContainer(ctx, m_muonL1TrigName, L1TrigMuons));
514 ATH_MSG_DEBUG("Retrieved L1 triggered muons " << L1TrigMuons->size());
515 for (const auto TrigL1mu : *L1TrigMuons) handleMuonL1Trigger(TrigL1mu);
516 }
517
518 //@@@@@ L2 @@@@@
519 if (m_doTrigMuonL2Validation) {
520 //@@@@@ L2SA @@@@@
521 const xAOD::L2StandAloneMuonContainer* L2SAMuons{nullptr};
522 ATH_CHECK(retrieveContainer(ctx, m_muonL2SAName, L2SAMuons));
523 ATH_MSG_DEBUG("Retrieved L2 StandAlone triggered muons " << L2SAMuons->size());
524 if (L2SAMuons->size() != 0) {
525 for (const auto L2SAmu : *L2SAMuons) {
526 ATH_MSG_DEBUG("Muon L2SA Trigger: pt " << L2SAmu->pt() << " phi " << L2SAmu->phi() << " eta " << L2SAmu->eta()
527 << " roiWord " << L2SAmu->roiWord() << " sAddress " << L2SAmu->sAddress());
528 m_vL2SAMuons.emplace_back(L2SAmu);
529 }
530 for (const auto& mu : m_vL2SAMuons) {
531 if (mu->pt() != 0.) {
532 m_vL2SAMuonsSelected.emplace_back(mu);
533 break;
534 }
535 }
536 for (unsigned int i = 0; i < m_vL2SAMuons.size(); i++) {
537 unsigned int cont = 0;
538 for (unsigned int j = 0; j < m_vL2SAMuonsSelected.size(); j++) {
539 if (((m_vL2SAMuons.at(i)->pt()) != 0.) && ((deltaR(m_vL2SAMuonsSelected.at(j), m_vL2SAMuons.at(i))) > 0.1))
540 cont++;
541 if (cont == m_vL2SAMuonsSelected.size()) {
542 m_vL2SAMuonsSelected.emplace_back(m_vL2SAMuons.at(i));
543 break;
544 }
545 }
546 }
547 for (unsigned int i = 0; i < m_vL2SAMuonsSelected.size(); i++) { handleMuonL2Trigger(m_vL2SAMuonsSelected.at(i)); }
548 L2SATriggerResolution();
549 }
550 for (const auto& muonItem : m_muonItems) {
551 std::vector<Trig::Feature<xAOD::L2StandAloneMuonContainer> > vec_muons;
552 TString muonItem_str = (TString)muonItem;
553 if (muonItem_str.Contains("_OR_")) {
554 muonItem_str.ReplaceAll("_OR_", " ");
555 TString delim = " ";
556 std::vector<TString> v_subchains;
557 SplitString(muonItem_str, delim, v_subchains);
558 for (int i = 0; i < (int)v_subchains.size(); i++) {
559 Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
560 std::vector<Trig::Feature<xAOD::L2StandAloneMuonContainer> > vec_muons_1 =
561 fc1.get<xAOD::L2StandAloneMuonContainer>();
562 for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
563 }
564 } else {
565 Trig::FeatureContainer fc = m_trigDec->features(muonItem);
566 vec_muons = fc.get<xAOD::L2StandAloneMuonContainer>();
567 }
568 ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::L2StandAloneMuonContainer> for chain " << muonItem << " = "
569 << vec_muons.size());
570 for (const auto& mufeat : vec_muons) {
571 ATH_MSG_DEBUG(muonItem << " vec_muons.size() = " << vec_muons.size()
572 << " mufeat.cptr()->size() = " << mufeat.cptr()->size());
573 for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
574 ATH_MSG_DEBUG("#####" << muonItem << " L2SA feature pt: " << (*mufeat.cptr())[i]->pt()
575 << " eta: " << (*mufeat.cptr())[i]->eta() << " phi: " << (*mufeat.cptr())[i]->phi());
576 }
577 }
578 }
579
580 //@@@@@ L2CB @@@@@
581
582 const xAOD::L2CombinedMuonContainer* L2CBMuons{nullptr};
583 ATH_CHECK(retrieveContainer(ctx, m_muonL2CBName, L2CBMuons));
584 ATH_MSG_DEBUG("Retrieved L2 Combined triggered muons " << L2CBMuons->size());
585 if (L2CBMuons->size() != 0) {
586 for (const auto L2CBmu : *L2CBMuons) {
587 ATH_MSG_DEBUG("Muon L2CB Trigger: pt " << L2CBmu->pt() << " phi " << L2CBmu->phi() << " eta " << L2CBmu->eta());
588 m_vL2CBMuons.emplace_back(L2CBmu);
589 }
590 for (unsigned int i = 0; i < m_vL2CBMuons.size(); i++) {
591 if ((m_vL2CBMuons.at(i)->pt()) != 0.) {
592 m_vL2CBMuonsSelected.emplace_back(m_vL2CBMuons.at(i));
593 break;
594 }
595 }
596 for (unsigned int i = 0; i < m_vL2CBMuons.size(); i++) {
597 unsigned int cont = 0;
598 for (unsigned int j = 0; j < m_vL2CBMuonsSelected.size(); j++) {
599 if (((m_vL2CBMuons.at(i)->pt()) != 0.) && ((deltaR(m_vL2CBMuonsSelected.at(j), m_vL2CBMuons.at(i))) > 0.1))
600 cont++;
601 if (cont == m_vL2CBMuonsSelected.size()) {
602 m_vL2CBMuonsSelected.emplace_back(m_vL2CBMuons.at(i));
603 break;
604 }
605 }
606 }
607 for (unsigned int i = 0; i < m_vL2CBMuonsSelected.size(); i++) { handleMuonL2Trigger(m_vL2CBMuonsSelected.at(i)); }
608 L2CBTriggerResolution();
609 }
610 for (const auto& muonItem : m_muonItems) {
611 std::vector<Trig::Feature<xAOD::L2CombinedMuonContainer> > vec_muons;
612 TString muonItem_str = (TString)muonItem;
613 if (muonItem_str.Contains("_OR_")) {
614 muonItem_str.ReplaceAll("_OR_", " ");
615 TString delim = " ";
616 std::vector<TString> v_subchains;
617 SplitString(muonItem_str, delim, v_subchains);
618 for (int i = 0; i < (int)v_subchains.size(); i++) {
619 Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
620 std::vector<Trig::Feature<xAOD::L2CombinedMuonContainer> > vec_muons_1 =
621 fc1.get<xAOD::L2CombinedMuonContainer>();
622 for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
623 }
624 } else {
625 Trig::FeatureContainer fc = m_trigDec->features(muonItem);
626 vec_muons = fc.get<xAOD::L2CombinedMuonContainer>();
627 }
628 ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::L2CombinedMuonContainer> for chain " << muonItem << " = "
629 << vec_muons.size());
630 for (const auto& mufeat : vec_muons) {
631 ATH_MSG_DEBUG(muonItem << " vec_muons.size() = " << vec_muons.size()
632 << " mufeat.cptr()->size() = " << mufeat.cptr()->size());
633 for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
634 ATH_MSG_DEBUG("#####" << muonItem << " L2CB feature pt: " << (*mufeat.cptr())[i]->pt()
635 << " eta: " << (*mufeat.cptr())[i]->eta() << " phi: " << (*mufeat.cptr())[i]->phi());
636 }
637 }
638 }
639 } // close if(m_doTrigMuonL2Validation)
640
641 //@@@@@ EF @@@@@
642 if (m_doTrigMuonEFValidation) {
643 const xAOD::MuonContainer* EFCombTrigMuons{nullptr};
644 const xAOD::MuonRoIContainer* L1TrigMuons{nullptr};
645 ATH_CHECK(retrieveContainer(ctx, m_muonEFCombTrigName, EFCombTrigMuons));
646 ATH_CHECK(retrieveContainer(ctx, m_muonL1TrigName, L1TrigMuons));
647 ATH_MSG_DEBUG("Retrieved EF triggered muons " << EFCombTrigMuons->size());
648 if (EFCombTrigMuons->size() != 0) {
649 for (const auto Trigmu : *EFCombTrigMuons) {
650 ATH_MSG_DEBUG("Muon EF Trigger: pt " << Trigmu->pt() << " phi " << Trigmu->phi() << " eta " << Trigmu->eta()
651 << " author" << Trigmu->author());
652 m_vEFMuons.emplace_back(Trigmu);
653 }
654 m_vEFMuonsSelected.emplace_back(m_vEFMuons.at(0));
655 for (unsigned int i = 0; i < m_vEFMuons.size(); i++) {
656 unsigned int cont = 0;
657 for (unsigned int j = 0; j < m_vEFMuonsSelected.size(); j++) {
658 if (((deltaR(m_vEFMuonsSelected.at(j), m_vEFMuons.at(i))) > 0.1) ||
659 ((m_vEFMuons.at(i)->author() - m_vEFMuonsSelected.at(j)->author()) != 0))
660 cont++;
661 if (cont == m_vEFMuonsSelected.size()) {
662 m_vEFMuonsSelected.emplace_back(m_vEFMuons.at(i));
663 break;
664 }
665 }
666 }
667 for (unsigned int i = 0; i < m_vEFMuonsSelected.size(); i++) { handleMuonTrigger(m_vEFMuonsSelected.at(i)); }
668 EFTriggerResolution();
669 }
670 if (!m_isData) {
671 for (const auto truthMu : *TruthMuons) {
672 ATH_MSG_DEBUG("TRUTH:: pt=" << truthMu->pt() << " eta=" << truthMu->eta() << " phi=" << truthMu->phi());
673 }
674 }
675 // handleMuonTrigger_ResoWRTTruth(m_vEFMuonsSelected,)
676 //@@@@@ chains efficiency @@@@@
677 for (const auto& muonItem : m_muonItems) {
678 m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
679 m_SelectedAuthor = 1;
680 if ((muonItem.find("msonly") != std::string::npos)) {
681 m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_MS;
682 m_SelectedAuthor = 5;
683 }
684 std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons;
685 TString muonItem_str = (TString)muonItem;
686 if (muonItem_str.Contains("_OR_")) {
687 muonItem_str.ReplaceAll("_OR_", " ");
688 TString delim = " ";
689 std::vector<TString> v_subchains;
690 SplitString(muonItem_str, delim, v_subchains);
691 for (int i = 0; i < (int)v_subchains.size(); i++) {
692 Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
693 std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons_1 = fc1.get<xAOD::MuonContainer>();
694 for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
695 }
696 } else {
697 Trig::FeatureContainer fc = m_trigDec->features(muonItem);
698 vec_muons = fc.get<xAOD::MuonContainer>();
699 }
700 ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::MuonContainer> for chain " << muonItem << " = " << vec_muons.size());
701 for (const auto& mufeat : vec_muons) {
702 ATH_MSG_DEBUG(muonItem << " vec_muons.size() = " << vec_muons.size()
703 << " mufeat.cptr()->size() = " << mufeat.cptr()->size());
704 for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
705 ATH_MSG_DEBUG("#####" << muonItem << " EF feature pt: " << (*mufeat.cptr())[i]->pt()
706 << " eta: " << (*mufeat.cptr())[i]->eta() << " phi: " << (*mufeat.cptr())[i]->phi()
707 << " author: " << (*mufeat.cptr())[i]->author());
708 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
709 if (m_selectMuonCategories[j] == ALL) {
710 if (((*mufeat.cptr())[i]->author()) == m_SelectedAuthor)
711 m_TriggerMuonValidationPlots[j]->fillFeatPlots(*(*mufeat.cptr())[i], muonItem);
712 } // if categ=ALL
713 } // categories
714 } // mufeat.cptr
715 } // mufeat
716 for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
717 bool break_flag = false;
718 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
719 if (m_selectMuonCategories[j] == ALL) {
720 m_TriggerMuonValidationPlots[j]->fillDenEff(*m_vRecoMuons_EffDen.at(k), muonItem);
721 }
722 }
723 for (const auto& mufeat : vec_muons) {
724 for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
725 if ((((*mufeat.cptr())[i]->author()) == m_SelectedAuthor) &&
726 (deltaR((*mufeat.cptr())[i], m_vRecoMuons_EffDen.at(k)) < 0.1)) {
727 break_flag = true;
728 ATH_MSG_DEBUG(" $$$ match Reco_EffDen "
729 << muonItem << " pt: " << m_vRecoMuons_EffDen.at(k)->pt() << " eta: "
730 << m_vRecoMuons_EffDen.at(k)->eta() << " phi: " << m_vRecoMuons_EffDen.at(k)->phi()
731 << " author: " << m_vRecoMuons_EffDen.at(k)->author());
732 ATH_MSG_DEBUG(" $$$ match EF MuidCo feature "
733 << muonItem << " pt: " << (*mufeat.cptr())[i]->pt()
734 << " eta: " << (*mufeat.cptr())[i]->eta() << " phi: " << (*mufeat.cptr())[i]->phi()
735 << " author: " << (*mufeat.cptr())[i]->author() << " rel_p "
736 << (std::abs(((*mufeat.cptr())[i]->pt() - m_vRecoMuons_EffDen.at(k)->pt()) /
737 (m_vRecoMuons_EffDen.at(k)->pt()))));
738 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
739 if (m_selectMuonCategories[j] == ALL) {
740 m_TriggerMuonValidationPlots[j]->fillNumEff(*m_vRecoMuons_EffDen.at(k), muonItem);
741 // if (muonItem=="HLT_2mu10") m_TriggerMuonValidationPlots[j]->fill(
742 // *(*mufeat.cptr())[i],*m_vRecoMuons_EffDen.at(k));
743
744 } // if categ=ALL
745 } // categories
746 break;
747 } // if(Delta_R)
748 } // mufeat
749 if (break_flag) break;
750 } // vec_muons
751 } // m_vRecoMuons_EffDen
752 } // m_muonItems
753 //@@@@@ L1 items efficiency @@@@@
754 for (const auto& L1MuonItem : m_L1MuonItems) {
755 m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
756 m_SelectedAuthor = 1;
757 float threshold = 0.;
758 if (L1MuonItem == "L1_MU4") threshold = 4000;
759 else if (L1MuonItem == "L1_MU6") threshold = 6000;
760 else if (L1MuonItem == "L1_MU10") threshold = 10000;
761 else if (L1MuonItem == "L1_MU11") threshold = 11000;
762 else if (L1MuonItem == "L1_MU15") threshold = 15000;
763 else if (L1MuonItem == "L1_MU20") threshold = 20000;
764 for (const auto TrigL1mu : *L1TrigMuons) {
765 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
766 if (m_selectMuonCategories[j] == ALL) {
767 if ((TrigL1mu->thrValue()) >= threshold)
768 m_TriggerMuonValidationPlots[j]->fillFeatPlots(*TrigL1mu, L1MuonItem);
769 } // if categ=ALL
770 } // categories
771 } // L1TrigMuons
772 for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
773 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
774 if (m_selectMuonCategories[j] == ALL) {
775 m_TriggerMuonValidationPlots[j]->fillDenL1Eff(*m_vRecoMuons_EffDen.at(k), L1MuonItem);
776 }
777 }
778 for (const auto TrigL1mu : *L1TrigMuons) {
779 if (((TrigL1mu->thrValue()) >= threshold) &&
780 (sqrt(pow(m_vRecoMuons_EffDen.at(k)->eta() - TrigL1mu->eta(), 2.) +
781 pow(m_vRecoMuons_EffDen.at(k)->phi() - TrigL1mu->phi(), 2.)) < 0.2)) {
782 ATH_MSG_DEBUG(" $$$ match Reco_EffDen "
783 << L1MuonItem << " pt: " << m_vRecoMuons_EffDen.at(k)->pt() << " eta: "
784 << m_vRecoMuons_EffDen.at(k)->eta() << " phi: " << m_vRecoMuons_EffDen.at(k)->phi()
785 << " author: " << m_vRecoMuons_EffDen.at(k)->author());
786 ATH_MSG_DEBUG(" $$$ L1 feature " << L1MuonItem << " pt: " << TrigL1mu->thrValue()
787 << " eta: " << TrigL1mu->eta() << " phi: " << TrigL1mu->phi());
788 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
789 if (m_selectMuonCategories[j] == ALL) {
790 m_TriggerMuonValidationPlots[j]->fillNumL1Eff(*m_vRecoMuons_EffDen.at(k), L1MuonItem);
791 } // if categ=ALL
792 } // categories
793 break;
794 } // if(Delta_R)
795 } // L1TrigMuons
796 } // m_vRecoMuons_EffDen
797 }
798 //@@@@@ chains efficiency w.r.t. L1 @@@@@
799 for (unsigned int m = 0; m < m_muonItems.size(); m++) {
800 std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons;
801 TString muonItem_str = (TString)m_muonItems[m];
802 if (muonItem_str.Contains("_OR_")) {
803 muonItem_str.ReplaceAll("_OR_", " ");
804 TString delim = " ";
805 std::vector<TString> v_subchains;
806 SplitString(muonItem_str, delim, v_subchains);
807 for (int i = 0; i < (int)v_subchains.size(); i++) {
808 Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
809 std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons_1 = fc1.get<xAOD::MuonContainer>();
810 for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
811 }
812 } else {
813 Trig::FeatureContainer fc = m_trigDec->features(m_muonItems[m]);
814 vec_muons = fc.get<xAOD::MuonContainer>();
815 }
816 m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
817 m_SelectedAuthor = 1;
818 if ((m_muonItems[m].find("msonly") != std::string::npos)) {
819 m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_MS;
820 m_SelectedAuthor = 5;
821 }
822 float threshold = 0.;
823 if (m_L1Seed[m] == "L1_MU4") threshold = 4000;
824 if (m_L1Seed[m] == "L1_MU6") threshold = 6000;
825 if (m_L1Seed[m] == "L1_MU10") threshold = 10000;
826 if (m_L1Seed[m] == "L1_MU11") threshold = 11000;
827 if (m_L1Seed[m] == "L1_MU15") threshold = 15000;
828 if (m_L1Seed[m] == "L1_MU20") threshold = 20000;
829 for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
830 bool break_flag = false;
831 for (const auto TrigL1mu : *L1TrigMuons) {
832 if (((TrigL1mu->thrValue()) >= threshold) &&
833 (sqrt(pow(m_vRecoMuons_EffDen.at(k)->eta() - TrigL1mu->eta(), 2.) +
834 pow(m_vRecoMuons_EffDen.at(k)->phi() - TrigL1mu->phi(), 2.)) < 0.2)) {
835 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
836 if (m_selectMuonCategories[j] == ALL) {
837 m_TriggerMuonValidationPlots[j]->fillDenRELEff(*m_vRecoMuons_EffDen.at(k), m_muonItems[m]);
838 } // if categ=ALL
839 } // categories
840 for (const auto& mufeat : vec_muons) {
841 for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
842 if ((((*mufeat.cptr())[i]->author()) == m_SelectedAuthor) &&
843 (deltaR((*mufeat.cptr())[i], m_vRecoMuons_EffDen.at(k)) < 0.1)) {
844 break_flag = true;
845 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
846 if (m_selectMuonCategories[j] == ALL) {
847 m_TriggerMuonValidationPlots[j]->fillNumRELEff(*m_vRecoMuons_EffDen.at(k),
848 m_muonItems[m]);
849 } // if categ=ALL
850 } // categories
851 break;
852 } // if(Delta_R)
853 } // mufeat
854 if (break_flag) break;
855 } // vec_muons
856 break;
857 } // if(Delta_R)
858 } // L1TrigMuons
859 } // m_vRecoMuons_EffDen
860 } // m_muonItems.size()
861 } // m_doTrigMuonEFValidation
862 }
863 return StatusCode::SUCCESS;
864 }//fillHistograms()*/
MuonLink
ElementLink< xAOD::MuonContainer > MuonLink
Definition BPhysHelper.cxx:21
x
#define x
pow
constexpr int pow(int base, int exp) noexcept
Definition ap_fixedTest.cxx:15
DataVector< xAOD::Muon_v1 >::const_iterator
DataModel_detail::const_iterator< DataVector > const_iterator
Definition DataVector.h:838
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuMETracks
std::vector< const xAOD::TrackParticle * > m_vZmumuMETracks
Definition MuonPhysValMonitoringTool.h:213
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2CBMuonsSelected
std::vector< const xAOD::L2CombinedMuon * > m_vL2CBMuonsSelected
Definition MuonPhysValMonitoringTool.h:220
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleTruthMuon
void handleTruthMuon(const xAOD::TruthParticle *truthMu, float weight=1.0)
Definition MuonPhysValMonitoringTool.cxx:965
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectComissioning
Gaudi::Property< bool > m_selectComissioning
Flag to tell whether muons with the comissioning author will be selected or not.
Definition MuonPhysValMonitoringTool.h:150
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedTruthMuons
std::vector< const xAOD::TruthParticle * > m_vMatchedTruthMuons
Definition MuonPhysValMonitoringTool.h:207
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2SAMuonsSelected
std::vector< const xAOD::L2StandAloneMuon * > m_vL2SAMuonsSelected
Definition MuonPhysValMonitoringTool.h:218
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedSlowMuons
std::vector< const xAOD::SlowMuon * > m_vMatchedSlowMuons
Definition MuonPhysValMonitoringTool.h:209
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL2Trigger
void handleMuonL2Trigger(const xAOD::L2StandAloneMuon *L2SAMu)
Definition MuonPhysValMonitoringTool.cxx:1126
MuonPhysValMonitoring::MuonPhysValMonitoringTool::SplitString
void SplitString(TString x, const TString &delim, std::vector< TString > &v)
Definition MuonPhysValMonitoringTool.cxx:1681
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2SAMuons
std::vector< const xAOD::L2StandAloneMuon * > m_vL2SAMuons
Definition MuonPhysValMonitoringTool.h:217
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleTruthMuonSegment
void handleTruthMuonSegment(const xAOD::MuonSegment *truthMuSeg, const xAOD::TruthParticleContainer *muonTruthContainer, float weight=1.0)
Definition MuonPhysValMonitoringTool.cxx:866
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuonSegments
std::vector< const xAOD::MuonSegment * > m_vMatchedMuonSegments
Definition MuonPhysValMonitoringTool.h:211
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuIDTracks
std::vector< const xAOD::TrackParticle * > m_vZmumuIDTracks
Definition MuonPhysValMonitoringTool.h:212
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrack
void handleMuonTrack(const xAOD::TrackParticle *tp, xAOD::Muon::TrackParticleType type, float weight=1.0)
Definition MuonPhysValMonitoringTool.cxx:1015
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonSegment
void handleMuonSegment(const xAOD::MuonSegment *muSeg, float weight=1.0)
Definition MuonPhysValMonitoringTool.cxx:882
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuonTracks
std::vector< const xAOD::TrackParticle * > m_vMatchedMuonTracks
Definition MuonPhysValMonitoringTool.h:210
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2CBMuons
std::vector< const xAOD::L2CombinedMuon * > m_vL2CBMuons
Definition MuonPhysValMonitoringTool.h:219
MuonPhysValMonitoring::MuonPhysValMonitoringTool::retrieveContainer
StatusCode retrieveContainer(const EventContext &ctx, const SG::ReadHandleKey< ContType > &key, const ContType *&container) const
Definition MuonPhysValMonitoringTool.cxx:46
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuon
void handleMuon(const xAOD::Muon *mu, const xAOD::SlowMuon *smu=nullptr, float weight=1.0)
Definition MuonPhysValMonitoringTool.cxx:898
Trig::FeatureContainer::get
const std::vector< Trig::Feature< T > > get(const std::string &label="", unsigned int condition=TrigDefs::Physics, const std::string &teName="") const
returns flattened vector of Features of given type This method is in fact sullied by 3 arguments.
Definition FeatureContainer.h:151
xAOD::EventInfo_v1::beamSpotWeight
float beamSpotWeight() const
Weight for beam spot size reweighting.
Definition EventInfo_v1.cxx:970
xAOD::Muon_v1::charge
float charge() const
xAOD::Muon_v1::allAuthors
uint16_t allAuthors() const
Get all the authors of this Muon.
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition TrackParticle_v1.cxx:122
find
std::string find(const std::string &s)
return a remapped string
Definition hcg.cxx:138
CaloNoise_fillDB.mu
mu
Definition CaloNoise_fillDB.py:51
xAOD::EventInfo
EventInfo_v1 EventInfo
Definition of the latest event info version.
Definition IEventInfoCnvTool.h:18
xAOD::MuonRoIContainer
MuonRoIContainer_v1 MuonRoIContainer
Definition MuonRoIContainer.h:16
xAOD::MuonSegmentContainer
MuonSegmentContainer_v1 MuonSegmentContainer
Definition of the current "MuonSegment container version".
Definition MuonSegmentContainer.h:14
xAOD::L2CombinedMuonContainer
L2CombinedMuonContainer_v1 L2CombinedMuonContainer
Define the latest version of the muon CB container.
Definition L2CombinedMuonContainer.h:15
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13
xAOD::L2StandAloneMuonContainer
L2StandAloneMuonContainer_v2 L2StandAloneMuonContainer
Define the latest version of the muon SA container.
Definition L2StandAloneMuonContainer.h:17
xAOD::TrackParticleContainer
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticleContainer.h:14
xAOD::Muon
Muon_v1 Muon
Reference the current persistent version:
Definition Event/xAOD/xAODMuon/xAODMuon/Muon.h:13
xAOD::SlowMuonContainer
SlowMuonContainer_v1 SlowMuonContainer
Definition of the current "SlowMuon container version".
Definition SlowMuonContainer.h:14
xAOD::MuonContainer
MuonContainer_v1 MuonContainer
Definition of the current "Muon container version".
Definition Event/xAOD/xAODMuon/xAODMuon/MuonContainer.h:14
xAOD::TruthParticleContainer
TruthParticleContainer_v1 TruthParticleContainer
Declare the latest version of the truth particle container.
Definition Event/xAOD/xAODTruth/xAODTruth/TruthParticleContainer.h:17

◆ fillHists()

StatusCode ManagedMonitorToolBase::fillHists ( )
virtualinherited

Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ).

Implements IMonitorToolBase.

Reimplemented in TileDigitsMonTool, and TileRawChannelMonTool.

Definition at line 739 of file ManagedMonitorToolBase.cxx.

741{
742
743 if (m_d->m_warnAboutMissingInitialize) {
744 m_d->m_warnAboutMissingInitialize = false;
745 msg(MSG::WARNING) << "ManagedMonitorToolBase::initialize() never called from reimplementation!" << endmsg;
746 }
747
748
749 bool isNewEventsBlock = ( m_procNEventsProp > 0 && ((m_nEvents % m_procNEventsProp) == 1) && m_haveClearedLastEventBlock );
750 if (isNewEventsBlock) m_haveClearedLastEventBlock = false;
751
752 m_newLowStat = false;
753 m_newLumiBlock = false;
754 m_newRun = false;
755 newLowStat = false;
756 newLumiBlock = false;
757 newRun = false;
758
759 m_newLowStatInterval = false;
760 m_newMedStatInterval = false;
761 m_newHigStatInterval = false;
762 newLowStatInterval = false;
763 newMedStatInterval = false;
764 newHigStatInterval = false;
765
766 m_useTrigger = ( (m_triggerChainProp != "" || m_triggerGroupProp != "") && (!m_trigDecTool.empty()) );
767
768 if( m_manager != 0 ) {
769 m_newLumiBlock = ( (m_lastLumiBlock != m_manager->lumiBlockNumber()) || m_manager->forkedProcess());
770 m_newRun = ( m_lastRun != m_manager->runNumber() );
771 newLumiBlock = m_newLumiBlock;
772 newRun = m_newRun;
773
774 if(m_newRun) {
775 m_newLumiBlock = true;
776 newLumiBlock = m_newLumiBlock;
777 isNewEventsBlock = true;
778 }
779
780 m_newEventsBlock = isNewEventsBlock;
781 newEventsBlock = m_newEventsBlock;
782
783 if( m_newLumiBlock ) {
784 // check if a new LB interval has started
785 // lowest lumiBlockNumber() is 1
786 // m_lastLowStatInterval is -1 initially
787 int currentLB = m_manager->lumiBlockNumber();
788 int LBsLowStat = m_manager->getLBsLowStat();
789 int LBsMedStat = m_manager->getLBsMedStat();
790 int LBsHigStat = m_manager->getLBsHigStat();
791
792 if( LBsLowStat*LBsMedStat*LBsHigStat == 0) {
793 msg(MSG::WARNING) << "zero LBs requested for interval" << endmsg;
794 }
795 else {
796 if( ((currentLB-1)/LBsLowStat) != m_lastLowStatInterval ) m_newLowStatInterval = true;
797 if( ((currentLB-1)/LBsMedStat) != m_lastMedStatInterval ) m_newMedStatInterval = true;
798 if( ((currentLB-1)/LBsHigStat) != m_lastHigStatInterval ) m_newHigStatInterval = true;
799 newLowStatInterval = m_newLowStatInterval;
800 newMedStatInterval = m_newHigStatInterval;
801 newHigStatInterval = m_newHigStatInterval;
802 }
803 }
804
805 // Allow inheriting classes the option of using the lastLumiBloc/lastRun values
806 // before updating them
807 }
808
809
810 StatusCode sc0( StatusCode::SUCCESS );
811 StatusCode sc1( StatusCode::SUCCESS );
812 StatusCode sc2( StatusCode::SUCCESS );
813 StatusCode sc3( StatusCode::SUCCESS );
814
815 // Set end of LowStat, LumiBlock and Run variables
816 // These are needed to be used in procHistograms().
817 m_endOfEventsBlock = m_newEventsBlock;
818 m_endOfLowStat = m_newLowStatInterval;
819 m_endOfLumiBlock = m_newLumiBlock;
820 m_endOfRun = m_newRun;
821 endOfEventsBlock = m_newEventsBlock;
822 endOfLowStat = m_newLowStatInterval;
823 endOfLumiBlock = m_newLumiBlock;
824 endOfRun = m_newRun;
825
826 // just duplicates m_newLowStatInterval
827 m_newLowStat = m_newLowStatInterval;
828 newLowStat = m_newLowStatInterval;
829
830 if( m_newEventsBlock || m_newLumiBlock || m_newRun ) {
831 ATH_MSG_DEBUG("Interval transition processing");
832 // Process histograms from the previous lumiBlock/run
833 if( m_nEvents != 1 ) {
834 m_d->benchPreProcHistograms();
835 sc0 = procHistograms();
836 m_d->benchPostProcHistograms();
837 }
838 // Re-book new histograms
839 m_d->benchPreBookHistograms();
840
841 if (!m_bookHistogramsInitial) {
842 sc1 = bookHistograms();
843 m_bookHistogramsInitial = true;
844 } else {
845 std::vector<Interval_t> intervals_to_process;
846 if (m_newEventsBlock) intervals_to_process.push_back(eventsBlock);
847 if (m_newLumiBlock) intervals_to_process.push_back(lumiBlock);
848 if (m_newLowStatInterval) intervals_to_process.push_back(lowStat);
849 if (m_newRun) intervals_to_process.push_back(run);
850 for (const auto interval: intervals_to_process) {
851 sc1 = regManagedHistograms(m_templateHistograms[interval]);
852 sc1 = regManagedGraphs(m_templateGraphs[interval]);
853 sc1 = regManagedTrees(m_templateTrees[interval]);
854 }
855 }
856 for (const auto& interval: std::vector<Interval_t>{ eventsBlock, lumiBlock, lowStat, run }) {
857 for (const auto& it: m_templateHistograms[interval]) {
858 // is histogram too small in x axis for LB range?
859 if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
860 //ATH_MSG_WARNING("We are rebinning for " << it.m_templateHist->GetName());
861 while ( it.m_templateHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
862 it.m_templateHist->LabelsInflate("X");
863 }
864 }
865 }
866 for (auto& it: m_templateEfficiencies[interval]) {
867 if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
868 // get the underlying passed and total TH1's from the TEfficiency
869 TH1* passedHist = it.m_templateHist->GetCopyPassedHisto();
870 TH1* totalHist = it.m_templateHist->GetCopyTotalHisto();
871 // inflate them until they exceed the lumi-block number
872 while (passedHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
873 passedHist->LabelsInflate("X");
874 totalHist->LabelsInflate("X");
875 }
876 // Replace them in the TEfficiency. First one has force ("f") option, since the
877 // histograms will not be consistent. This is corrected in the next line, so we
878 // do check for consistency then.
879 it.m_templateHist->SetPassedHistogram(*passedHist, "f");
880 it.m_templateHist->SetTotalHistogram(*totalHist, " ");
881 delete passedHist; // not owned by THistSvc, so need to be deleted.
882 delete totalHist;
883 }
884 }
885 }
886
887 if (auto streamname = dynamic_cast<OfflineStream*>(streamNameFunction())) {
888 streamname->updateRunLB();
889 }
890
891 sc3 = bookHistogramsRecurrent( );
892
893 m_d->benchPostBookHistograms();
894
895 }//end if new RUN/LB/Block
896
897 // check filters
898 bool filterresult(true);
899 if (! m_DQFilterTools.empty()) {
900 ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
901 for (; filterresult && (ifilter != filterend);
902 ++ifilter) {
903 filterresult = (filterresult && (*ifilter)->accept());
904 }
905 }
906
907
908 // ...and fill as normal
909 if(filterresult &&
910 (!m_useTrigger
911 || (m_vTrigChainNames.size()>0 && trigChainsArePassed(m_vTrigChainNames))
912 || (m_vTrigGroupNames.size()>0 && trigChainsArePassed(m_vTrigGroupNames))) ) {
913 ATH_MSG_DEBUG("Passed trigger, presumably");
914 m_d->benchPreFillHistograms();
915 fillHistograms().ignore();
916 m_haveClearedLastEventBlock = true;
917 m_d->benchPostFillHistograms();
918 ++m_nEvents;
919 } else { ATH_MSG_DEBUG("Failed trigger, presumably"); }
920
921 ++m_nEventsIgnoreTrigger;
922 if( m_newLumiBlock && (m_nEventsIgnoreTrigger != 1) ) {
923 ++m_nLumiBlocks;
924 }
925 if( m_manager != 0 ) {
926 m_lastRun = m_manager->runNumber();
927 if( m_newLumiBlock ) {
928 m_lastLumiBlock = m_manager->lumiBlockNumber();
929
930 int LBsLowStat = m_manager->getLBsLowStat();
931 int LBsMedStat = m_manager->getLBsMedStat();
932 int LBsHigStat = m_manager->getLBsHigStat();
933 if( LBsLowStat*LBsMedStat*LBsHigStat > 0) {
934 if( m_newLowStatInterval ) m_lastLowStatInterval = (m_lastLumiBlock-1)/LBsLowStat;
935 if( m_newMedStatInterval ) m_lastMedStatInterval = (m_lastLumiBlock-1)/LBsMedStat;
936 if( m_newHigStatInterval ) m_lastHigStatInterval = (m_lastLumiBlock-1)/LBsHigStat;
937 }
938 }
939 }
940
941 return StatusCode::SUCCESS;
942}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:63
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition AthCommonMsg.h:24
AthenaMonManager::lumiBlockNumber
static unsigned int lumiBlockNumber()
Definition AthenaMonManager.cxx:328
ManagedMonitorToolBase::regManagedTrees
StatusCode regManagedTrees(std::vector< MgmtParams< TTree > > &templateTrees)
Definition ManagedMonitorToolBase.cxx:1200
ManagedMonitorToolBase::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Definition ManagedMonitorToolBase.h:849
ManagedMonitorToolBase::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition ManagedMonitorToolBase.cxx:1285
ManagedMonitorToolBase::m_vTrigGroupNames
std::vector< std::string > m_vTrigGroupNames
Definition ManagedMonitorToolBase.h:680
ManagedMonitorToolBase::m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
Definition ManagedMonitorToolBase.h:664
ManagedMonitorToolBase::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition ManagedMonitorToolBase.cxx:1305
ManagedMonitorToolBase::m_trigDecTool
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool
Definition ManagedMonitorToolBase.h:845
ManagedMonitorToolBase::regManagedGraphs
StatusCode regManagedGraphs(std::vector< MgmtParams< TGraph > > &templateGraphs)
Definition ManagedMonitorToolBase.cxx:1069
ManagedMonitorToolBase::m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
Definition ManagedMonitorToolBase.h:668
ManagedMonitorToolBase::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition ManagedMonitorToolBase.cxx:1297
ManagedMonitorToolBase::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Definition ManagedMonitorToolBase.h:680
ManagedMonitorToolBase::m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
Definition ManagedMonitorToolBase.h:672
ManagedMonitorToolBase::m_templateEfficiencies
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
Definition ManagedMonitorToolBase.h:676
ManagedMonitorToolBase::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition ManagedMonitorToolBase.cxx:1313
ManagedMonitorToolBase::regManagedHistograms
StatusCode regManagedHistograms(std::vector< MgmtParams< TH1 > > &templateHistograms)
Definition ManagedMonitorToolBase.cxx:972
ManagedMonitorToolBase::trigChainsArePassed
virtual bool trigChainsArePassed(std::vector< std::string > &)
Definition ManagedMonitorToolBase.cxx:2093
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22

◆ finalHists()

StatusCode ManagedMonitorToolBase::finalHists ( )
virtualinherited

Calls procHists( true, true, true ).

Implements IMonitorToolBase.

Reimplemented in TileCellNoiseMonTool, TileDigitsMonTool, and TileRawChannelMonTool.

Definition at line 1254 of file ManagedMonitorToolBase.cxx.

1256{
1257
1258 // This assumes that the end of a file will naturally end a run, which is not always true.
1259 // A merging application run afterwards should be able to put parts of a run together.
1260 if( m_nEvents != 1 ) {
1261 m_d->benchPreProcHistograms();
1262
1263 // Set end flags for the LowStat, LumiBlock and Run variables.
1264 // This is needed to be used in the procHistograms method below.
1265 m_endOfEventsBlock = true;
1266 m_endOfLowStat = true;
1267 m_endOfLumiBlock = true;
1268 m_endOfRun = true;
1269 endOfEventsBlock = true;
1270 endOfLowStat = true;
1271 endOfLumiBlock = true;
1272 endOfRun = true;
1273
1274 StatusCode sc = procHistograms();
1275
1276 m_d->benchPostProcHistograms();
1277 return sc;
1278 }
1279 return StatusCode::SUCCESS;
1280}
sc
static Double_t sc
Definition LArPhysWaveHECTool.cxx:37

◆ findHistogram()

TH1F * MuonPhysValMonitoring::MuonPhysValMonitoringTool::findHistogram ( const std::vector< HistData > & hists,
const std::string & hnameTag,
const std::string & hdirTag,
const std::string & hNewName )
private

Definition at line 1364 of file MuonPhysValMonitoringTool.cxx.

1365 {
1366 TH1F* h = nullptr;
1367 for (const auto& hist : hists) {
1368 if (hist.second.find(hdirTag) != std::string::npos || hdirTag.empty()) {
1369 std::string histname = hist.first->GetName();
1370 if (histname.find(hnameTag) != std::string::npos) {
1371 h = (TH1F*)hist.first->Clone(hNewName.c_str());
1372 return h;
1373 }
1374 }
1375 }
1376 return h;
1377 }

◆ findRecoMuon()

const xAOD::Muon * MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuon ( const xAOD::TruthParticle * truthMu)
private

Definition at line 1290 of file MuonPhysValMonitoringTool.cxx.

1290 {
1291 static const SG::ConstAccessor<MuonLink> acc_muon("recoMuonLink");
1292 if (!acc_muon.isAvailable(*truthMu)) return nullptr;
1293 MuonLink link = acc_muon(*truthMu);
1294 if (!link.isValid()) return nullptr;
1295 const xAOD::Muon* reco_mu = (*link);
1296 if (!m_selectComissioning && reco_mu->allAuthors() & comm_bit) return nullptr;
1297 m_vMatchedMuons.emplace_back(reco_mu);
1298 return reco_mu;
1299 }

◆ findRecoMuonSegment()

const xAOD::MuonSegment * MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuonSegment ( const xAOD::MuonSegment * truthMuSeg)
private

Definition at line 1349 of file MuonPhysValMonitoringTool.cxx.

1349 {
1350 static const SG::ConstAccessor<MuonSegmentLink> recoSegmentLinkAcc("recoSegmentLink");
1351 if (!recoSegmentLinkAcc.isAvailable(*truthMuSeg)) {
1352 ATH_MSG_DEBUG("recoSegmentLink not found");
1353 return nullptr;
1354 }
1355 MuonSegmentLink link = recoSegmentLinkAcc(*truthMuSeg);
1356 if (!link.isValid()) {
1357 ATH_MSG_DEBUG("recoSegmentLink not valid");
1358 return nullptr;
1359 }
1360 m_vMatchedMuonSegments.emplace_back(*link);
1361 return (*link);
1362 }

◆ findRecoSlowMuon()

const xAOD::SlowMuon * MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoSlowMuon ( const xAOD::TruthParticle * truthMu)
private

Definition at line 1301 of file MuonPhysValMonitoringTool.cxx.

1301 {
1302 const xAOD::SlowMuonContainer* SlowMuons = nullptr;
1303 retrieveContainer(Gaudi::Hive::currentContext() , m_slowMuonsName, SlowMuons).ignore();
1304 if (!SlowMuons) return nullptr;
1305 for (const auto smu : *SlowMuons) {
1306 const MuonLink muLink = smu->muonLink();
1307 if (!muLink.isValid()) continue;
1308 float DR = deltaR(*muLink , truthMu);
1309 if (DR < 0.005) {
1310 m_vMatchedSlowMuons.emplace_back(smu);
1311 return smu;
1312 }
1313 }
1314
1315 return nullptr;
1316 }

◆ get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const
inlineprotectedinherited

Definition at line 692 of file ManagedMonitorToolBase.h.

692 {
693 return m_nEvents;
694 }

◆ get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const
inlineprotectedinherited

Definition at line 696 of file ManagedMonitorToolBase.h.

696 {
697 return m_procNEventsProp;
698 }

◆ getCorrectedMuon()

std::unique_ptr< xAOD::Muon > MuonPhysValMonitoring::MuonPhysValMonitoringTool::getCorrectedMuon ( const xAOD::Muon & mu)
private

Definition at line 1412 of file MuonPhysValMonitoringTool.cxx.

1412 {
1413 std::unique_ptr<xAOD::Muon> mu_c;
1414 if (mu.m() <= 0) return mu_c;
1415 mu_c = std::make_unique<xAOD::Muon>();
1416 mu_c->makePrivateStore(mu);
1417
1418 // add decorations too fool the muon selector tool
1419 const xAOD::TrackParticle* idtrk{mu_c->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)};
1420 const xAOD::TrackParticle* metrk{mu_c->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)};
1421 if (idtrk && metrk) {
1422 const static SG::Decorator<float> InnerDetectorPtDec("InnerDetectorPt");
1423 const static SG::Decorator<float> MuonSpectrometerPtDec("MuonSpectrometerPt");
1424 InnerDetectorPtDec(*mu_c) = idtrk->pt();
1425 MuonSpectrometerPtDec(*mu_c) = metrk->pt();
1426 }
1427 m_muonSelectionTool->setQuality(*mu_c);
1428 m_muonSelectionTool->setPassesIDCuts(*mu_c);
1429 return mu_c;
1430 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition MuonPhysValMonitoringTool.h:168
xAOD::TrackParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition TrackParticle_v1.cxx:75

◆ getHist() [1/4]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *& h,
const std::string & hName,
const MonGroup & group )
virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1417 of file ManagedMonitorToolBase.cxx.

1419{
1420 std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1421 return m_THistSvc->getHist( streamName, h );
1422}

◆ getHist() [2/4]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *& h,
const std::string & hName,
const std::string & system,
Interval_t interval )
virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1407 of file ManagedMonitorToolBase.cxx.

1410{
1411 MonGroup group( this, system, interval );
1412 return getHist( h, hName, group );
1413}
ManagedMonitorToolBase::getHist
virtual StatusCode getHist(TH1 *&h, const std::string &hName, const std::string &system, Interval_t interval)
Returns a TH1 via the pointer passed as the first argument.
Definition ManagedMonitorToolBase.cxx:1408

◆ getHist() [3/4]

StatusCode ManagedMonitorToolBase::getHist ( TH2 *& h,
const std::string & hName,
const MonGroup & group )
virtualinherited

Returns a TH2 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1436 of file ManagedMonitorToolBase.cxx.

1438{
1439 std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1440 return m_THistSvc->getHist( streamName, h );
1441}

◆ getHist() [4/4]

StatusCode ManagedMonitorToolBase::getHist ( TH2 *& h,
const std::string & hName,
const std::string & system,
Interval_t interval )
virtualinherited

Returns a TH2 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1426 of file ManagedMonitorToolBase.cxx.

1429{
1430 MonGroup group( this, system, interval );
1431 return getHist( h, hName, group );
1432}

◆ getMuonSegmentTruthCategory()

MuonPhysValMonitoringTool::MUCATEGORY MuonPhysValMonitoring::MuonPhysValMonitoringTool::getMuonSegmentTruthCategory ( const xAOD::MuonSegment * truthMuSeg,
const xAOD::TruthParticleContainer * muonTruthContainer )
private

Definition at line 1379 of file MuonPhysValMonitoringTool.cxx.

1380 {
1381 static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1382 TruthLink truthLink;
1383 if (truthParticleLinkAcc.isAvailable(*truthMuSeg)) {
1384 truthLink = truthParticleLinkAcc(*truthMuSeg);
1385 if (truthLink.isValid()) {
1386 const int theUniqueID = HepMC::uniqueID(*truthLink);
1387 if (std::abs((*truthLink)->pdgId()) != 13) return REST;
1388
1389 for (const auto muTruthPart : *muonTruthContainer) {
1390 if ( HepMC::uniqueID(muTruthPart) == theUniqueID ) { return getMuonTruthCategory(muTruthPart); }
1391 }
1392 }
1393 } else
1394 ATH_MSG_WARNING("No truth link available for muon truth segment");
1395
1396 return REST;
1397 }
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
TruthLink
ElementLink< xAOD::TruthParticleContainer > TruthLink
Definition TruthRelatedMuonPlotOrganizer.cxx:12
MuonPhysValMonitoring::MuonPhysValMonitoringTool::getMuonTruthCategory
MuonPhysValMonitoringTool::MUCATEGORY getMuonTruthCategory(const xAOD::IParticle *prt)
Definition MuonPhysValMonitoringTool.cxx:1399
HepMC::uniqueID
int uniqueID(const T &p)
Definition MagicNumbers.h:117

◆ getMuonTruthCategory()

MuonPhysValMonitoringTool::MUCATEGORY MuonPhysValMonitoring::MuonPhysValMonitoringTool::getMuonTruthCategory ( const xAOD::IParticle * prt)
private

Definition at line 1399 of file MuonPhysValMonitoringTool.cxx.

1399 {
1400 static const SG::ConstAccessor<int> truthTypeAcc("truthType");
1401 static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
1402 int truthType = truthTypeAcc(*mu);
1403 if (truthType == 6)
1404 return PROMPT;
1405 else if (truthType == 8 && (truthOriginAcc(*mu) == 34 || truthOriginAcc(*mu) == 35))
1406 return INFLIGHT;
1407 else if (truthType == 7)
1408 return NONISO;
1409 return REST;
1410 }
IDTPM::truthType
int truthType(const U &p)
Definition TrackParametersHelper.h:274

◆ getNewStreamNameFcn()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::getNewStreamNameFcn ( ) const
protectedvirtualinherited

Definition at line 2155 of file ManagedMonitorToolBase.cxx.

2157{
2158 StreamNameFcn* fcn(0);
2159
2160 switch( m_environment ) {
2161 case AthenaMonManager::noOutput:
2162 fcn = new NoOutputStream();
2163 break;
2164 case AthenaMonManager::online:
2165 fcn = new OnlineStream();
2166 break;
2167 case AthenaMonManager::user:
2168 fcn = new DefaultStream( m_fileKey );
2169 break;
2170 case AthenaMonManager::tier0:
2171 case AthenaMonManager::tier0Raw:
2172 case AthenaMonManager::tier0ESD:
2173 case AthenaMonManager::AOD:
2174 case AthenaMonManager::altprod:
2175 default:
2176 fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
2177 }
2178
2179 return fcn;
2180}
ManagedMonitorToolBase::StreamNameFcn
A function-object base class allowing the specific implementation of getStreamName to be decided at r...
Definition ManagedMonitorToolBase.h:325
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition ManagedMonitorToolBase.h:839
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition ManagedMonitorToolBase.h:838

◆ handleMuon()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuon ( const xAOD::Muon * mu,
const xAOD::SlowMuon * smu = nullptr,
float weight = 1.0 )
private

Definition at line 898 of file MuonPhysValMonitoringTool.cxx.

898 {
899 if (!mu) return;
900 if (!m_selectComissioning && mu->allAuthors() & comm_bit) return;
901
902 if (msgLvl(MSG::DEBUG)) printMuonDebug(mu);
903
904 // make deep copy of muon and decorate with quality
905 std::unique_ptr<xAOD::Muon> mu_c;
906 try {
907 mu_c = getCorrectedMuon(*mu);
908 } catch (const SG::ExcBadAuxVar&) {
909 ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
910 return;
911 }
912
913 if (m_isData) {
914 MUCATEGORY thisMuonCategory = ALL;
915 // for events with a Zmumu candidate, separate Z muons from the rest:
916 if (m_vZmumuMuons.size() > 0) {
917 thisMuonCategory = REST;
918 if (std::find(m_vZmumuMuons.begin(), m_vZmumuMuons.end(), mu) != m_vZmumuMuons.end()) { thisMuonCategory = PROMPT; }
919 }
920 // fill plots
921 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
922 if (m_selectMuonCategories[i] == ALL or m_selectMuonCategories[i] == thisMuonCategory) {
923 if (mu_c){
924 // histos
925 m_muonValidationPlots[i]->fill(*mu_c, weight);
926 if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
927 // tree branches
928 m_muonValidationPlots[i]->fillTreeBranches(*mu_c);
929 }
930 }
931 }
932 }
933
935 // SELECT MUON MEDIUM QUALITY FOR TRIGGER VALIDATION
936 xAOD::Muon::Quality my_quality = m_muonSelectionTool->getQuality(*mu_c);
937 if (my_quality <= xAOD::Muon::Medium && m_isoTool->accept(*mu_c)) m_vRecoMuons.emplace_back(mu);
939
940 if (smu) {
941 if (std::find(std::begin(m_vMatchedSlowMuons), std::end(m_vMatchedSlowMuons), smu) != std::end(m_vMatchedSlowMuons)) { return; }
942 } else {
943 if (std::find(std::begin(m_vMatchedMuons), std::end(m_vMatchedMuons), mu) != std::end(m_vMatchedMuons)) { return; }
944 }
945
946 // unmatched reco muons (not matched with any kind of truth particle, fakes)
947 if (!m_isData) m_oUnmatchedRecoMuonPlots->fill(*mu_c, weight);
948
949 m_h_overview_reco_category->Fill("Other", weight);
950 m_h_overview_reco_authors[3]->Fill(mu->author(), weight);
951
952 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
953 if (m_selectMuonCategories[i] == ALL) {
954 if (mu_c){// histos
955 m_muonValidationPlots[i]->fill(*mu_c);
956 if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
957 // tree branches
958 m_muonValidationPlots[i]->fillTreeBranches(*mu_c);
959 break;
960 }
961 }
962 }
963 }
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition AthCommonMsg.h:30
MuonPhysValMonitoring::MuonPhysValMonitoringTool::getCorrectedMuon
std::unique_ptr< xAOD::Muon > getCorrectedMuon(const xAOD::Muon &mu)
Definition MuonPhysValMonitoringTool.cxx:1412
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition CutsMETMaker.cxx:18

◆ handleMuonL1Trigger()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL1Trigger ( const xAOD::MuonRoI * TrigL1mu)
private

Definition at line 1116 of file MuonPhysValMonitoringTool.cxx.

1116 {
1117 ATH_MSG_DEBUG("MuonRoI L1 Trigger: ptThr " << TrigL1mu->thrValue() << " phi " << TrigL1mu->phi() << " eta " << TrigL1mu->eta());
1118 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1119 if (m_selectMuonCategories[i] == ALL) {
1120 m_TriggerMuonValidationPlots[i]->fill(*TrigL1mu);
1121 break;
1122 }
1123 }
1124 }
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
xAOD::MuonRoI_v1::thrValue
float thrValue() const
The highest threshold value (in MeV) passed by the muon candidate.
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.

◆ handleMuonL2Trigger() [1/2]

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL2Trigger ( const xAOD::L2CombinedMuon * L2CBMu)
private

Definition at line 1174 of file MuonPhysValMonitoringTool.cxx.

1174 {
1175 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1176 if (m_selectMuonCategories[i] == ALL) {
1177 m_TriggerMuonValidationPlots[i]->fill(*L2CBMu);
1178 break;
1179 }
1180 }
1181 ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2CB Trigger : pt " << L2CBMu->pt() << " phi " << L2CBMu->phi() << " eta "
1182 << L2CBMu->eta());
1183 }
xAOD::L2CombinedMuon_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
xAOD::L2CombinedMuon_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
xAOD::L2CombinedMuon_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.

◆ handleMuonL2Trigger() [2/2]

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL2Trigger ( const xAOD::L2StandAloneMuon * L2SAMu)
private

Definition at line 1126 of file MuonPhysValMonitoringTool.cxx.

1126 {
1127 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1128 if (m_selectMuonCategories[i] == ALL) {
1129 m_TriggerMuonValidationPlots[i]->fill(*L2SAMu);
1130 break;
1131 }
1132 }
1133 ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2SA Trigger : pt " << L2SAMu->pt() << " phi " << L2SAMu->phi() << " eta "
1134 << L2SAMu->eta() << " roiWord " << L2SAMu->roiWord()
1135 << " sAddress " << L2SAMu->sAddress());
1136 }
xAOD::L2StandAloneMuon_v2::sAddress
int sAddress() const
Get the station address of the muon.
xAOD::L2StandAloneMuon_v2::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
xAOD::L2StandAloneMuon_v2::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
xAOD::L2StandAloneMuon_v2::roiWord
uint32_t roiWord() const
Get the RoI ID of the seeding LVL1 muon.
xAOD::L2StandAloneMuon_v2::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.

◆ handleMuonSegment()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonSegment ( const xAOD::MuonSegment * muSeg,
float weight = 1.0 )
private

Definition at line 882 of file MuonPhysValMonitoringTool.cxx.

882 {
883 if (!muSeg) {
884 ATH_MSG_WARNING("No muon segment found");
885 return;
886 }
887 if (std::find(std::begin(m_vMatchedMuonSegments), std::end(m_vMatchedMuonSegments), muSeg) != std::end(m_vMatchedMuonSegments))
888 return;
889 if (!m_isData) m_oUnmatchedRecoMuonSegmentPlots->fill(*muSeg, weight);
890 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
891 if (m_selectMuonCategories[i] == ALL) {
892 m_muonSegmentValidationPlots[i]->fill(muSeg, weight);
893 break;
894 }
895 }
896 }

◆ handleMuonTrack()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrack ( const xAOD::TrackParticle * tp,
xAOD::Muon::TrackParticleType type,
float weight = 1.0 )
private

Definition at line 1015 of file MuonPhysValMonitoringTool.cxx.

1015 {
1016 if (!tp) {
1017 ATH_MSG_WARNING("No track particle found");
1018 return;
1019 }
1020
1021 // if ID track, check that it passes standard combined mu reco selections
1022 bool passesMuonTrackSel = false;
1023 if (type == xAOD::Muon::InnerDetectorTrackParticle) { passesMuonTrackSel = m_trackSelector->decision(*tp); }
1024
1025 if (m_isData) {
1026 if (type == xAOD::Muon::InnerDetectorTrackParticle) {
1027 MUCATEGORY thisTrkCategory = ALL;
1028 // for events with a Zmumu candidate, separate Z muon tracks from the rest:
1029 if (m_vZmumuIDTracks.size() > 0) {
1030 thisTrkCategory = REST;
1031 for (const auto& zmu : m_vZmumuIDTracks) {
1032 if (deltaR(zmu, tp) < 0.01) {
1033 thisTrkCategory = PROMPT;
1034 break;
1035 }
1036 }
1037 }
1038
1039 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1040 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisTrkCategory) {
1041 m_muonIDTrackValidationPlots[i]->fill(*tp, weight);
1042 if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*tp, weight);
1043 }
1044 }
1045 } else if (type == xAOD::Muon::MuonSpectrometerTrackParticle)
1046 m_muonMSTrackValidationPlots[ALL]->fill(*tp, weight);
1047 else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)
1048 m_muonMETrackValidationPlots[ALL]->fill(*tp, weight);
1049 else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle)
1050 m_muonMSOnlyMETrackValidationPlots[ALL]->fill(*tp, weight);
1051
1052 return;
1053 }
1054
1055 static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1056 TruthLink truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
1057
1058 if (!truthLink.isValid()) {
1059 ATH_MSG_DEBUG("No truth link available");
1060 if (type == xAOD::Muon::InnerDetectorTrackParticle) return;
1061 if (!passesAcceptanceCuts(tp)) return;
1062
1063 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1064 if (m_selectMuonCategories[i] == ALL) {
1065 // ID track plots for any track
1066 // if (type==xAOD::Muon::InnerDetectorTrackParticle) {
1067 // m_muonIDTrackValidationPlots[i]->fill(*tp);
1068 // if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*tp);
1069 // } else
1070 if (type == xAOD::Muon::MuonSpectrometerTrackParticle) {
1071 if (!m_isData) m_oUnmatchedRecoMuonTrackPlots->fill(*tp, weight);
1072 m_muonMSTrackValidationPlots[i]->fill(*tp, weight);
1073 } else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) {
1074 m_muonMETrackValidationPlots[i]->fill(*tp, weight);
1075 } else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle) {
1076 m_muonMSOnlyMETrackValidationPlots[i]->fill(*tp, weight);
1077 }
1078 break;
1079 }
1080 }
1081 } // end if no valid truth link
1082 else { // here: valid truth link and truthType
1083
1084 if (type ==
1085 xAOD::Muon::InnerDetectorTrackParticle) { // don't fill histograms for any ID track, only for muons; buys a lot of time
1086 if ((*truthLink)->absPdgId() != 13 || !MC::isStable(*truthLink)) return; // not a muon
1087 if (HepMC::uniqueID(*truthLink) == HepMC::UNDEFINED_ID || HepMC::is_simulation_particle((*truthLink))) return; // must have valid barcode
1088 }
1089
1090 if (!passesAcceptanceCuts(*truthLink)) return;
1091 unsigned int thisMuonCategory = getMuonTruthCategory(tp);
1092
1093 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1094 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
1095 if (type == xAOD::Muon::InnerDetectorTrackParticle) {
1096 if (!m_fwdtracksName.empty() && std::abs((*truthLink)->eta()) > 2.5)
1097 m_muonIDForwardTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1098 else if (!m_tracksName.empty()) {
1099 m_muonIDTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1100 if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1101 }
1102 } else if (type == xAOD::Muon::MuonSpectrometerTrackParticle) {
1103 m_muonMSTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1104 } else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) {
1105 m_muonMETrackValidationPlots[i]->fill(*truthLink, tp, weight);
1106 } else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle) {
1107 m_muonMSOnlyMETrackValidationPlots[i]->fill(*truthLink, tp, weight);
1108 }
1109 }
1110 }
1111 }
1112
1113 return;
1114 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_trackSelector
ToolHandle< Trk::ITrackSelectorTool > m_trackSelector
Definition MuonPhysValMonitoringTool.h:171
HepMC::UNDEFINED_ID
constexpr int UNDEFINED_ID
Definition MagicNumbers.h:57
HepMC::is_simulation_particle
bool is_simulation_particle(const T &p)
Method to establish if a particle (or barcode) was created during the simulation (TODO update to be s...
Definition MagicNumbers.h:355
MC::isStable
bool isStable(const T &p)
Identify if the particle is stable, i.e. has not decayed.
Definition HepMCHelpers.h:45

◆ handleMuonTrigger()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrigger ( const xAOD::Muon * mu)
private

Definition at line 1221 of file MuonPhysValMonitoringTool.cxx.

1221 {
1222 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1223 if (m_selectMuonCategories[i] == ALL) {
1224 m_TriggerMuonValidationPlots[i]->fill(*EFMu);
1225 break;
1226 }
1227 }
1228 ATH_MSG_DEBUG("==> Geometrical selection of EF Trigger muons: pt " << EFMu->pt() << " phi " << EFMu->phi() << " eta " << EFMu->eta()
1229 << " author " << EFMu->author());
1230 }

◆ handleSlowMuon()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleSlowMuon ( const xAOD::SlowMuon * smu,
float weight = 1.0 )
private

◆ handleTruthMuon()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleTruthMuon ( const xAOD::TruthParticle * truthMu,
float weight = 1.0 )
private

Definition at line 965 of file MuonPhysValMonitoringTool.cxx.

965 {
966 const xAOD::SlowMuon* smu = nullptr;
967 const xAOD::Muon* mu = nullptr;
968 if (!m_slowMuonsName.empty()) {
969 smu = findRecoSlowMuon(truthMu);
970 if (smu) {
971 const MuonLink muLink = smu->muonLink();
972 if (muLink.isValid()) mu = *muLink;
973
974 if (!mu) {
975 ATH_MSG_WARNING("Found SlowMuon without valid muon link");
976 smu = nullptr;
977 }
978 }
979 } else {
980 mu = findRecoMuon(truthMu);
981 }
982
983 if (msgLvl(MSG::DEBUG)) printTruthMuonDebug(truthMu, mu);
984 if (!passesAcceptanceCuts(truthMu)) return;
985
986 std::unique_ptr<xAOD::Muon> mu_c;
987 if (mu) {
988 try {
989 mu_c = getCorrectedMuon(*mu);
990 } catch (const SG::ExcBadAuxVar&) {
991 ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
992 return;
993 }
994 }
995
996 unsigned int thisMuonCategory = getMuonTruthCategory(truthMu);
997 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
998 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
999 // histos
1000 m_muonValidationPlots[i]->fill(
1001 truthMu, mu_c.get(), m_MSTracks,
1002 weight); // if no muon is found a protection inside MuonValidationPlots will ensure, its plots won't be filled
1003 if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots[i]->fill(truthMu, smu, mu_c.get(), weight);
1004 // tree branches
1005 m_muonValidationPlots[i]->fillTreeBranches(truthMu, mu_c.get(), m_MSTracks);
1006 }
1007 }
1008 if (mu_c) {
1009 m_h_overview_reco_category->Fill(thisMuonCategory - 1, weight);
1010 m_h_overview_reco_authors[thisMuonCategory - 1]->Fill(mu_c->author(), weight);
1011 } else if (!m_isData)
1012 m_oUnmatchedTruthMuonPlots->fill(*truthMu, weight);
1013 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoSlowMuon
const xAOD::SlowMuon * findRecoSlowMuon(const xAOD::TruthParticle *truthMu)
Definition MuonPhysValMonitoringTool.cxx:1301
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuon
const xAOD::Muon * findRecoMuon(const xAOD::TruthParticle *truthMu)
Definition MuonPhysValMonitoringTool.cxx:1290
MuonPhysValMonitoring::MuonPhysValMonitoringTool::printTruthMuonDebug
void printTruthMuonDebug(const xAOD::TruthParticle *truthMu, const xAOD::Muon *mu)
Definition MuonPhysValMonitoringTool.cxx:1318
xAOD::SlowMuon_v1::muonLink
const ElementLink< MuonContainer > & muonLink() const
xAOD::SlowMuon
SlowMuon_v1 SlowMuon
Reference the current persistent version:
Definition SlowMuon.h:13

◆ handleTruthMuonSegment()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleTruthMuonSegment ( const xAOD::MuonSegment * truthMuSeg,
const xAOD::TruthParticleContainer * muonTruthContainer,
float weight = 1.0 )
private

Definition at line 866 of file MuonPhysValMonitoringTool.cxx.

867 {
868 const xAOD::MuonSegment* muSeg = findRecoMuonSegment(truthMuSeg);
870
871 unsigned int thisMuonCategory = ALL; // getMuonSegmentTruthCategory(truthMuSeg, muonTruthContainer) @@@ Does not work...
872
873 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
874 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
875 m_muonSegmentValidationPlots[i]->fill(truthMuSeg, muSeg,
876 weight); // if no reco muon segment is found a protection inside
877 // MuonSegmentValidationPlots will ensure, its plots won't be filled
878 }
879 }
880 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuonSegment
const xAOD::MuonSegment * findRecoMuonSegment(const xAOD::MuonSegment *truthMuSeg)
Definition MuonPhysValMonitoringTool.cxx:1349
xAOD::MuonSegment
MuonSegment_v1 MuonSegment
Reference the current persistent version:
Definition Event/xAOD/xAODMuon/xAODMuon/MuonSegment.h:13

◆ initialize()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::initialize ( )
overridevirtual

Reimplemented from ManagedMonitorToolBase.

Definition at line 65 of file MuonPhysValMonitoringTool.cxx.

65 {
66 ATH_MSG_INFO("Initializing " << name() << "...");
67 ATH_CHECK(ManagedMonitorToolBase::initialize());
68
69 for (unsigned int i = 0; i < m_selectHLTMuonItems.size(); i++) {
70 if (m_selectHLTMuonItems[i][0] == "" || m_selectHLTMuonItems[i][1] == "") continue;
71 m_muonItems.emplace_back(m_selectHLTMuonItems[i][0]);
72 m_L1Seed.emplace_back(m_selectHLTMuonItems[i][1]);
73 }
74
75 // setup flags
76 if (m_doTrigMuonValidation == false) {
77 m_doTrigMuonL1Validation = false;
78 m_doTrigMuonL2Validation = false;
79 m_doTrigMuonEFValidation = false;
80 }
81 ATH_CHECK(m_trigDec.retrieve(DisableTool{!m_doTrigMuonValidation}));
82
83 ATH_CHECK(m_eventInfo.initialize());
84 ATH_CHECK(m_muonSelectionTool.retrieve());
85 ATH_CHECK(m_trackSelector.retrieve());
86 ATH_CHECK(m_isoTool.retrieve());
87
88 ATH_CHECK(m_tracksName.initialize());
89 ATH_CHECK(m_fwdtracksName.initialize(!m_fwdtracksName.empty()));
90 ATH_CHECK(m_muonsName.initialize());
91 ATH_CHECK(m_slowMuonsName.initialize(!m_slowMuonsName.empty()));
92
93 ATH_CHECK(m_muonTracksName.initialize());
94 ATH_CHECK(m_muonExtrapolatedTracksName.initialize());
95 ATH_CHECK(m_muonMSOnlyExtrapolatedTracksName.initialize());
96
97 ATH_CHECK(m_muonSegmentsName.initialize());
98 ATH_CHECK(m_muonsTruthName.initialize(!m_isData));
99 ATH_CHECK(m_muonSegmentsTruthName.initialize(!m_isData));
100 ATH_CHECK(m_muonL1TrigName.initialize(m_doTrigMuonL1Validation));
101 ATH_CHECK(m_muonL2SAName.initialize(m_doTrigMuonL2Validation));
102 ATH_CHECK(m_muonL2CBName.initialize(m_doTrigMuonL2Validation));
103 ATH_CHECK(m_muonEFCombTrigName.initialize(m_doTrigMuonEFValidation));
104
105 if (!m_isData) {
106 const std::vector<std::string> truthDecors{"truthOrigin", "truthType", "truthParticleLink"};
107 const std::vector<std::string> keys{m_tracksName.key(), m_fwdtracksName.key(), m_muonsName.key(),
108 m_slowMuonsName.key(), m_muonTracksName.key(), m_muonExtrapolatedTracksName.key(),
109 m_muonMSOnlyExtrapolatedTracksName.key()};
110 for (const std::string& key : keys) {
111 if (key.empty()) continue;
112 for (const std::string& decor : truthDecors){
113 m_decorDep.emplace_back(std::format("{:}.{:}", key , decor));
114 }
115 }
116 const std::vector<std::string> truthPartDecors{"MuonEntryLayer_px", "nprecLayers",
117 "truthOrigin", "truthType"};
118
119 for (const std::string& decor: truthPartDecors) {
120 m_decorDep.emplace_back(m_muonsTruthName, decor);
121 }
122
123
124
125 }
126
127 ATH_CHECK(m_decorDep.initialize());
128 return StatusCode::SUCCESS;
129 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_decorDep
SG::ReadDecorHandleKeyArray< xAOD::IParticleContainer > m_decorDep
Definition MuonPhysValMonitoringTool.h:141
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_isoTool
ToolHandle< CP::IIsolationSelectionTool > m_isoTool
Definition MuonPhysValMonitoringTool.h:172

◆ inputHandles()

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

◆ interfaceID()

const InterfaceID & IMonitorToolBase::interfaceID ( )
inlinestaticinherited

Definition at line 29 of file IMonitorToolBase.h.

29{ return IID_IMonitorToolBase; }
IID_IMonitorToolBase
static const InterfaceID IID_IMonitorToolBase("IMonitorToolBase", 1, 0)

◆ intervalEnumToString()

std::string ManagedMonitorToolBase::intervalEnumToString ( Interval_t interval)
staticinherited

Converts a LevelOfDetail_t to a string of the same name.

Converts a string to the corresponding LevelOfDetail_t. Converts a Interval_t to a string of the same name.

Definition at line 535 of file ManagedMonitorToolBase.cxx.

537{
538 std::string str("file");
539
540 switch( interval ) {
541 case all:
542 str = "all";
543 break;
544 case fill:
545 str = "fill";
546 break;
547 case run:
548 str = "run";
549 break;
550 case lowStat:
551 str = "lowStat";
552 break;
553 case medStat:
554 str = "medStat";
555 break;
556 case higStat:
557 str = "higStat";
558 break;
559 case lumiBlock:
560 str = "lumiBlock";
561 break;
562 case eventsBlock:
563 str = "eventsBlock";
564 break;
565 case file:
566 str = "file";
567 break;
568 default:
569 str = "unknown";
570 }
571
572 return str;
573}

◆ intervalStringToEnum()

ManagedMonitorToolBase::Interval_t ManagedMonitorToolBase::intervalStringToEnum ( const std::string & str)
staticinherited

Converts a string to the corresponding Interval_t.

Definition at line 577 of file ManagedMonitorToolBase.cxx.

579{
580 std::string lcstr( strToLower(str) );
581
582 if( lcstr == "all" )
583 return all;
584 else if( lcstr == "fill" )
585 return fill;
586 else if( lcstr == "run" )
587 return run;
588 else if( lcstr == "lowStat" )
589 return lowStat;
590 else if( lcstr == "medStat" )
591 return medStat;
592 else if( lcstr == "higStat" )
593 return higStat;
594 else if( lcstr == "lumiBlock" )
595 return lumiBlock;
596 else if( lcstr == "eventsBlock" )
597 return eventsBlock;
598 else if( lcstr == "file" )
599 return file;
600
601 if( Imp::s_svcLocator ) {
602 SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
603 if( ms.isValid() ) {
604 MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
605 log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
606 << str << "\", returning \"file\"" << endmsg;
607 }
608 }
609
610 return file;
611}
ManagedMonitorToolBase::Imp::s_svcLocator
static std::atomic< ISvcLocator * > s_svcLocator
Definition ManagedMonitorToolBase.cxx:38

◆ L2CBTriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2CBTriggerResolution ( )
private

Definition at line 1185 of file MuonPhysValMonitoringTool.cxx.

1185 {
1186 int k_L2CBMu_MinDeltaR = -1;
1187 float MinDeltaR = 0.;
1188 ATH_MSG_DEBUG(" m_vL2CBMuons.size()" << m_vL2CBMuons.size());
1189 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1190 ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1191 << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1192 }
1193 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1194 if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1195 ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1196 << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1197 k_L2CBMu_MinDeltaR = -1;
1198 MinDeltaR = 1000;
1199 ATH_MSG_DEBUG("==============>>>> k_L2CBMu_MinDeltaR=" << k_L2CBMu_MinDeltaR << " MinDeltaR" << MinDeltaR);
1200 for (unsigned int k = 0; k < m_vL2CBMuons.size(); k++) {
1201 ATH_MSG_DEBUG(" :::::::: TEST: L2CB pt=" << m_vL2CBMuons.at(k)->pt() << " eta=" << m_vL2CBMuons.at(k)->eta()
1202 << " phi=" << m_vL2CBMuons.at(k)->phi()
1203 << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)));
1204 if ((deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)) < 0.1 &&
1205 (deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)) < MinDeltaR))) {
1206 k_L2CBMu_MinDeltaR = k;
1207 MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k));
1208 ATH_MSG_DEBUG("==============>>>> taken!!!! k_L2CBMu_MinDeltaR=" << k_L2CBMu_MinDeltaR << " MinDeltaR"
1209 << MinDeltaR);
1210 }
1211 }
1212 if (k_L2CBMu_MinDeltaR == -1) continue;
1213 for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1214 if (m_selectMuonCategories[c] == ALL) {
1215 m_TriggerMuonValidationPlots[c]->fill(*m_vL2CBMuons.at(k_L2CBMu_MinDeltaR), *m_vRecoMuons.at(i));
1216 }
1217 }
1218 }
1219 }

◆ L2SATriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2SATriggerResolution ( )
private

Definition at line 1138 of file MuonPhysValMonitoringTool.cxx.

1138 {
1139 int k_L2SAMu_MinDeltaR = -1;
1140 float MinDeltaR = 0.;
1141 ATH_MSG_DEBUG(" m_vL2SAMuons.size()" << m_vL2SAMuons.size());
1142 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1143 ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1144 << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1145 }
1146 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1147 if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1148 ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1149 << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1150 k_L2SAMu_MinDeltaR = -1;
1151 MinDeltaR = 1000;
1152 ATH_MSG_DEBUG("==============>>>> k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << " MinDeltaR" << MinDeltaR);
1153 for (unsigned int k = 0; k < m_vL2SAMuons.size(); k++) {
1154 ATH_MSG_DEBUG(" :::::::: TEST: L2SA pt=" << m_vL2SAMuons.at(k)->pt() << " eta=" << m_vL2SAMuons.at(k)->eta()
1155 << " phi=" << m_vL2SAMuons.at(k)->phi()
1156 << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)));
1157 if ((deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < 0.1 &&
1158 (deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < MinDeltaR))) {
1159 k_L2SAMu_MinDeltaR = k;
1160 MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k));
1161 ATH_MSG_DEBUG("==============>>>> taken!!!! k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << " MinDeltaR"
1162 << MinDeltaR);
1163 }
1164 }
1165 if (k_L2SAMu_MinDeltaR == -1) continue;
1166 for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1167 if (m_selectMuonCategories[c] == ALL) {
1168 m_TriggerMuonValidationPlots[c]->fill(*m_vL2SAMuons.at(k_L2SAMu_MinDeltaR), *m_vRecoMuons.at(i));
1169 }
1170 }
1171 }
1172 }

◆ lbAverageInteractionsPerCrossing()

float ManagedMonitorToolBase::lbAverageInteractionsPerCrossing ( const EventContext & ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average mu, i.e.

<mu>

Definition at line 1691 of file ManagedMonitorToolBase.cxx.

1693{
1694 if (!m_lumiDataKey.empty()) {
1695 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1696 return lumi->lbAverageInteractionsPerCrossing();
1697 } else {
1698 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageInteractionsPerCrossing() can't work properly! ");
1699 ATH_MSG_DEBUG("Warning: lbAverageInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1700 return -1.0;
1701 }
1702 // not reached
1703}
ManagedMonitorToolBase::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition ManagedMonitorToolBase.h:887

◆ lbAverageLivefraction()

float ManagedMonitorToolBase::lbAverageLivefraction ( const EventContext & ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average luminosity livefraction.

Definition at line 1760 of file ManagedMonitorToolBase.cxx.

1762{
1763 if (m_environment == AthenaMonManager::online)
1764 return 1.0;
1765
1766 if (!m_trigLiveFractionDataKey.empty()) {
1767 SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
1768 return live->lbAverageLiveFraction();
1769 } else {
1770 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
1771 ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
1772 return -1.0;
1773 }
1774 // not reached
1775}
ManagedMonitorToolBase::m_trigLiveFractionDataKey
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey
Definition ManagedMonitorToolBase.h:891

◆ lbAverageLuminosity()

float ManagedMonitorToolBase::lbAverageLuminosity ( const EventContext & ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)

Definition at line 1727 of file ManagedMonitorToolBase.cxx.

1729{
1730 if (!m_lumiDataKey.empty()) {
1731 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1732 return lumi->lbAverageLuminosity();
1733 } else {
1734 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLuminosity() can't work properly! ");
1735 ATH_MSG_DEBUG("Warning: lbAverageLuminosity() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1736 return -1.0;
1737 }
1738 // not reached
1739}

◆ lbDuration()

double ManagedMonitorToolBase::lbDuration ( const EventContext & ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Luminosity block time (in seconds)

Definition at line 1814 of file ManagedMonitorToolBase.cxx.

1816{
1817 if ( m_environment == AthenaMonManager::online ) {
1818 return m_defaultLBDuration;
1819 }
1820 if (!m_lbDurationDataKey.empty()) {
1821 SG::ReadCondHandle<LBDurationCondData> dur (m_lbDurationDataKey, ctx);
1822 return dur->lbDuration();
1823 } else {
1824 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbDuration() can't work properly! ");
1825 ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1826 return m_defaultLBDuration;
1827 }
1828 // not reached
1829}
ManagedMonitorToolBase::m_lbDurationDataKey
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey
Definition ManagedMonitorToolBase.h:889

◆ lbInteractionsPerCrossing()

float ManagedMonitorToolBase::lbInteractionsPerCrossing ( const EventContext & ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Instantaneous number of interactions, i.e.

mu

Definition at line 1707 of file ManagedMonitorToolBase.cxx.

1709{
1710 if (!m_lumiDataKey.empty()) {
1711 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1712 float muToLumi = lumi->muToLumi();
1713 if (muToLumi > 0) {
1714 return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id()) / muToLumi;
1715 }
1716 return 0;
1717 } else {
1718 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbInteractionsPerCrossing() can't work properly! ");
1719 ATH_MSG_DEBUG("Warning: lbInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1720 return -1.0;
1721 }
1722 // not reached
1723}

◆ lbLuminosityPerBCID()

float ManagedMonitorToolBase::lbLuminosityPerBCID ( const EventContext & ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Instantaneous luminosity.

Definition at line 1743 of file ManagedMonitorToolBase.cxx.

1745{
1746 if (!m_lumiDataKey.empty()) {
1747 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1748 return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id());
1749 } else {
1750 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLuminosityPerBCID() can't work properly! ");
1751 ATH_MSG_DEBUG("Warning: lbLuminosityPerBCID() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1752 return -1.0;
1753 }
1754 // not reached
1755}

◆ lbLumiWeight()

double ManagedMonitorToolBase::lbLumiWeight ( const EventContext & ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Average Integrated Luminosity Live Fraction.

Definition at line 1798 of file ManagedMonitorToolBase.cxx.

1800{
1801 if (!m_lumiDataKey.empty()) {
1802 return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
1803 } else{
1804 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLumiWeight() can't work properly! ");
1805 ATH_MSG_DEBUG("Warning: lbLumiWeight() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1806 return -1.0;
1807 }
1808 // not reached
1809}
ManagedMonitorToolBase::lbAverageLivefraction
virtual float lbAverageLivefraction(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity livefraction.
Definition ManagedMonitorToolBase.cxx:1761
ManagedMonitorToolBase::lbAverageLuminosity
virtual float lbAverageLuminosity(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
Definition ManagedMonitorToolBase.cxx:1728
ManagedMonitorToolBase::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Luminosity block time (in seconds)
Definition ManagedMonitorToolBase.cxx:1815

◆ livefractionPerBCID()

float ManagedMonitorToolBase::livefractionPerBCID ( const EventContext & ctx = Gaudi::Hive::currentContext()) const
virtualinherited

Livefraction per bunch crossing ID.

Definition at line 1779 of file ManagedMonitorToolBase.cxx.

1781{
1782 if (m_environment == AthenaMonManager::online)
1783 return 1.0;
1784
1785 if (!m_trigLiveFractionDataKey.empty()) {
1786 SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
1787 return live->l1LiveFractionVector().at (ctx.eventID().bunch_crossing_id());
1788 } else {
1789 //ATH_MSG_FATAL("! Luminosity tool has been disabled ! livefractionPerBCID() can't work properly! ");
1790 ATH_MSG_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
1791 return -1.0;
1792 }
1793 // not reached
1794}

◆ ManagedMonitorToolBase()

ManagedMonitorToolBase::ManagedMonitorToolBase ( const std::string & type,
const std::string & name,
const IInterface * parent )

Constructor with parameters:

Definition at line 388 of file ManagedMonitorToolBase.cxx.

340 : AthAlgTool( type, name, parent )
341 , m_manager(0)
342 , m_managerNameProp("AthenaMonManager")
343 , m_fileKey("")
344 , m_dataTypeStr("userDefined")
345 , m_environmentStr("noOutput")
346 , m_detailLevel(1)
347 , m_dataType(AthenaMonManager::userDefined)
348 , m_environment(AthenaMonManager::user)
349 , m_streamNameFcn(0)
350 , m_THistSvc("THistSvc",name)
351 , m_procNEventsProp(0)
352 , m_path("")
353 , m_preScaleProp(0)
354 , m_triggerChainProp("")
355 , m_triggerGroupProp("")
356 , m_useTrigger(false)
357 , m_lastLumiBlock(0)
358 , m_lastRun(0)
359 , m_lastLowStatInterval(-1)
360 , m_lastMedStatInterval(-1)
361 , m_lastHigStatInterval(-1)
362 , m_nEvents(1)
363 , m_nEventsIgnoreTrigger(1)
364 , m_nLumiBlocks(1)
365 , m_haveClearedLastEventBlock(true)
366 , m_bookHistogramsInitial(false)
367 , m_useLumi(false)
368 , m_defaultLBDuration(60.)
369 , m_d(new Imp(this))
370{
371// ManagedMonitorToolBase_resetHistStatistics(this);
372 declareInterface<IMonitorToolBase>(this);
373 declareProperty( "ProcessNEvents", m_procNEventsProp );
374 declareProperty( "histoPathBase", m_path );
375 declareProperty( "PreScale", m_preScaleProp );
376 declareProperty( "TriggerChain", m_triggerChainProp );
377 declareProperty( "TriggerGroup", m_triggerGroupProp );
378
379 // If a class would like to associate itself to a manager but cannot actually
380 // be referenced by it, the manager name can be set explicitly. Otherwise,
381 // it is set automatically.
382 declareProperty( "ManagerName", m_managerNameProp );
383
384 // Enable luminosity tool?
385 declareProperty( "EnableLumi", m_useLumi );
386
387 // How detailed should the monitoring be?
388 declareProperty( "DetailLevel", m_detailLevel );
389
390 // If we don't know how long an LB is, here's the default
391 declareProperty( "DefaultLBDuration", m_defaultLBDuration );
392
393 // Properties that are overridden in initialize()---settings via jobOptions are ignored!
394 declareProperty( "FileKey", m_fileKey );
395 declareProperty( "DataType", m_dataTypeStr );
396 declareProperty( "Environment", m_environmentStr );
397
398 if( !Imp::s_svcLocator )
399 Imp::s_svcLocator = svcLoc();
400
401 for (auto interval: { eventsBlock, lumiBlock, lowStat, run, all }) {
402 m_templateHistograms[interval] = std::vector< MgmtParams<TH1> >();
403 m_templateGraphs[interval] = std::vector< MgmtParams<TGraph> >();
404 m_templateTrees[interval] = std::vector< MgmtParams<TTree> >();
405 m_supportedIntervalsForRebooking.insert(interval);
406 }
407
408 newLowStatInterval = false;
409 newMedStatInterval = false;
410 newHigStatInterval = false;
411 newLowStat = false;
412 newLumiBlock = false;
413 newRun = false;
414 newEventsBlock = false;
415 endOfEventsBlock = false;
416 endOfLowStat = false;
417 endOfLumiBlock = false;
418 endOfRun = false;
419
420 m_newLowStatInterval = false;
421 m_newMedStatInterval = false;
422 m_newHigStatInterval = false;
423 m_newLowStat = false;
424 m_newLumiBlock = false;
425 m_newRun = false;
426 m_newEventsBlock = false;
427 m_endOfEventsBlock = false;
428 m_endOfLowStat = false;
429 m_endOfLumiBlock = false;
430 m_endOfRun = false;
431}
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
ManagedMonitorToolBase::m_supportedIntervalsForRebooking
std::set< Interval_t > m_supportedIntervalsForRebooking
Definition ManagedMonitorToolBase.h:896

◆ MMTB_DEPRECATED() [1/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfEventsBlock )
inherited

◆ MMTB_DEPRECATED() [2/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLowStat )
inherited

◆ MMTB_DEPRECATED() [3/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLumiBlock )
inherited

◆ MMTB_DEPRECATED() [4/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfRun )
inherited

◆ MMTB_DEPRECATED() [5/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newEventsBlock )
inherited

◆ MMTB_DEPRECATED() [6/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newHigStatInterval )
inherited

◆ MMTB_DEPRECATED() [7/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStat )
inherited

◆ MMTB_DEPRECATED() [8/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStatInterval )
inherited

◆ MMTB_DEPRECATED() [9/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLumiBlock )
inherited

◆ MMTB_DEPRECATED() [10/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newMedStatInterval )
inherited

◆ MMTB_DEPRECATED() [11/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newRun )
inherited

◆ modifyHistogram()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::modifyHistogram ( TH1 * hist)
private

Definition at line 1432 of file MuonPhysValMonitoringTool.cxx.

1432 {
1433 std::string histname = hist->GetName();
1434
1435 if(m_muonsName.key() == "Muons"){
1436 if (histname.find("parameters_z0") != std::string::npos) {
1437 hist->GetXaxis()->Set(80, -200., 200.);
1438 }
1439 if (histname.find("parameters_d0") != std::string::npos && histname.find("parameters_d0_small") == std::string::npos) {
1440 hist->GetXaxis()->Set(80, -1., 1.);
1441 hist->GetYaxis()->SetTitle("Entries / 0.025 mm");
1442 }
1443 } else if(m_muonsName.key() == "MuonsLRT"){
1444 if (histname.find("parameters_d0") != std::string::npos && histname.find("parameters_d0_small") == std::string::npos) {
1445 hist->Rebin(100);
1446 hist->GetYaxis()->SetTitle("Entries / 2.5 mm");
1447 }
1448 }
1449
1450
1451 if (histname.find("trigger_L1_pt") != std::string::npos) { // if (histname=="Muons_All_trigger_L1_pt"){
1452 hist->SetTitle("L1Trigger Muons pt threshold");
1453 hist->GetXaxis()->SetTitle("L1Trigger Muons pt threshold [GeV]");
1454 hist->GetXaxis()->Set(30, -0.5, 29.5);
1455 }
1456 if (histname.find("trigger_L1_eta_pt") != std::string::npos) { // if (histname=="Muons_All_trigger_L1_eta_pt") {
1457 hist->SetTitle("L1Trigger Muons pt threshold vs eta");
1458 hist->GetYaxis()->Set(90, -0.5, 29.5);
1459 hist->GetYaxis()->SetTitle("L1Trigger Muons pt threshold [GeV]");
1460 }
1461
1462 if (histname.find("trigger") != std::string::npos &&
1463 ((histname.find("Denom_pt") != std::string::npos) || (histname.find("Numer_pt") != std::string::npos) ||
1464 (histname.find("Features_pt") != std::string::npos)))
1465 hist->GetXaxis()->Set(200, 0., 200.);
1466
1467 if (histname.find("hits") != std::string::npos) {
1468 if (histname.find("etaLayer2") != std::string::npos)
1469 hist->GetXaxis()->Set(15, -0.5, 14.5);
1470 else if (histname.find("etaLayer") != std::string::npos)
1471 hist->GetXaxis()->Set(11, -0.5, 10.5);
1472 }
1473
1475 bool is2D = !(histname.find("_vs_") == std::string::npos);
1477
1478 if (histname.find("METrackParticles") != std::string::npos) {
1479 if (histname.find("Res_eta") != std::string::npos) {
1480 if (is2D)
1481 hist->GetYaxis()->Set(50, -0.025, 0.025);
1482 else
1483 hist->GetXaxis()->Set(50, -0.025, 0.025);
1484 } else if (histname.find("Res_phi") != std::string::npos) {
1485 if (is2D)
1486 hist->GetYaxis()->Set(50, -0.02, 0.02);
1487 else
1488 hist->GetXaxis()->Set(50, -0.02, 0.02);
1489 }
1490 } else if (histname.find("MSTrackParticles") != std::string::npos) {
1491 if (histname.find("Res_eta") != std::string::npos) {
1492 if (is2D)
1493 hist->GetYaxis()->Set(50, -0.025, 0.025);
1494 else
1495 hist->GetXaxis()->Set(50, -0.025, 0.025);
1496 } else if (histname.find("Res_phi") != std::string::npos) {
1497 if (is2D)
1498 hist->GetYaxis()->Set(50, -0.05, 0.05);
1499 else
1500 hist->GetXaxis()->Set(50, -0.05, 0.05);
1501 }
1502 } else {
1503 if (histname.find("Res_eta") != std::string::npos) {
1504 if (is2D)
1505 hist->GetYaxis()->Set(50, -0.005, 0.005);
1506 else
1507 hist->GetXaxis()->Set(50, -0.005, 0.005);
1508 } else if (histname.find("Res_phi") != std::string::npos) {
1509 if (is2D)
1510 hist->GetYaxis()->Set(50, -0.002, 0.002);
1511 else
1512 hist->GetXaxis()->Set(50, -0.002, 0.002);
1513 }
1514 }
1515
1516 if (histname.find("trigger") != std::string::npos) {
1517 // RESO EF - MC
1518 if ((!m_isData) && histname.find("MuidCo") != std::string::npos &&
1519 (histname.find("BARREL") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
1520 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1521 hist->GetXaxis()->Set(100, -0.04, 0.04);
1522 }
1523 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.04, 0.04); }
1524 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1525 hist->GetXaxis()->Set(100, -0.0005, 0.0005);
1526 }
1527 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
1528
1529 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1530 hist->GetXaxis()->Set(100, -0.0002, 0.0002);
1531 }
1532 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0002, 0.0002); }
1533 }
1534 if ((!m_isData) && histname.find("MuidCo") != std::string::npos && (histname.find("ENDCAPS") != std::string::npos)) {
1535 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1536 hist->GetXaxis()->Set(100, -0.05, 0.05);
1537 }
1538 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.05, 0.05); }
1539 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1540 hist->GetXaxis()->Set(100, -0.001, 0.001);
1541 }
1542 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
1543
1544 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1545 hist->GetXaxis()->Set(100, -0.0003, 0.0003);
1546 }
1547 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0003, 0.0003); }
1548 }
1549 if ((!m_isData) && histname.find("MuidSA") != std::string::npos) {
1550 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1551 hist->GetXaxis()->Set(100, -0.03, 0.03);
1552 }
1553 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1554
1555 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1556 hist->GetXaxis()->Set(100, -0.03, 0.03);
1557 }
1558 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1559 }
1560 if ((!m_isData) && histname.find("MuidSA") != std::string::npos && (histname.find("BARREL") != std::string::npos)) {
1561 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1562 hist->GetXaxis()->Set(100, -0.15, 0.15);
1563 }
1564 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.15, 0.15); }
1565 }
1566 if ((!m_isData) && histname.find("MuidSA") != std::string::npos &&
1567 (histname.find("ENDCAPS") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
1568 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1569 hist->GetXaxis()->Set(100, -0.2, 0.2);
1570 }
1571 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.2, 0.2); }
1572 }
1573
1574 // RESO EF - DATA
1575 if ((m_isData) && histname.find("MuidCo") != std::string::npos &&
1576 (histname.find("BARREL") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
1577 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1578 hist->GetXaxis()->Set(100, -0.06, 0.06);
1579 }
1580 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.06, 0.06); }
1581 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1582 hist->GetXaxis()->Set(100, -0.001, 0.001);
1583 }
1584 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
1585
1586 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1587 hist->GetXaxis()->Set(100, -0.0005, 0.0005);
1588 }
1589 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
1590 }
1591 if ((m_isData) && histname.find("MuidCo") != std::string::npos && (histname.find("ENDCAPS") != std::string::npos)) {
1592 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1593 hist->GetXaxis()->Set(100, -0.1, 0.1);
1594 }
1595 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.1, 0.1); }
1596 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1597 hist->GetXaxis()->Set(100, -0.0015, 0.0015);
1598 }
1599 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0015, 0.0015); }
1600
1601 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1602 hist->GetXaxis()->Set(100, -0.0005, 0.0005);
1603 }
1604 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
1605 }
1606 if ((m_isData) && histname.find("MuidSA") != std::string::npos) {
1607 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1608 hist->GetXaxis()->Set(100, -0.03, 0.03);
1609 }
1610 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1611
1612 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1613 hist->GetXaxis()->Set(100, -0.03, 0.03);
1614 }
1615 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1616 }
1617 if ((m_isData) && histname.find("MuidSA") != std::string::npos && (histname.find("BARREL") != std::string::npos)) {
1618 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1619 hist->GetXaxis()->Set(100, -0.3, 0.3);
1620 }
1621 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.3, 0.3); }
1622 }
1623 if ((m_isData) && histname.find("MuidSA") != std::string::npos &&
1624 (histname.find("ENDCAPS") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
1625 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1626 hist->GetXaxis()->Set(100, -0.5, 0.5);
1627 }
1628 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.5, 0.5); }
1629 }
1630
1631 // LEVEL2
1632 if ((histname.find("L2_StandAlone") != std::string::npos)) {
1633 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1634 hist->GetXaxis()->Set(100, -0.03, 0.03);
1635 }
1636 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1637
1638 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1639 hist->GetXaxis()->Set(100, -0.03, 0.03);
1640 }
1641 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
1642 }
1643 if ((histname.find("L2_StandAlone") != std::string::npos) && (histname.find("BARREL") != std::string::npos)) {
1644 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1645 hist->GetXaxis()->Set(100, -0.3, 0.3);
1646 }
1647 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.3, 0.3); }
1648 }
1649 if ((histname.find("L2_StandAlone") != std::string::npos) &&
1650 ((histname.find("ENDCAPS") != std::string::npos) || (histname.find("WHOLE_DETECT") != std::string::npos))) {
1651 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1652 hist->GetXaxis()->Set(100, -0.5, 0.5);
1653 }
1654 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.5, 0.5); }
1655 }
1656
1657 if ((histname.find("L2_Combined") != std::string::npos)) {
1658 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1659 hist->GetXaxis()->Set(100, -0.002, 0.002);
1660 }
1661 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.002, 0.002); }
1662
1663 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1664 hist->GetXaxis()->Set(100, -0.001, 0.001);
1665 }
1666 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
1667 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
1668 hist->GetXaxis()->Set(100, -0.2, 0.2);
1669 }
1670 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.2, 0.2); }
1671 }
1672 }
1673 }

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ newEventsBlockFlag()

bool ManagedMonitorToolBase::newEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 793 of file ManagedMonitorToolBase.h.

793{ return m_newEventsBlock; }

◆ newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 789 of file ManagedMonitorToolBase.h.

789{ return m_newHigStatInterval; }

◆ newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 790 of file ManagedMonitorToolBase.h.

790{ return m_newLowStat; }

◆ newLowStatIntervalFlag()

bool ManagedMonitorToolBase::newLowStatIntervalFlag ( ) const
inlineprotectedinherited

Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called.

Definition at line 787 of file ManagedMonitorToolBase.h.

787{ return m_newLowStatInterval; }

◆ newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 791 of file ManagedMonitorToolBase.h.

791{ return m_newLumiBlock; }

◆ newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 788 of file ManagedMonitorToolBase.h.

788{ return m_newMedStatInterval; }

◆ newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const
inlineprotectedinherited

Definition at line 792 of file ManagedMonitorToolBase.h.

792{ return m_newRun; }

◆ outputHandles()

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

◆ parseList()

StatusCode ManagedMonitorToolBase::parseList ( const std::string & line,
std::vector< std::string > & result )
protectedinherited

Definition at line 2111 of file ManagedMonitorToolBase.cxx.

2112 {
2113 std::string item;
2114 std::stringstream ss(line);
2115
2116 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
2117
2118 while ( std::getline(ss, item, ',') ) {
2119 std::stringstream iss(item); // remove
2120 iss >> item; // whitespace
2121 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
2122 result.push_back(item);
2123 }
2124
2125 msg(MSG::DEBUG) << endmsg;
2126 return StatusCode::SUCCESS;
2127}
ss
static Double_t ss
Definition LArPhysWaveHECTool.cxx:37
get_generator_info.result
result
Definition get_generator_info.py:21

◆ passesAcceptanceCuts()

bool MuonPhysValMonitoring::MuonPhysValMonitoringTool::passesAcceptanceCuts ( const xAOD::IParticle * prt)
private

Definition at line 1675 of file MuonPhysValMonitoringTool.cxx.

1675 {
1676 if (prt->pt() < 2000.) return false;
1677 if (std::abs(prt->eta()) > 2.7) return false;
1678 return true;
1679 }
xAOD::IParticle::eta
virtual double eta() const =0
The pseudorapidity ( ) of the particle.
xAOD::IParticle::pt
virtual double pt() const =0
The transverse momentum ( ) of the particle.

◆ preSelector()

bool ManagedMonitorToolBase::preSelector ( )
virtualinherited

Implements IMonitorToolBase.

Definition at line 1679 of file ManagedMonitorToolBase.cxx.

1681{
1682 if( m_preScaleProp > 1 ) {
1683 return ( (m_nEvents % m_preScaleProp) == 1 );
1684 }
1685 return true;
1686}

◆ printMuonDebug()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::printMuonDebug ( const xAOD::Muon * mu)
private

Definition at line 1280 of file MuonPhysValMonitoringTool.cxx.

1280 {
1281 const xAOD::TrackParticle* tp = mu->primaryTrackParticle();
1282 static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1283 TruthLink truthLink;
1284 if (tp) {
1285 truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
1286 }
1287 ATH_MSG_DEBUG("Muon: pt " << mu->pt() << " eta " << mu->eta() << " link " << truthLink.isValid());
1288 }

◆ printTruthMuonDebug()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::printTruthMuonDebug ( const xAOD::TruthParticle * truthMu,
const xAOD::Muon * mu )
private

Definition at line 1318 of file MuonPhysValMonitoringTool.cxx.

1318 {
1319 ATH_MSG_DEBUG("Truth muon: " << truthMu->pt() << " eta " << truthMu->eta());
1320 if (!mu) return;
1321 ATH_MSG_DEBUG("Reco muon: " << mu->pt() << " eta " << mu->eta());
1322 }
xAOD::TruthParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition TruthParticle_v1.cxx:161
xAOD::TruthParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition TruthParticle_v1.cxx:169

◆ procHistograms()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::procHistograms ( )
overridevirtual

An inheriting class should either override this function or finalHists().

Reimplemented from ManagedMonitorToolBase.

Definition at line 1324 of file MuonPhysValMonitoringTool.cxx.

1324 {
1325 ATH_MSG_INFO("Finalising hists " << name() << "...");
1326 for (const auto& plots : m_muonValidationPlots) plots->finalize();
1327 for (const auto& plots : m_TriggerMuonValidationPlots) plots->finalize();
1328 if (!m_isData) {
1329 m_oUnmatchedRecoMuonPlots->finalize();
1330 m_oUnmatchedTruthMuonPlots->finalize();
1331 }
1332
1333 for (const auto& plots : m_muonMSTrackValidationPlots) plots->finalize();
1334 for (const auto& plots : m_muonMETrackValidationPlots) plots->finalize();
1335 for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) plots->finalize();
1336 for (const auto& plots : m_muonIDTrackValidationPlots) plots->finalize();
1337 for (const auto& plots : m_muonIDSelectedTrackValidationPlots) plots->finalize();
1338 for (const auto& plots : m_muonIDForwardTrackValidationPlots) plots->finalize();
1339 if (!m_isData)
1340 if (m_oUnmatchedRecoMuonTrackPlots) m_oUnmatchedRecoMuonTrackPlots->finalize();
1341
1342 for (const auto& plots : m_muonSegmentValidationPlots) plots->finalize();
1343 if (!m_isData)
1344 if (m_oUnmatchedRecoMuonSegmentPlots) m_oUnmatchedRecoMuonSegmentPlots->finalize();
1345
1346 return StatusCode::SUCCESS;
1347 }//procHistograms*/

◆ regEfficiency()

StatusCode ManagedMonitorToolBase::regEfficiency ( TEfficiency * e,
const MonGroup & group )
virtualinherited

Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot.

Definition at line 1444 of file ManagedMonitorToolBase.cxx.

1444 {
1445 if (!e)
1446 return StatusCode::FAILURE;
1447
1448 TGraph* g = reinterpret_cast<TGraph*>(e);
1449 std::string name = e->GetName();
1450
1451 // MANAGED
1452 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1453 // warn about not using merge algorithms
1454 if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1455 ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
1456 }
1457 // add the efficiency to rebooking vector
1458 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1459 m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
1460 } else {
1461 ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
1462 return StatusCode::FAILURE;
1463 }
1464
1465 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1466 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1467 registerMetadata(streamName, name, group).ignore();
1468 return m_THistSvc->regGraph( streamName, g );
1469 } else {
1470 // UNMANAGED
1471 if( m_manager != 0 ) {
1472 std::string genericName = NoOutputStream().getStreamName( this, group, name );
1473 m_manager->writeAndDelete( genericName );
1474 m_manager->passOwnership( e, genericName );
1475 }
1476
1477 std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
1478 StatusCode smd = registerMetadata(streamName, name, group);
1479 if (smd != StatusCode::SUCCESS)
1480 return StatusCode::FAILURE;
1481
1482 return m_THistSvc->regGraph( streamName, g );
1483 }
1484}
ManagedMonitorToolBase::NoOutputStream::getStreamName
virtual std::string getStreamName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, bool usePreviousInterval=false)
A function that converts a MonGroup of logical parameters into a physical output stream name.
Definition ManagedMonitorToolBase.cxx:1937
ManagedMonitorToolBase::registerMetadata
StatusCode registerMetadata(const std::string &streamName, const std::string &hName, const MonGroup &group)
Definition ManagedMonitorToolBase.cxx:946
ManagedMonitorToolBase::intervalEnumToString
static std::string intervalEnumToString(Interval_t interval)
Converts a LevelOfDetail_t to a string of the same name.
Definition ManagedMonitorToolBase.cxx:536

◆ regGraph() [1/2]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph * g,
const MonGroup & group )
virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Reimplemented in TilePaterMonTool.

Definition at line 1498 of file ManagedMonitorToolBase.cxx.

1500{
1501 if (!g)
1502 return StatusCode::FAILURE;
1503
1504 // This part of the code deals with MANAGED type
1505 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1506 // Create an unmanaged group based on the original MonGroup instance passed
1507 // This is needed because managed graph is presented as a number of unmanaged
1508 // graphs (one per each interval)
1509 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1510
1511 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1512 m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
1513 } else {
1514 ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1515 return StatusCode::FAILURE;
1516 }
1517
1518 std::string name = g->GetName();
1519 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1520 registerMetadata(streamName, name, group).ignore();
1521 return m_THistSvc->regGraph( streamName, g );
1522 //return m_THistSvc->regGraph( streamName );
1523 }
1524
1525 // This part of the code deals with UNMANAGED type
1526 std::string gName = g->GetName();
1527
1528 if( m_manager != 0 ) {
1529 std::string genericName = NoOutputStream().getStreamName( this, group, gName );
1530 m_manager->writeAndDelete( genericName );
1531 m_manager->passOwnership( g, genericName );
1532 }
1533
1534 std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1535
1536 StatusCode smd = registerMetadata(streamName, gName, group);
1537 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1538
1539 return m_THistSvc->regGraph( streamName, g );
1540}

◆ regGraph() [2/2]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph * g,
const std::string & system,
Interval_t interval,
MgmtAttr_t histo_mgmt = ATTRIB_MANAGED,
const std::string & chain = "",
const std::string & merge = "" )
virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Reimplemented in TilePaterMonTool.

Definition at line 1488 of file ManagedMonitorToolBase.cxx.

1491{
1492 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1493 return regGraph( g, group );
1494}
ManagedMonitorToolBase::regGraph
virtual StatusCode regGraph(TGraph *g, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
Registers a TGraph to be included in the output stream using logical parameters that describe the gra...
Definition ManagedMonitorToolBase.cxx:1489

◆ regHist() [1/2]

StatusCode ManagedMonitorToolBase::regHist ( TH1 * h,
const MonGroup & group )
virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

A histogram is passed via reference to a pointer.

Reimplemented in TilePaterMonTool.

Definition at line 1352 of file ManagedMonitorToolBase.cxx.

1354{
1355// ManagedMonitorToolBase_addHistStatistics(this,h);
1356
1357 if (!h)
1358 return StatusCode::FAILURE;
1359
1360 // This part of the code deals with MANAGED type
1361 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1362 /*
1363 Create an unmanaged group based on the original MonGroup instance passed
1364 It is needed because managed histogram is presented as a number of unmanaged
1365 histograms (one per each interval)
1366 Update (PUEO) - I don't think it actually matters, and need to keep
1367 track of "proper" attribute for X_VS_LB
1368 */
1369
1370 if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1371 ATH_MSG_WARNING("HEY! You're attempting to register " << h->GetName() << " as a per-LB histogram, but you're not setting the merge algorithm! This is a SUPER-BAD idea! Use \"merge\", at least.");
1372 }
1373
1374 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1375 m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
1376 } else {
1377 ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1378 return StatusCode::FAILURE;
1379 }
1380
1381 std::string hName = h->GetName();
1382 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1383 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
1384 registerMetadata(streamName, hName, group).ignore();
1385 return m_THistSvc->regHist( streamName, h );
1386 }
1387
1388 // This part of the code deals with UNMANAGED type
1389 std::string hName = h->GetName();
1390
1391 if( m_manager != 0 ) {
1392 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1393 m_manager->writeAndDelete( genericName );
1394 m_manager->passOwnership( h, genericName );
1395 }
1396
1397 std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1398
1399 StatusCode smd = registerMetadata(streamName, hName, group);
1400 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1401
1402 return m_THistSvc->regHist( streamName, h );
1403}

◆ regHist() [2/2]

StatusCode ManagedMonitorToolBase::regHist ( TH1 * h,
const std::string & system,
Interval_t interval,
MgmtAttr_t histo_mgmt = ATTRIB_MANAGED,
const std::string & chain = "",
const std::string & merge = "" )
virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

Reimplemented in TilePaterMonTool.

Definition at line 1343 of file ManagedMonitorToolBase.cxx.

1346{
1347 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1348 return regHist( h, group );
1349}

◆ registerMetadata()

StatusCode ManagedMonitorToolBase::registerMetadata ( const std::string & streamName,
const std::string & hName,
const MonGroup & group )
protectedinherited

Definition at line 945 of file ManagedMonitorToolBase.cxx.

947 {
948 if( m_environment != AthenaMonManager::online ) {
949 TTree* metadata(0);
950 std::string mdStreamName( streamName );
951 size_t found=mdStreamName.rfind('/');
952
953 if ( found != std::string::npos )
954 mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
955
956 MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
957 if( i == m_metadataMap.end() ) {
958 metadata = new TTree( "metadata", "Monitoring Metadata" );
959 if (! metadata) return StatusCode::FAILURE;
960 StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
961 if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
962 i = m_metadataMap.emplace( mdStreamName, new OutputMetadata(metadata) ).first;
963 }
964
965 i->second->fill( hName, group.interval(), group.chain(), group.merge() );
966 }
967 return StatusCode::SUCCESS;
968}

◆ regManagedEfficiencies()

StatusCode ManagedMonitorToolBase::regManagedEfficiencies ( std::vector< MgmtParams< TEfficiency > > & templateEfficiencies)
protectedinherited

Definition at line 1139 of file ManagedMonitorToolBase.cxx.

1139 {
1140 bool allIsOk = true;
1141 for( auto& it : templateEfficiencies ) {
1142 // get components of MgmtParams and copy efficiency
1143 MonGroup group = it.m_group;
1144 TEfficiency* theEfficiency = it.m_templateHist;
1145 TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
1146 int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
1147 int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
1148 int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
1149 e->SetBins(nbins,xlow,xhigh); // reset histogram
1150 std::string name = e->GetName();
1151
1152 // make TGraph casts of TEfficiencies
1153 TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
1154 TGraph* g = reinterpret_cast<TGraph*>(e);
1155
1156 // Get the streamName for the previous interval
1157 std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1158
1159 // RE-REGISTER
1160 // 1) De-register the original graph with the THistSvc
1161 StatusCode sc1 = m_THistSvc->deReg( theGraph );
1162 if (sc1 == StatusCode::FAILURE) allIsOk = false;
1163 // 2) Fix THistSvc->deReg for TGraphs
1164 bool doneCleaning = false;
1165 std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
1166 TSeqCollection *filelist=gROOT->GetListOfFiles();
1167 for (int i=0; i<filelist->GetEntries(); i++) {
1168 ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1169 TFile* file = static_cast<TFile*>(filelist->At(i));
1170 StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1171 if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
1172 }
1173 // 3) Check if TGraph fix has been applied successfully
1174 if (!doneCleaning) {
1175 ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1176 allIsOk = false;
1177 }
1178 // 4) Register cloned histogram under previous interval streamName
1179 StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1180 if (sc3 == StatusCode::FAILURE)
1181 allIsOk = false;
1182
1183 // get streamname for interval
1184 streamName = streamNameFunction()->getStreamName( this, group, name, false );
1185 // store metadata
1186 StatusCode smd = registerMetadata(streamName, name, group);
1187 if (smd != StatusCode::SUCCESS) allIsOk = false;
1188 // Re-register the original graph
1189 StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1190 if (sc4 == StatusCode::FAILURE) allIsOk = false;
1191 }
1192
1193 if (!allIsOk) return StatusCode::FAILURE;
1194 return StatusCode::SUCCESS;
1195}
ManagedMonitorToolBase::StreamNameFcn::getDirectoryName
virtual std::string getDirectoryName(const ManagedMonitorToolBase *tool, const MonGroup &group, const std::string &objName, const bool usePreviousInterval)=0
A function that returns TDirectory path in a file that corresponds to a given MonGroup and object nam...
ManagedMonitorToolBase::THistSvc_deReg_fixTGraph
StatusCode THistSvc_deReg_fixTGraph(TFile *file, TGraph *theGraph, std::string &directoryName)
Fixes THistSvc->deReg(obj) when obj is TGraph instance.
Definition ManagedMonitorToolBase.cxx:1037
SCT_CalibAlgs::nbins
@ nbins
Definition SCT_CalibNumbers.h:10
python.envutil.filelist
filelist
print ("Checking files %s..." % fullfile)
Definition envutil.py:133

◆ regManagedGraphs()

StatusCode ManagedMonitorToolBase::regManagedGraphs ( std::vector< MgmtParams< TGraph > > & templateGraphs)
protectedinherited

Definition at line 1068 of file ManagedMonitorToolBase.cxx.

1070{
1071 // See the description for the regManagedHistograms method
1072 bool allIsOk = true;
1073
1074 for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
1075 MonGroup group = (*it).m_group;
1076
1077 // Get a handle to the graph
1078 TGraph* theGraph = (*it).m_templateHist;
1079
1080 // Clone the graph
1081 TGraph* g = static_cast<TGraph*>(theGraph->Clone());
1082 theGraph->Set(0); // equivalent to Reset() for TH1
1083
1084 // Get name
1085 std::string gName = g->GetName();
1086
1087 // Get the streamName for the previous interval
1088 std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
1089
1090 // De-register the original graph with the THistSvc
1091 StatusCode sc1 = m_THistSvc->deReg( theGraph );
1092 if (sc1 == StatusCode::FAILURE)
1093 allIsOk = false;
1094
1095 // *** begin ***
1096 // Fix THistSvc->deReg for TGraphs
1097 bool doneCleaning = false;
1098 std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
1099 TSeqCollection *filelist=gROOT->GetListOfFiles();
1100 for (int i=0; i<filelist->GetEntries(); i++) {
1101 ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1102 TFile* file = static_cast<TFile*>(filelist->At(i));
1103 StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1104 if (sc2 == StatusCode::SUCCESS)
1105 doneCleaning = true;
1106 }
1107
1108 // Check if TGraph fix has been applied successfully
1109 if (!doneCleaning) {
1110 ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1111 allIsOk = false;
1112 }
1113 // *** end ***
1114
1115 // Register clonned histogram under previous interval streamName
1116 StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1117 if (sc3 == StatusCode::FAILURE)
1118 allIsOk = false;
1119
1120 // Get streamName for the current interval
1121 streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1122 // Register metadata information with the current interval streamname
1123 StatusCode smd = registerMetadata(streamName, gName, group);
1124 if (smd != StatusCode::SUCCESS)
1125 allIsOk = false;
1126
1127 // Re-register the original graph with the current interval streamName
1128 StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1129 if (sc4 == StatusCode::FAILURE)
1130 allIsOk = false;
1131
1132 }
1133
1134 if (!allIsOk) return StatusCode::FAILURE;
1135
1136 return StatusCode::SUCCESS;
1137}

◆ regManagedHistograms()

StatusCode ManagedMonitorToolBase::regManagedHistograms ( std::vector< MgmtParams< TH1 > > & templateHistograms)
protectedinherited

Definition at line 971 of file ManagedMonitorToolBase.cxx.

973{
974 // The method registers histograms with the THistSvc and saves them to file.
975
976 // The funky business with registering and deregistering the histogram is needed
977 // to get the correct directory when saving histograms. THistSvc deals with ROOT
978 // to set up proper TDirectory, so we rely on it.
979 // E.g.
980 // m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
981 // m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
982 // at the end of execution
983 // use passownership of the histogram and save it to file
984 // m_manager->passOwnership( h, genericName );
985 // m_manager->writeAndDelete( genericName );
986 bool allIsOk = true;
987
988 for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
989 MonGroup& group = (*it).m_group;
990
991 // Get a handle to the histogram
992 TH1* theHist = (*it).m_templateHist;
993
994 // Clone the histogram
995 TH1* h = static_cast<TH1*>(theHist->Clone());
996 theHist->Reset();
997
998 // Get name
999 std::string hName = h->GetName();
1000
1001 // Get the streamName for the previous interval
1002 std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
1003
1004 // Register the histogram with the THistSvc
1005 StatusCode sc1 = m_THistSvc->deReg( theHist );
1006 if (sc1 == StatusCode::FAILURE) allIsOk = false;
1007
1008 // Register clonned histogram under previous interval streamName
1009 StatusCode sc2 = m_THistSvc->regHist( streamName, h );
1010 if (sc2 == StatusCode::FAILURE) allIsOk = false;
1011
1012 if( m_manager != 0 ) {
1013 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1014 m_manager->passOwnership( h, genericName );
1015 m_manager->writeAndDelete( genericName );
1016 }
1017
1018 // Get streamName for the current interval
1019 streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1020 // Register metadata information with the current interval streamname
1021 StatusCode smd = registerMetadata(streamName, hName, group);
1022 if (smd != StatusCode::SUCCESS) allIsOk = false;
1023
1024 // Re-register the original histogram with the current interval streamName
1025 StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
1026 if (sc3 == StatusCode::FAILURE) allIsOk = false;
1027
1028 }
1029
1030 if (!allIsOk) return StatusCode::FAILURE;
1031
1032 return StatusCode::SUCCESS;
1033}

◆ regManagedTrees()

StatusCode ManagedMonitorToolBase::regManagedTrees ( std::vector< MgmtParams< TTree > > & templateTrees)
protectedinherited

Definition at line 1199 of file ManagedMonitorToolBase.cxx.

1201{
1202 // See the description for the regManagedHistograms method
1203 bool allIsOk = true;
1204
1205 for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
1206 MonGroup group = (*it).m_group;
1207
1208 // Get a handle to the original tree
1209 TTree* theTree = (*it).m_templateHist;
1210
1211 // Clone the tree
1212 TTree* t = static_cast<TTree*>(theTree->Clone());
1213 theTree->Reset();
1214
1215 // Dumping the tree
1216 std::string name = t->GetName();
1217
1218 // Get the streamName for the previous interval
1219 std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1220
1221 // De-register original tree with the THistSvc
1222 StatusCode sc1 = m_THistSvc->deReg( theTree );
1223 if (sc1 == StatusCode::FAILURE) allIsOk = false;
1224
1225 // Register clonned tree under previous interval streamName
1226 StatusCode sc2 = m_THistSvc->regTree( streamName, t );
1227 if (sc2 == StatusCode::FAILURE) allIsOk = false;
1228
1229 if( m_manager != 0 ) {
1230 std::string genericName = NoOutputStream().getStreamName( this, group, name );
1231 m_manager->passOwnership( t, genericName );
1232 m_manager->writeAndDelete( genericName );
1233 }
1234
1235 // Get streamName for the current interval
1236 streamName = streamNameFunction()->getStreamName( this, group, name, false );
1237 // Register metadata information with the current interval streamname
1238 StatusCode smd = registerMetadata(streamName, name, group);
1239 if (smd != StatusCode::SUCCESS) allIsOk = false;
1240
1241 // Re-register the original graph with the current interval streamName
1242 StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
1243 if (sc3 == StatusCode::FAILURE) allIsOk = false;
1244
1245 }
1246
1247 if (!allIsOk) return StatusCode::FAILURE;
1248
1249 return StatusCode::SUCCESS;
1250}
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:5

◆ regTree() [1/2]

StatusCode ManagedMonitorToolBase::regTree ( TTree * t,
const MonGroup & group )
virtualinherited

Registers a TTree to be included in the output stream using logical parameters that describe it.

Definition at line 1554 of file ManagedMonitorToolBase.cxx.

1556{
1557
1558 // This part of the code deals with MANAGED type
1559 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1560 // Create an unmanaged group based on the original MonGroup instance passed
1561 // This is needed because managed tree is presented as a number of unmanaged
1562 // trees (one per each interval)
1563 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1564
1565 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1566 m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
1567 } else {
1568 ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1569 return StatusCode::FAILURE;
1570 }
1571
1572 std::string name = t->GetName();
1573 std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
1574 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1575 registerMetadata(streamName, name, group).ignore();
1576 return m_THistSvc->regTree( streamName, t );
1577 }
1578
1579
1580 // This part of the code deals with UNMANAGED type
1581 std::string tName = t->GetName();
1582
1583 if( m_manager != 0 ) {
1584 std::string genericName = NoOutputStream().getStreamName( this, group, tName );
1585 m_manager->writeAndDelete( genericName );
1586 m_manager->passOwnership( t, genericName );
1587 }
1588
1589 std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
1590
1591 StatusCode smd = registerMetadata(streamName, tName, group);
1592 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1593
1594 return m_THistSvc->regTree( streamName, t );
1595}

◆ regTree() [2/2]

StatusCode ManagedMonitorToolBase::regTree ( TTree * t,
const std::string & system,
Interval_t interval,
MgmtAttr_t histo_mgmt = ATTRIB_MANAGED,
const std::string & chain = "",
const std::string & merge = "" )
virtualinherited

Registers a TTree to be included in the output stream using logical parameters that describe it.

Definition at line 1544 of file ManagedMonitorToolBase.cxx.

1547{
1548 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1549 return regTree( t, group );
1550}

◆ 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< AlgTool > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ renounceArray()

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

◆ retrieveContainer()

template<class ContType>
StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::retrieveContainer ( const EventContext & ctx,
const SG::ReadHandleKey< ContType > & key,
const ContType *& container ) const
private

Definition at line 46 of file MuonPhysValMonitoringTool.cxx.

48 {
49 container = nullptr;
50 if (key.empty()) {
51 ATH_MSG_DEBUG("No key of type "<<typeid(ContType).name()<<" has been parsed");
52 return StatusCode::SUCCESS;
53 }
54 SG::ReadHandle readHandle{key,ctx};
55 if (!readHandle.isPresent()) {
56 ATH_MSG_ERROR("Failed to retrieve "<<key.fullKey()<<". Please check.");
57 return StatusCode::FAILURE;
58 }
59 container = readHandle.cptr();
60 return StatusCode::SUCCESS;
61 }
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
SG::VarHandleBase::isPresent
bool isPresent() const
Is the referenced object present in SG?
Definition StoreGate/src/VarHandleBase.cxx:400

◆ runStat()

StatusCode ManagedMonitorToolBase::runStat ( )
virtualinherited

This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ).

Implements IMonitorToolBase.

Definition at line 1661 of file ManagedMonitorToolBase.cxx.

1663{
1664 return StatusCode::SUCCESS;
1665}

◆ setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager * manager)
virtualinherited

Takes a pointer to a managing object to get information from it when needed.

Definition at line 1325 of file ManagedMonitorToolBase.cxx.

1327{
1328 ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
1329 m_manager = manager;
1330 if( m_manager != 0 ) {
1331 ATH_MSG_DEBUG( " --> Setting manager");
1332 m_managerNameProp = m_manager->name();
1333 m_fileKey = m_manager->fileKey();
1334 m_dataType = m_manager->dataType();
1335 m_environment = m_manager->environment();
1336 delete m_streamNameFcn;
1337 m_streamNameFcn = getNewStreamNameFcn();
1338 }
1339 ATH_MSG_DEBUG( " --> Exiting successfully");
1340}
ManagedMonitorToolBase::getNewStreamNameFcn
virtual StreamNameFcn * getNewStreamNameFcn() const
Definition ManagedMonitorToolBase.cxx:2156

◆ setupOutputStreams()

StatusCode ManagedMonitorToolBase::setupOutputStreams ( std::vector< std::string > Mapping = std::vector<std::string>())
virtualinherited

This implementation does nothing—streams in this class should be managed by the AthenaMonManager.

Consider using MonitorToolBase for user-managed streams.

Implements IMonitorToolBase.

Definition at line 1650 of file ManagedMonitorToolBase.cxx.

1652{
1653 // All instances should write to the stream(s) defined by the
1654 // AthenaMonManager.
1655
1656 return StatusCode::SUCCESS;
1657}

◆ SplitString()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::SplitString ( TString x,
const TString & delim,
std::vector< TString > & v )
private

Definition at line 1681 of file MuonPhysValMonitoringTool.cxx.

1681 {
1682 v.clear();
1683 int stringLength = x.Length();
1684 int delimLength = delim.Length();
1685
1686 int stop = 1;
1687 TString temp = "---";
1688 while (stop != -1) {
1689 stop = x.First(delim);
1690
1691 if (stop != -1) {
1692 temp = x(0, stop);
1693 TSubString newString = x(stop + delimLength, stringLength);
1694 x = newString;
1695 stringLength = x.Length();
1696 } else {
1697 stringLength = x.Length();
1698 temp = x(0, stringLength);
1699 }
1700
1701 v.emplace_back(temp);
1702 }
1703 }

◆ streamNameFunction()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::streamNameFunction ( )
virtualinherited

Returns the function object that converts logical paramters into a physical stream name.

Definition at line 450 of file ManagedMonitorToolBase.cxx.

452{
453 if( m_streamNameFcn == 0 ) {
454 msg(MSG::ERROR) << "!! streamNameFunction() has not been initialized !!" << endmsg;
455 msg(MSG::ERROR) << " --> neither ManagedMonitorToolBase::initialize() nor" << endmsg;
456 msg(MSG::ERROR) << " --> ManagedMonitorToolBase::setMonManager() has been called." << endmsg;
457 msg(MSG::ERROR) << " --> Correct configuration cannot be guaranteed from this point." << endmsg;
458 m_streamNameFcn = getNewStreamNameFcn();
459 }
460 return m_streamNameFcn;
461}

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

◆ sysStart()

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

◆ THistSvc_deReg_fixTGraph()

StatusCode ManagedMonitorToolBase::THistSvc_deReg_fixTGraph ( TFile * file,
TGraph * theGraph,
std::string & directoryName )
protectedinherited

Fixes THistSvc->deReg(obj) when obj is TGraph instance.

Read more in source file about this bug.

Definition at line 1036 of file ManagedMonitorToolBase.cxx.

1038{
1039 // THistSvc employs TDirectory Append method when registering TGraph.
1040 // When deReg is used to de-register TGraph object, THistSvc only removes the object
1041 // from its internal management but forgets to delete from TDirectory.
1042 // The current method fixes this problem by removing the TGraph object manually
1043 // after THistSvc->deReg(TGraph* obj) is called.
1044
1045 // Saves and restores gFile and gDirectory
1046 GlobalDirectoryRestore restore;
1047
1048 // This check is true when TGraph object is removed successfully
1049 bool graphRemoved = false;
1050
1051 file->cd("/");
1052 TDirectory* dir = file->GetDirectory(directoryName.c_str());
1053 if (dir != 0) {
1054 dir->cd();
1055 TObject* obj = dir->Remove(theGraph);
1056 if (obj != 0)
1057 graphRemoved = true;
1058 }
1059
1060 if (!graphRemoved) {
1061 return StatusCode::FAILURE;
1062 }
1063
1064 return StatusCode::SUCCESS;
1065}

◆ trigChainsArePassed()

bool ManagedMonitorToolBase::trigChainsArePassed ( std::vector< std::string > & vTrigNames)
protectedvirtualinherited

Definition at line 2092 of file ManagedMonitorToolBase.cxx.

2094{
2095 ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
2096
2097 for(unsigned int i=0; i<vTrigNames.size(); i++) {
2098 if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
2099 ATH_MSG_DEBUG( " + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
2100 return true;
2101 }
2102 else {
2103 ATH_MSG_DEBUG( " - \"" << vTrigNames[i] << "\" did not pass");
2104 }
2105 }
2106
2107 return false;
2108}

◆ updateTriggersForGroups()

void ManagedMonitorToolBase::updateTriggersForGroups ( std::vector< std::string > & vTrigChainNames)
protectedinherited

Definition at line 2130 of file ManagedMonitorToolBase.cxx.

2131 {
2132 for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
2133 std::string& thisName = vTrigChainNames[i];
2134 if (thisName.compare(0, 9, "CATEGORY_") ==0) {
2135 ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
2136 std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
2137 std::ostringstream oss;
2138 oss << "(";
2139 for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
2140 if (itrig != 0) {
2141 oss << "|";
2142 }
2143 oss << triggers[itrig];
2144 }
2145 oss << ")";
2146 // replace with new value
2147 std::string newval = oss.str();
2148 ATH_MSG_DEBUG("Replaced with " << newval);
2149 vTrigChainNames[i] = std::move(newval);
2150 }
2151 }
2152}
ManagedMonitorToolBase::m_trigTranslator
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator
Definition ManagedMonitorToolBase.h:847

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

◆ writeAndDelete()

StatusCode ManagedMonitorToolBase::writeAndDelete ( TH1 * h,
const MonGroup & group )
virtualinherited

Write out histogram and delete it.

Definition at line 1599 of file ManagedMonitorToolBase.cxx.

1600 {
1601 if (!h)
1602 return StatusCode::FAILURE;
1603
1604 std::string hName = h->GetName();
1605
1606 if( m_manager != 0 ) {
1607 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1608 m_manager->writeAndDelete( genericName );
1609 }
1610 return StatusCode::SUCCESS;
1611}

Member Data Documentation

◆ m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial
privateinherited

Definition at line 893 of file ManagedMonitorToolBase.h.

◆ m_counterBits

std::map<std::string, int> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_counterBits
private

Definition at line 107 of file MuonPhysValMonitoringTool.h.

◆ m_d

Imp* ManagedMonitorToolBase::m_d
privateinherited

Definition at line 900 of file ManagedMonitorToolBase.h.

◆ m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType
protectedinherited

Definition at line 838 of file ManagedMonitorToolBase.h.

◆ m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr
protectedinherited

Definition at line 834 of file ManagedMonitorToolBase.h.

◆ m_decorDep

SG::ReadDecorHandleKeyArray<xAOD::IParticleContainer> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_decorDep {this, "DecorDependencies", {}}
private

Definition at line 141 of file MuonPhysValMonitoringTool.h.

141{this, "DecorDependencies", {}};

◆ m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration
privateinherited

Definition at line 895 of file ManagedMonitorToolBase.h.

◆ m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel
protectedinherited

Definition at line 836 of file ManagedMonitorToolBase.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doBinnedResolutionPlots

Gaudi::Property<bool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doBinnedResolutionPlots {this, "DoBinnedResolutionPlots", true}
private

Definition at line 158 of file MuonPhysValMonitoringTool.h.

158{this, "DoBinnedResolutionPlots", true};

◆ m_doTrigMuonEFValidation

Gaudi::Property<bool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonEFValidation {this, "DoTrigMuonEFValidation", false}
private

Definition at line 162 of file MuonPhysValMonitoringTool.h.

162{this, "DoTrigMuonEFValidation", false};

◆ m_doTrigMuonL1Validation

Gaudi::Property<bool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonL1Validation {this, "DoTrigMuonL1Validation", false}
private

Definition at line 160 of file MuonPhysValMonitoringTool.h.

160{this, "DoTrigMuonL1Validation", false};

◆ m_doTrigMuonL2Validation

Gaudi::Property<bool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonL2Validation {this, "DoTrigMuonL2Validation", false}
private

Definition at line 161 of file MuonPhysValMonitoringTool.h.

161{this, "DoTrigMuonL2Validation", false};

◆ m_doTrigMuonValidation

Gaudi::Property<bool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonValidation {this, "DoTrigMuonValidation", false}
private

Definition at line 159 of file MuonPhysValMonitoringTool.h.

159{this, "DoTrigMuonValidation", false};

◆ m_DQFilterTools

ToolHandleArray<IDQFilterTool> ManagedMonitorToolBase::m_DQFilterTools {this,"FilterTools",{}}
protectedinherited

Definition at line 849 of file ManagedMonitorToolBase.h.

849{this,"FilterTools",{}};

◆ m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment
protectedinherited

Definition at line 839 of file ManagedMonitorToolBase.h.

◆ m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr
protectedinherited

Definition at line 835 of file ManagedMonitorToolBase.h.

◆ m_eventInfo

SG::ReadHandleKey<xAOD::EventInfo> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_eventInfo {this, "EventInfo", "EventInfo", "event info"}
private

Definition at line 165 of file MuonPhysValMonitoringTool.h.

165{this, "EventInfo", "EventInfo", "event info"};

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fileKey

std::string ManagedMonitorToolBase::m_fileKey
protectedinherited

Definition at line 833 of file ManagedMonitorToolBase.h.

◆ m_fwdtracksName

TrackContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_fwdtracksName {this, "FwdTrackContainerName", ""}
private

Definition at line 125 of file MuonPhysValMonitoringTool.h.

125{this, "FwdTrackContainerName", ""};

◆ m_h_overview_nObjects

std::vector<TH1F*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_nObjects
private

Definition at line 199 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_authors

std::vector<TH1F*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_reco_authors
private

Definition at line 201 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_category

TH1F* MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_reco_category {nullptr}
private

Definition at line 200 of file MuonPhysValMonitoringTool.h.

200{nullptr};

◆ m_h_overview_Z_mass

TH1F* MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass {nullptr}
private

Definition at line 203 of file MuonPhysValMonitoringTool.h.

203{nullptr};

◆ m_h_overview_Z_mass_ID

TH1F* MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass_ID {nullptr}
private

Definition at line 205 of file MuonPhysValMonitoringTool.h.

205{nullptr};

◆ m_h_overview_Z_mass_ME

TH1F* MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass_ME {nullptr}
private

Definition at line 204 of file MuonPhysValMonitoringTool.h.

204{nullptr};

◆ m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock
protectedinherited

Definition at line 866 of file ManagedMonitorToolBase.h.

◆ m_isData

Gaudi::Property<bool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_isData {this, "IsData", false}
private

Definition at line 163 of file MuonPhysValMonitoringTool.h.

163{this, "IsData", false};

◆ m_isoTool

ToolHandle<CP::IIsolationSelectionTool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_isoTool {this, "IsoTool", ""}
private

Definition at line 172 of file MuonPhysValMonitoringTool.h.

172{this, "IsoTool", ""};

◆ m_L1MuonItems

Gaudi::Property<std::vector<std::string> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_L1MuonItems {this, "SelectL1MuonItems", {}}
private

Definition at line 152 of file MuonPhysValMonitoringTool.h.

152{this, "SelectL1MuonItems", {}};

◆ m_L1Seed

std::vector<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_L1Seed
private

Definition at line 109 of file MuonPhysValMonitoringTool.h.

◆ m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock
protectedinherited

Definition at line 859 of file ManagedMonitorToolBase.h.

◆ m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun
protectedinherited

Definition at line 860 of file ManagedMonitorToolBase.h.

◆ m_lbDurationDataKey

SG::ReadCondHandleKey<LBDurationCondData> ManagedMonitorToolBase::m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
privateinherited

Definition at line 888 of file ManagedMonitorToolBase.h.

889{this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"};

◆ m_lumiDataKey

SG::ReadCondHandleKey<LuminosityCondData> ManagedMonitorToolBase::m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
privateinherited

Definition at line 886 of file ManagedMonitorToolBase.h.

887{this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"};

◆ m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager
protectedinherited

Definition at line 829 of file ManagedMonitorToolBase.h.

◆ m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp
protectedinherited

Definition at line 831 of file ManagedMonitorToolBase.h.

◆ m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap
protectedinherited

Definition at line 827 of file ManagedMonitorToolBase.h.

◆ m_MSTracks

const xAOD::TrackParticleContainer* MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_MSTracks {nullptr}
private

Definition at line 106 of file MuonPhysValMonitoringTool.h.

106{nullptr};

◆ m_muonEFCombTrigName

MuonContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonEFCombTrigName {this, "EFCombTrigMuonContainerName", "HLT_xAOD__MuonContainer_MuonEFInfo"}
private

Definition at line 139 of file MuonPhysValMonitoringTool.h.

139{this, "EFCombTrigMuonContainerName", "HLT_xAOD__MuonContainer_MuonEFInfo"};

◆ m_muonExtrapolatedTracksName

TrackContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonExtrapolatedTracksName {this, "MuonExtrapolatedTrackContainerName", "ExtrapolatedMuonTrackParticles"}
private

Definition at line 130 of file MuonPhysValMonitoringTool.h.

130{this, "MuonExtrapolatedTrackContainerName", "ExtrapolatedMuonTrackParticles"};

◆ m_muonIDForwardTrackValidationPlots

std::vector<std::unique_ptr<MuonTrackValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDForwardTrackValidationPlots
private

Definition at line 189 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDSelectedTrackValidationPlots

std::vector<std::unique_ptr<MuonTrackValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDSelectedTrackValidationPlots
private

Definition at line 188 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDTrackValidationPlots

std::vector<std::unique_ptr<MuonTrackValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDTrackValidationPlots
private

Definition at line 187 of file MuonPhysValMonitoringTool.h.

◆ m_muonItems

std::vector<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonItems
private

Definition at line 108 of file MuonPhysValMonitoringTool.h.

◆ m_muonL1TrigName

MuonROIContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL1TrigName {this, "L1TrigMuonContainerName", "LVL1MuonRoIs"}
private

Definition at line 136 of file MuonPhysValMonitoringTool.h.

136{this, "L1TrigMuonContainerName", "LVL1MuonRoIs"};

◆ m_muonL2CBName

L2CBContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL2CBName {this, "L2CBMuonContainerName", "HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfo"}
private

Definition at line 138 of file MuonPhysValMonitoringTool.h.

138{this, "L2CBMuonContainerName", "HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfo"};

◆ m_muonL2SAName

L2SAContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL2SAName {this, "L2SAMuonContainerName", "HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo"}
private

Definition at line 137 of file MuonPhysValMonitoringTool.h.

137{this, "L2SAMuonContainerName", "HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo"};

◆ m_muonMETrackValidationPlots

std::vector<std::unique_ptr<MuonTrackValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMETrackValidationPlots
private

Definition at line 185 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSOnlyExtrapolatedTracksName

TrackContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyExtrapolatedTracksName
private
Initial value:
{this, "MuonOnlyExtrapolatedTrackContainerName",
"MSOnlyExtrapolatedMuonTrackParticles"}

Definition at line 131 of file MuonPhysValMonitoringTool.h.

131 {this, "MuonOnlyExtrapolatedTrackContainerName",
132 "MSOnlyExtrapolatedMuonTrackParticles"};

◆ m_muonMSOnlyMETrackValidationPlots

std::vector<std::unique_ptr<MuonTrackValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyMETrackValidationPlots
private

Definition at line 186 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSTrackValidationPlots

std::vector<std::unique_ptr<MuonTrackValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSTrackValidationPlots
private

Definition at line 184 of file MuonPhysValMonitoringTool.h.

◆ m_muonPrinter

ToolHandle<Rec::IMuonPrintingTool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonPrinter {this, "MuonPrinter", "Rec::MuonPrintingTool/MuonPrintingTool"}
private

Definition at line 169 of file MuonPhysValMonitoringTool.h.

169{this, "MuonPrinter", "Rec::MuonPrintingTool/MuonPrintingTool"};

◆ m_muonSegmentsName

SegmentContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentsName {this, "MuonSegmentContainerName", "MuonSegments"}
private

Definition at line 134 of file MuonPhysValMonitoringTool.h.

134{this, "MuonSegmentContainerName", "MuonSegments"};

◆ m_muonSegmentsTruthName

SegmentContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentsTruthName {this, "MuonTruthSegmentContainerName", "MuonTruthSegments"}
private

Definition at line 135 of file MuonPhysValMonitoringTool.h.

135{this, "MuonTruthSegmentContainerName", "MuonTruthSegments"};

◆ m_muonSegmentValidationPlots

std::vector<std::unique_ptr<MuonSegmentValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentValidationPlots
private

Definition at line 190 of file MuonPhysValMonitoringTool.h.

◆ m_muonSelectionTool

ToolHandle<CP::IMuonSelectionTool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSelectionTool {this, "MuonSelector", "CP::MuonSelectionTool/MuonSelectionTool"}
private

Definition at line 168 of file MuonPhysValMonitoringTool.h.

168{this, "MuonSelector", "CP::MuonSelectionTool/MuonSelectionTool"};

◆ m_muonsName

MuonContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonsName {this, "MuonContainerName", "Muons"}
private

Definition at line 126 of file MuonPhysValMonitoringTool.h.

126{this, "MuonContainerName", "Muons"};

◆ m_muonsTruthName

TruthPartKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonsTruthName {this, "MuonTruthParticleContainerName", "MuonTruthParticles"}
private

Definition at line 128 of file MuonPhysValMonitoringTool.h.

128{this, "MuonTruthParticleContainerName", "MuonTruthParticles"};

◆ m_muonTracksName

TrackContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonTracksName {this, "MuonTrackContainerName", "MuonSpectrometerTrackParticles"}
private

Definition at line 129 of file MuonPhysValMonitoringTool.h.

129{this, "MuonTrackContainerName", "MuonSpectrometerTrackParticles"};

◆ m_muonValidationPlots

std::vector<std::unique_ptr<MuonValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonValidationPlots
private

Definition at line 182 of file MuonPhysValMonitoringTool.h.

◆ m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents
protectedinherited

Definition at line 863 of file ManagedMonitorToolBase.h.

◆ m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger
protectedinherited

Definition at line 864 of file ManagedMonitorToolBase.h.

◆ m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock
privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

◆ m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newRun

bool ManagedMonitorToolBase::m_newRun
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks
protectedinherited

Definition at line 865 of file ManagedMonitorToolBase.h.

◆ m_oUnmatchedRecoMuonPlots

std::unique_ptr<Muon::RecoMuonPlotOrganizer> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonPlots
private

Definition at line 191 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonSegmentPlots

std::unique_ptr<Muon::MuonSegmentPlots> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonSegmentPlots
private

Definition at line 194 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonTrackPlots

std::unique_ptr<Muon::RecoMuonTrackPlotOrganizer> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonTrackPlots
private

Definition at line 193 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedTruthMuonPlots

std::unique_ptr<Muon::TruthMuonPlotOrganizer> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedTruthMuonPlots
private

Definition at line 192 of file MuonPhysValMonitoringTool.h.

◆ m_path

std::string ManagedMonitorToolBase::m_path
protectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

◆ m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp
protectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

◆ m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp
protectedinherited

Definition at line 851 of file ManagedMonitorToolBase.h.

◆ m_selectComissioning

Gaudi::Property<bool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectComissioning {this, "SelectComissioningMuons", false}
private

Flag to tell whether muons with the comissioning author will be selected or not.

Definition at line 150 of file MuonPhysValMonitoringTool.h.

150{this, "SelectComissioningMuons", false};

◆ m_SelectedAuthor

int MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_SelectedAuthor {0}
private

Definition at line 110 of file MuonPhysValMonitoringTool.h.

110{0};

◆ m_selectHLTMuonItems

Gaudi::Property<std::vector<std::vector<std::string> > > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectHLTMuonItems {this, "SelectHLTMuonItems", {}}
private

Definition at line 151 of file MuonPhysValMonitoringTool.h.

151{this, "SelectHLTMuonItems", {}};

◆ m_selectMuonAuthors

Gaudi::Property<std::vector<unsigned int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonAuthors
private
Initial value:
{
this,
"SelectMuonAuthors",
{xAOD::Muon::MuidCo, xAOD::Muon::MuTagIMO, xAOD::Muon::MuidSA, xAOD::Muon::MuGirl, xAOD::Muon::CaloTag, xAOD::Muon::CaloScore}}

Definition at line 145 of file MuonPhysValMonitoringTool.h.

145 {
146 this,
147 "SelectMuonAuthors",
148 {xAOD::Muon::MuidCo, xAOD::Muon::MuTagIMO, xAOD::Muon::MuidSA, xAOD::Muon::MuGirl, xAOD::Muon::CaloTag, xAOD::Muon::CaloScore}};

◆ m_selectMuonCategories

Gaudi::Property<std::vector<unsigned int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategories
private
Initial value:
{
this,
"SelectMuonCategories",
{MUCATEGORY::ALL, MUCATEGORY::PROMPT, MUCATEGORY::INFLIGHT, MUCATEGORY::NONISO, MUCATEGORY::REST}}

Definition at line 153 of file MuonPhysValMonitoringTool.h.

153 {
154 this,
155 "SelectMuonCategories",
156 {MUCATEGORY::ALL, MUCATEGORY::PROMPT, MUCATEGORY::INFLIGHT, MUCATEGORY::NONISO, MUCATEGORY::REST}};

◆ m_selectMuonCategoriesStr

std::vector<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategoriesStr
private

Definition at line 174 of file MuonPhysValMonitoringTool.h.

◆ m_selectMuonWPs

Gaudi::Property<std::vector<int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonWPs
private
Initial value:
{
this, "SelectMuonWorkingPoints", {xAOD::Muon::Loose, xAOD::Muon::Medium, xAOD::Muon::Tight}}

Definition at line 143 of file MuonPhysValMonitoringTool.h.

143 {
144 this, "SelectMuonWorkingPoints", {xAOD::Muon::Loose, xAOD::Muon::Medium, xAOD::Muon::Tight}};

◆ m_slowMuonsName

SlowContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonsName {this, "SlowMuonContainerName", "SlowMuons"}
private

Definition at line 127 of file MuonPhysValMonitoringTool.h.

127{this, "SlowMuonContainerName", "SlowMuons"};

◆ m_slowMuonValidationPlots

std::vector<std::unique_ptr<SlowMuonValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonValidationPlots
private

Definition at line 196 of file MuonPhysValMonitoringTool.h.

◆ m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn
protectedinherited

Definition at line 841 of file ManagedMonitorToolBase.h.

◆ m_supportedIntervalsForRebooking

std::set<Interval_t> ManagedMonitorToolBase::m_supportedIntervalsForRebooking
privateinherited

Definition at line 896 of file ManagedMonitorToolBase.h.

◆ m_templateEfficiencies

std::map< Interval_t, std::vector< MgmtParams<TEfficiency> > > ManagedMonitorToolBase::m_templateEfficiencies
protectedinherited

Definition at line 676 of file ManagedMonitorToolBase.h.

◆ m_templateGraphs

std::map< Interval_t, std::vector< MgmtParams<TGraph> > > ManagedMonitorToolBase::m_templateGraphs
protectedinherited

Definition at line 668 of file ManagedMonitorToolBase.h.

◆ m_templateHistograms

std::map< Interval_t, std::vector< MgmtParams<TH1> > > ManagedMonitorToolBase::m_templateHistograms
protectedinherited

Definition at line 664 of file ManagedMonitorToolBase.h.

◆ m_templateTrees

std::map< Interval_t, std::vector< MgmtParams<TTree> > > ManagedMonitorToolBase::m_templateTrees
protectedinherited

Definition at line 672 of file ManagedMonitorToolBase.h.

◆ m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc
protectedinherited

Definition at line 843 of file ManagedMonitorToolBase.h.

◆ m_trackSelector

ToolHandle<Trk::ITrackSelectorTool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_trackSelector {this, "TrackSelector", "InDet::InDetDetailedTrackSelectorTool/MuonCombinedInDetDetailedTrackSelectorTool"}
private

Definition at line 171 of file MuonPhysValMonitoringTool.h.

171{this, "TrackSelector", "InDet::InDetDetailedTrackSelectorTool/MuonCombinedInDetDetailedTrackSelectorTool"};

◆ m_tracksName

TrackContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_tracksName {this, "TrackContainerName", "InDetTrackParticles"}
private

Definition at line 124 of file MuonPhysValMonitoringTool.h.

124{this, "TrackContainerName", "InDetTrackParticles"};

◆ m_trigDec

ToolHandle<Trig::TrigDecisionTool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_trigDec {this, "TrigDecTool", "Trig::TrigDecisionTool/TrigDecisionTool"}
private

Definition at line 170 of file MuonPhysValMonitoringTool.h.

170{this, "TrigDecTool", "Trig::TrigDecisionTool/TrigDecisionTool"};

◆ m_trigDecTool

PublicToolHandle<Trig::ITrigDecisionTool> ManagedMonitorToolBase::m_trigDecTool {this, "TrigDecisionTool",""}
protectedinherited

Definition at line 845 of file ManagedMonitorToolBase.h.

845{this, "TrigDecisionTool",""};

◆ m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp
protectedinherited

Definition at line 854 of file ManagedMonitorToolBase.h.

◆ m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp
protectedinherited

Definition at line 855 of file ManagedMonitorToolBase.h.

◆ m_TriggerMuonValidationPlots

std::vector<std::unique_ptr<TriggerMuonValidationPlots> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_TriggerMuonValidationPlots
private

Definition at line 183 of file MuonPhysValMonitoringTool.h.

◆ m_trigLiveFractionDataKey

SG::ReadCondHandleKey<TrigLiveFractionCondData> ManagedMonitorToolBase::m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
privateinherited

Definition at line 890 of file ManagedMonitorToolBase.h.

891{this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"};

◆ m_trigTranslator

PublicToolHandle<ITriggerTranslatorTool> ManagedMonitorToolBase::m_trigTranslator {this,"TriggerTranslatorTool",""}
protectedinherited

Definition at line 847 of file ManagedMonitorToolBase.h.

847{this,"TriggerTranslatorTool",""};

◆ m_useLumi

bool ManagedMonitorToolBase::m_useLumi
privateinherited

Definition at line 894 of file ManagedMonitorToolBase.h.

◆ m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger
protectedinherited

Definition at line 857 of file ManagedMonitorToolBase.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vEFMuons

std::vector<const xAOD::Muon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vEFMuons
private

Definition at line 215 of file MuonPhysValMonitoringTool.h.

◆ m_vEFMuonsSelected

std::vector<const xAOD::Muon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vEFMuonsSelected
private

Definition at line 216 of file MuonPhysValMonitoringTool.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vL2CBMuons

std::vector<const xAOD::L2CombinedMuon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2CBMuons
private

Definition at line 219 of file MuonPhysValMonitoringTool.h.

◆ m_vL2CBMuonsSelected

std::vector<const xAOD::L2CombinedMuon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2CBMuonsSelected
private

Definition at line 220 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuons

std::vector<const xAOD::L2StandAloneMuon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2SAMuons
private

Definition at line 217 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuonsSelected

std::vector<const xAOD::L2StandAloneMuon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2SAMuonsSelected
private

Definition at line 218 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuons

std::vector<const xAOD::Muon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuons
private

Definition at line 208 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonSegments

std::vector<const xAOD::MuonSegment*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuonSegments
private

Definition at line 211 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonTracks

std::vector<const xAOD::TrackParticle*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuonTracks
private

Definition at line 210 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedSlowMuons

std::vector<const xAOD::SlowMuon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedSlowMuons
private

Definition at line 209 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedTruthMuons

std::vector<const xAOD::TruthParticle*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedTruthMuons
private

Definition at line 207 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons

std::vector<const xAOD::Muon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons
private

Definition at line 221 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen

std::vector<const xAOD::Muon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen
private

Definition at line 224 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_CB

std::vector<const xAOD::Muon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen_CB
private

Definition at line 222 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_MS

std::vector<const xAOD::Muon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen_MS
private

Definition at line 223 of file MuonPhysValMonitoringTool.h.

◆ m_vTrigChainNames

std::vector<std::string> ManagedMonitorToolBase::m_vTrigChainNames
protectedinherited

Definition at line 680 of file ManagedMonitorToolBase.h.

◆ m_vTrigGroupNames

std::vector<std::string> ManagedMonitorToolBase::m_vTrigGroupNames
protectedinherited

Definition at line 680 of file ManagedMonitorToolBase.h.

◆ m_vZmumuIDTracks

std::vector<const xAOD::TrackParticle*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuIDTracks
private

Definition at line 212 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMETracks

std::vector<const xAOD::TrackParticle*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuMETracks
private

Definition at line 213 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMuons

std::vector<const xAOD::Muon*> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuMuons
private

Definition at line 214 of file MuonPhysValMonitoringTool.h.

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