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 (const EventContext &ctx) 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 (const EventContext &ctx)
 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) const
 Average mu, i.e.
virtual float lbInteractionsPerCrossing (const EventContext &ctx) const
 Instantaneous number of interactions, i.e.
virtual float lbAverageLuminosity (const EventContext &ctx) const
 Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
virtual float lbLuminosityPerBCID (const EventContext &ctx) const
 Instantaneous luminosity.
virtual double lbDuration (const EventContext &ctx) const
 Luminosity block time (in seconds).
virtual float lbAverageLivefraction (const EventContext &ctx) const
 Average luminosity livefraction.
virtual float livefractionPerBCID (const EventContext &ctx) const
 Livefraction per bunch crossing ID.
virtual double lbLumiWeight (const EventContext &ctx) 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)
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 827 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 114 of file ManagedMonitorToolBase.h.

114 { file = 0, eventsBlock, lumiBlock,
115 lowStat, medStat, higStat,
116 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 131 of file ManagedMonitorToolBase.h.

131{ 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:1345
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonSegmentPlots
std::unique_ptr< Muon::MuonSegmentPlots > m_oUnmatchedRecoMuonSegmentPlots
Definition MuonPhysValMonitoringTool.h:193
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentValidationPlots
std::vector< std::unique_ptr< MuonSegmentValidationPlots > > m_muonSegmentValidationPlots
Definition MuonPhysValMonitoringTool.h:189
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedTruthMuonPlots
std::unique_ptr< Muon::TruthMuonPlotOrganizer > m_oUnmatchedTruthMuonPlots
Definition MuonPhysValMonitoringTool.h:191
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonValidationPlots
std::vector< std::unique_ptr< SlowMuonValidationPlots > > m_slowMuonValidationPlots
Definition MuonPhysValMonitoringTool.h:195
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonPlots
std::unique_ptr< Muon::RecoMuonPlotOrganizer > m_oUnmatchedRecoMuonPlots
Definition MuonPhysValMonitoringTool.h:190
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonTrackPlots
std::unique_ptr< Muon::RecoMuonTrackPlotOrganizer > m_oUnmatchedRecoMuonTrackPlots
Definition MuonPhysValMonitoringTool.h:192
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDForwardTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDForwardTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:188
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMETrackValidationPlots
Definition MuonPhysValMonitoringTool.h:184
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_TriggerMuonValidationPlots
std::vector< std::unique_ptr< TriggerMuonValidationPlots > > m_TriggerMuonValidationPlots
Definition MuonPhysValMonitoringTool.h:182
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:183
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:181
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:185
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:186
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDSelectedTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDSelectedTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:187
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 1285 of file ManagedMonitorToolBase.cxx.

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

◆ bookHists()

StatusCode ManagedMonitorToolBase::bookHists ( )
virtualinherited

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

Implements IMonitorToolBase.

Definition at line 730 of file ManagedMonitorToolBase.cxx.

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

◆ 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:1546
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.

Definition at line 1670 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1624 of file ManagedMonitorToolBase.cxx.

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

◆ deregHist()

StatusCode ManagedMonitorToolBase::deregHist ( TH1 * h)
virtualinherited

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

Definition at line 1616 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1642 of file ManagedMonitorToolBase.cxx.

1644{
1645 std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
1646 return m_THistSvc->deReg( streamName );
1647}
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:452

◆ 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 1632 of file ManagedMonitorToolBase.cxx.

1635{
1636 MonGroup group( this, system, interval );
1637 return deregObject( objName, group );
1638}
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition ManagedMonitorToolBase.h:138
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:1633
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 1223 of file MuonPhysValMonitoringTool.cxx.

1223 {
1224 int k_EFMu_MinDeltaR = -1;
1225 float MinDeltaR = 0.;
1226 std::vector<int> vAvailableAuthors;
1227 vAvailableAuthors.clear();
1228 vAvailableAuthors.emplace_back(m_vEFMuons[0]->author());
1229 unsigned int iter = 0;
1230 for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1231 iter = 0;
1232 for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1233 if (m_vEFMuons[k]->author() != vAvailableAuthors[l]) iter++;
1234 }
1235 if (iter == vAvailableAuthors.size()) vAvailableAuthors.emplace_back(m_vEFMuons[k]->author());
1236 }
1237 ATH_MSG_DEBUG(" m_vEFMuons.size()" << m_vEFMuons.size());
1238 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1239 ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1240 << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1241 }
1242 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1243 if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1244 ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1245 << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1246 for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1247 k_EFMu_MinDeltaR = -1;
1248 MinDeltaR = 1000;
1249 for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1250 ATH_MSG_DEBUG(" :::::::: TEST: EF pt=" << m_vEFMuons.at(k)->pt() << " eta=" << m_vEFMuons.at(k)->eta()
1251 << " phi=" << m_vEFMuons.at(k)->phi()
1252 << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k))
1253 << " author=" << m_vEFMuons.at(k)->author());
1254 if (m_vEFMuons.at(k)->author() == vAvailableAuthors.at(l) &&
1255 (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < 0.1 &&
1256 (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < MinDeltaR))) {
1257 k_EFMu_MinDeltaR = k;
1258 MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k));
1259 }
1260 }
1261 if (k_EFMu_MinDeltaR == -1) continue;
1262 for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1263 if (m_selectMuonCategories[c] == ALL) {
1264 m_TriggerMuonValidationPlots[c]->fill(*m_vEFMuons.at(k_EFMu_MinDeltaR), *m_vRecoMuons.at(i));
1265 }
1266 }
1267 }
1268 }
1269 }
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 795 of file ManagedMonitorToolBase.h.

795{ return m_endOfEventsBlock; }

◆ endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 796 of file ManagedMonitorToolBase.h.

796{ return m_endOfLowStat; }

◆ endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 797 of file ManagedMonitorToolBase.h.

797{ return m_endOfLumiBlock; }

◆ endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const
inlineprotectedinherited

Definition at line 798 of file ManagedMonitorToolBase.h.

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

Definition at line 740 of file ManagedMonitorToolBase.cxx.

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

Definition at line 1255 of file ManagedMonitorToolBase.cxx.

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

1356 {
1357 TH1F* h = nullptr;
1358 for (const auto& hist : hists) {
1359 if (hist.second.find(hdirTag) != std::string::npos || hdirTag.empty()) {
1360 std::string histname = hist.first->GetName();
1361 if (histname.find(hnameTag) != std::string::npos) {
1362 h = (TH1F*)hist.first->Clone(hNewName.c_str());
1363 return h;
1364 }
1365 }
1366 }
1367 return h;
1368 }

◆ findRecoMuon()

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

Definition at line 1281 of file MuonPhysValMonitoringTool.cxx.

1281 {
1282 static const SG::ConstAccessor<MuonLink> acc_muon("recoMuonLink");
1283 if (!acc_muon.isAvailable(*truthMu)) return nullptr;
1284 MuonLink link = acc_muon(*truthMu);
1285 if (!link.isValid()) return nullptr;
1286 const xAOD::Muon* reco_mu = (*link);
1287 if (!m_selectComissioning && reco_mu->allAuthors() & comm_bit) return nullptr;
1288 m_vMatchedMuons.emplace_back(reco_mu);
1289 return reco_mu;
1290 }
SG::ConstAccessor
SG::ConstAccessor< T, ALLOC > ConstAccessor
Definition AuxElement.h:570

◆ findRecoMuonSegment()

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

Definition at line 1340 of file MuonPhysValMonitoringTool.cxx.

1340 {
1341 static const SG::ConstAccessor<MuonSegmentLink> recoSegmentLinkAcc("recoSegmentLink");
1342 if (!recoSegmentLinkAcc.isAvailable(*truthMuSeg)) {
1343 ATH_MSG_DEBUG("recoSegmentLink not found");
1344 return nullptr;
1345 }
1346 MuonSegmentLink link = recoSegmentLinkAcc(*truthMuSeg);
1347 if (!link.isValid()) {
1348 ATH_MSG_DEBUG("recoSegmentLink not valid");
1349 return nullptr;
1350 }
1351 m_vMatchedMuonSegments.emplace_back(*link);
1352 return (*link);
1353 }

◆ findRecoSlowMuon()

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

Definition at line 1292 of file MuonPhysValMonitoringTool.cxx.

1292 {
1293 const xAOD::SlowMuonContainer* SlowMuons = nullptr;
1294 retrieveContainer(Gaudi::Hive::currentContext() , m_slowMuonsName, SlowMuons).ignore();
1295 if (!SlowMuons) return nullptr;
1296 for (const auto smu : *SlowMuons) {
1297 const MuonLink muLink = smu->muonLink();
1298 if (!muLink.isValid()) continue;
1299 float DR = deltaR(*muLink , truthMu);
1300 if (DR < 0.005) {
1301 m_vMatchedSlowMuons.emplace_back(smu);
1302 return smu;
1303 }
1304 }
1305
1306 return nullptr;
1307 }

◆ get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const
inlineprotectedinherited

Definition at line 693 of file ManagedMonitorToolBase.h.

693 {
694 return m_nEvents;
695 }

◆ get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const
inlineprotectedinherited

Definition at line 697 of file ManagedMonitorToolBase.h.

697 {
698 return m_procNEventsProp;
699 }

◆ getCorrectedMuon()

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

Definition at line 1403 of file MuonPhysValMonitoringTool.cxx.

1403 {
1404 std::unique_ptr<xAOD::Muon> mu_c;
1405 if (mu.m() <= 0) return mu_c;
1406 mu_c = std::make_unique<xAOD::Muon>();
1407 mu_c->makePrivateStore(mu);
1408
1409 // add decorations too fool the muon selector tool
1410 const xAOD::TrackParticle* idtrk{mu_c->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)};
1411 const xAOD::TrackParticle* metrk{mu_c->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)};
1412 if (idtrk && metrk) {
1413 const static SG::Decorator<float> InnerDetectorPtDec("InnerDetectorPt");
1414 const static SG::Decorator<float> MuonSpectrometerPtDec("MuonSpectrometerPt");
1415 InnerDetectorPtDec(*mu_c) = idtrk->pt();
1416 MuonSpectrometerPtDec(*mu_c) = metrk->pt();
1417 }
1418 m_muonSelectionTool->setQuality(*mu_c);
1419 m_muonSelectionTool->setPassesIDCuts(*mu_c);
1420 return mu_c;
1421 }
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
SG::Decorator
SG::Decorator< T, ALLOC > Decorator
Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
Definition AuxElement.h:576

◆ 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 1418 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1408 of file ManagedMonitorToolBase.cxx.

1411{
1412 MonGroup group( this, system, interval );
1413 return getHist( h, hName, group );
1414}
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:1409

◆ 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 1437 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1427 of file ManagedMonitorToolBase.cxx.

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

◆ getMuonSegmentTruthCategory()

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

Definition at line 1370 of file MuonPhysValMonitoringTool.cxx.

1371 {
1372 static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1373 TruthLink truthLink;
1374 if (truthParticleLinkAcc.isAvailable(*truthMuSeg)) {
1375 truthLink = truthParticleLinkAcc(*truthMuSeg);
1376 if (truthLink.isValid()) {
1377 const int theUniqueID = HepMC::uniqueID(*truthLink);
1378 if (std::abs((*truthLink)->pdgId()) != 13) return REST;
1379
1380 for (const auto muTruthPart : *muonTruthContainer) {
1381 if ( HepMC::uniqueID(muTruthPart) == theUniqueID ) { return getMuonTruthCategory(muTruthPart); }
1382 }
1383 }
1384 } else
1385 ATH_MSG_WARNING("No truth link available for muon truth segment");
1386
1387 return REST;
1388 }
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:1390
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 1390 of file MuonPhysValMonitoringTool.cxx.

1390 {
1391 static const SG::ConstAccessor<int> truthTypeAcc("truthType");
1392 static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
1393 int truthType = truthTypeAcc(*mu);
1394 if (truthType == 6)
1395 return PROMPT;
1396 else if (truthType == 8 && (truthOriginAcc(*mu) == 34 || truthOriginAcc(*mu) == 35))
1397 return INFLIGHT;
1398 else if (truthType == 7)
1399 return NONISO;
1400 return REST;
1401 }
IDTPM::truthType
int truthType(const U &p)
Definition TrackParametersHelper.h:274

◆ getNewStreamNameFcn()

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

Definition at line 2156 of file ManagedMonitorToolBase.cxx.

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

◆ handleMuon()

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

Definition at line 889 of file MuonPhysValMonitoringTool.cxx.

889 {
890 if (!mu) return;
891 if (!m_selectComissioning && mu->allAuthors() & comm_bit) return;
892
893 if (msgLvl(MSG::DEBUG)) printMuonDebug(mu);
894
895 // make deep copy of muon and decorate with quality
896 std::unique_ptr<xAOD::Muon> mu_c;
897 try {
898 mu_c = getCorrectedMuon(*mu);
899 } catch (const SG::ExcBadAuxVar&) {
900 ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
901 return;
902 }
903
904 if (m_isData) {
905 MUCATEGORY thisMuonCategory = ALL;
906 // for events with a Zmumu candidate, separate Z muons from the rest:
907 if (m_vZmumuMuons.size() > 0) {
908 thisMuonCategory = REST;
909 if (std::find(m_vZmumuMuons.begin(), m_vZmumuMuons.end(), mu) != m_vZmumuMuons.end()) { thisMuonCategory = PROMPT; }
910 }
911 // fill plots
912 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
913 if (m_selectMuonCategories[i] == ALL or m_selectMuonCategories[i] == thisMuonCategory) {
914 if (mu_c){
915 // histos
916 m_muonValidationPlots[i]->fill(*mu_c, weight);
917 if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
918 // tree branches
919 m_muonValidationPlots[i]->fillTreeBranches(*mu_c);
920 }
921 }
922 }
923 }
924
926 // SELECT MUON MEDIUM QUALITY FOR TRIGGER VALIDATION
927 xAOD::Muon::Quality my_quality = m_muonSelectionTool->getQuality(*mu_c);
928 if (my_quality <= xAOD::Muon::Medium && m_isoTool->accept(*mu_c)) m_vRecoMuons.emplace_back(mu);
930
931 if (smu) {
932 if (std::find(std::begin(m_vMatchedSlowMuons), std::end(m_vMatchedSlowMuons), smu) != std::end(m_vMatchedSlowMuons)) { return; }
933 } else {
934 if (std::find(std::begin(m_vMatchedMuons), std::end(m_vMatchedMuons), mu) != std::end(m_vMatchedMuons)) { return; }
935 }
936
937 // unmatched reco muons (not matched with any kind of truth particle, fakes)
938 if (!m_isData) m_oUnmatchedRecoMuonPlots->fill(*mu_c, weight);
939
940 m_h_overview_reco_category->Fill("Other", weight);
941 m_h_overview_reco_authors[3]->Fill(mu->author(), weight);
942
943 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
944 if (m_selectMuonCategories[i] == ALL) {
945 if (mu_c){// histos
946 m_muonValidationPlots[i]->fill(*mu_c);
947 if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
948 // tree branches
949 m_muonValidationPlots[i]->fillTreeBranches(*mu_c);
950 break;
951 }
952 }
953 }
954 }
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:1403
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 1107 of file MuonPhysValMonitoringTool.cxx.

1107 {
1108 ATH_MSG_DEBUG("MuonRoI L1 Trigger: ptThr " << TrigL1mu->thrValue() << " phi " << TrigL1mu->phi() << " eta " << TrigL1mu->eta());
1109 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1110 if (m_selectMuonCategories[i] == ALL) {
1111 m_TriggerMuonValidationPlots[i]->fill(*TrigL1mu);
1112 break;
1113 }
1114 }
1115 }
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 1165 of file MuonPhysValMonitoringTool.cxx.

1165 {
1166 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1167 if (m_selectMuonCategories[i] == ALL) {
1168 m_TriggerMuonValidationPlots[i]->fill(*L2CBMu);
1169 break;
1170 }
1171 }
1172 ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2CB Trigger : pt " << L2CBMu->pt() << " phi " << L2CBMu->phi() << " eta "
1173 << L2CBMu->eta());
1174 }
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 1117 of file MuonPhysValMonitoringTool.cxx.

1117 {
1118 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1119 if (m_selectMuonCategories[i] == ALL) {
1120 m_TriggerMuonValidationPlots[i]->fill(*L2SAMu);
1121 break;
1122 }
1123 }
1124 ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2SA Trigger : pt " << L2SAMu->pt() << " phi " << L2SAMu->phi() << " eta "
1125 << L2SAMu->eta() << " roiWord " << L2SAMu->roiWord()
1126 << " sAddress " << L2SAMu->sAddress());
1127 }
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 873 of file MuonPhysValMonitoringTool.cxx.

873 {
874 if (!muSeg) {
875 ATH_MSG_WARNING("No muon segment found");
876 return;
877 }
878 if (std::find(std::begin(m_vMatchedMuonSegments), std::end(m_vMatchedMuonSegments), muSeg) != std::end(m_vMatchedMuonSegments))
879 return;
880 if (!m_isData) m_oUnmatchedRecoMuonSegmentPlots->fill(*muSeg, weight);
881 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
882 if (m_selectMuonCategories[i] == ALL) {
883 m_muonSegmentValidationPlots[i]->fill(muSeg, weight);
884 break;
885 }
886 }
887 }

◆ handleMuonTrack()

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

Definition at line 1006 of file MuonPhysValMonitoringTool.cxx.

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

◆ handleMuonTrigger()

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

Definition at line 1212 of file MuonPhysValMonitoringTool.cxx.

1212 {
1213 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1214 if (m_selectMuonCategories[i] == ALL) {
1215 m_TriggerMuonValidationPlots[i]->fill(*EFMu);
1216 break;
1217 }
1218 }
1219 ATH_MSG_DEBUG("==> Geometrical selection of EF Trigger muons: pt " << EFMu->pt() << " phi " << EFMu->phi() << " eta " << EFMu->eta()
1220 << " author " << EFMu->author());
1221 }

◆ 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 956 of file MuonPhysValMonitoringTool.cxx.

956 {
957 const xAOD::SlowMuon* smu = nullptr;
958 const xAOD::Muon* mu = nullptr;
959 if (!m_slowMuonsName.empty()) {
960 smu = findRecoSlowMuon(truthMu);
961 if (smu) {
962 const MuonLink muLink = smu->muonLink();
963 if (muLink.isValid()) mu = *muLink;
964
965 if (!mu) {
966 ATH_MSG_WARNING("Found SlowMuon without valid muon link");
967 smu = nullptr;
968 }
969 }
970 } else {
971 mu = findRecoMuon(truthMu);
972 }
973
974 if (msgLvl(MSG::DEBUG)) printTruthMuonDebug(truthMu, mu);
975 if (!passesAcceptanceCuts(truthMu)) return;
976
977 std::unique_ptr<xAOD::Muon> mu_c;
978 if (mu) {
979 try {
980 mu_c = getCorrectedMuon(*mu);
981 } catch (const SG::ExcBadAuxVar&) {
982 ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
983 return;
984 }
985 }
986
987 unsigned int thisMuonCategory = getMuonTruthCategory(truthMu);
988 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
989 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
990 // histos
991 m_muonValidationPlots[i]->fill(
992 truthMu, mu_c.get(), m_MSTracks,
993 weight); // if no muon is found a protection inside MuonValidationPlots will ensure, its plots won't be filled
994 if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots[i]->fill(truthMu, smu, mu_c.get(), weight);
995 // tree branches
996 m_muonValidationPlots[i]->fillTreeBranches(truthMu, mu_c.get(), m_MSTracks);
997 }
998 }
999 if (mu_c) {
1000 m_h_overview_reco_category->Fill(thisMuonCategory - 1, weight);
1001 m_h_overview_reco_authors[thisMuonCategory - 1]->Fill(mu_c->author(), weight);
1002 } else if (!m_isData)
1003 m_oUnmatchedTruthMuonPlots->fill(*truthMu, weight);
1004 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoSlowMuon
const xAOD::SlowMuon * findRecoSlowMuon(const xAOD::TruthParticle *truthMu)
Definition MuonPhysValMonitoringTool.cxx:1292
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuon
const xAOD::Muon * findRecoMuon(const xAOD::TruthParticle *truthMu)
Definition MuonPhysValMonitoringTool.cxx:1281
MuonPhysValMonitoring::MuonPhysValMonitoringTool::printTruthMuonDebug
void printTruthMuonDebug(const xAOD::TruthParticle *truthMu, const xAOD::Muon *mu)
Definition MuonPhysValMonitoringTool.cxx:1309
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 857 of file MuonPhysValMonitoringTool.cxx.

858 {
859 const xAOD::MuonSegment* muSeg = findRecoMuonSegment(truthMuSeg);
861
862 unsigned int thisMuonCategory = ALL; // getMuonSegmentTruthCategory(truthMuSeg, muonTruthContainer) @@@ Does not work...
863
864 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
865 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
866 m_muonSegmentValidationPlots[i]->fill(truthMuSeg, muSeg,
867 weight); // if no reco muon segment is found a protection inside
868 // MuonSegmentValidationPlots will ensure, its plots won't be filled
869 }
870 }
871 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuonSegment
const xAOD::MuonSegment * findRecoMuonSegment(const xAOD::MuonSegment *truthMuSeg)
Definition MuonPhysValMonitoringTool.cxx:1340
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 30 of file IMonitorToolBase.h.

30{ 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 536 of file ManagedMonitorToolBase.cxx.

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

◆ intervalStringToEnum()

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

Converts a string to the corresponding Interval_t.

Definition at line 578 of file ManagedMonitorToolBase.cxx.

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

◆ L2CBTriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2CBTriggerResolution ( )
private

Definition at line 1176 of file MuonPhysValMonitoringTool.cxx.

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

◆ L2SATriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2SATriggerResolution ( )
private

Definition at line 1129 of file MuonPhysValMonitoringTool.cxx.

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

◆ lbAverageInteractionsPerCrossing()

float ManagedMonitorToolBase::lbAverageInteractionsPerCrossing ( const EventContext & ctx) const
virtualinherited

Average mu, i.e.

<mu>

Definition at line 1692 of file ManagedMonitorToolBase.cxx.

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

◆ lbAverageLivefraction()

float ManagedMonitorToolBase::lbAverageLivefraction ( const EventContext & ctx) const
virtualinherited

Average luminosity livefraction.

Definition at line 1761 of file ManagedMonitorToolBase.cxx.

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

◆ lbAverageLuminosity()

float ManagedMonitorToolBase::lbAverageLuminosity ( const EventContext & ctx) const
virtualinherited

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

Definition at line 1728 of file ManagedMonitorToolBase.cxx.

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

◆ lbDuration()

double ManagedMonitorToolBase::lbDuration ( const EventContext & ctx) const
virtualinherited

Luminosity block time (in seconds).

Definition at line 1815 of file ManagedMonitorToolBase.cxx.

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

◆ lbInteractionsPerCrossing()

float ManagedMonitorToolBase::lbInteractionsPerCrossing ( const EventContext & ctx) const
virtualinherited

Instantaneous number of interactions, i.e.

mu

Definition at line 1708 of file ManagedMonitorToolBase.cxx.

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

◆ lbLuminosityPerBCID()

float ManagedMonitorToolBase::lbLuminosityPerBCID ( const EventContext & ctx) const
virtualinherited

Instantaneous luminosity.

Definition at line 1744 of file ManagedMonitorToolBase.cxx.

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

◆ lbLumiWeight()

double ManagedMonitorToolBase::lbLumiWeight ( const EventContext & ctx) const
virtualinherited

Average Integrated Luminosity Live Fraction.

Definition at line 1799 of file ManagedMonitorToolBase.cxx.

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

◆ livefractionPerBCID()

float ManagedMonitorToolBase::livefractionPerBCID ( const EventContext & ctx) const
virtualinherited

Livefraction per bunch crossing ID.

Definition at line 1780 of file ManagedMonitorToolBase.cxx.

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

◆ ManagedMonitorToolBase()

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

Constructor with parameters:

Definition at line 389 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1423 of file MuonPhysValMonitoringTool.cxx.

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

◆ 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 794 of file ManagedMonitorToolBase.h.

794{ return m_newEventsBlock; }

◆ newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 790 of file ManagedMonitorToolBase.h.

790{ return m_newHigStatInterval; }

◆ newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 791 of file ManagedMonitorToolBase.h.

791{ 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 788 of file ManagedMonitorToolBase.h.

788{ return m_newLowStatInterval; }

◆ newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 792 of file ManagedMonitorToolBase.h.

792{ return m_newLumiBlock; }

◆ newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 789 of file ManagedMonitorToolBase.h.

789{ return m_newMedStatInterval; }

◆ newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const
inlineprotectedinherited

Definition at line 793 of file ManagedMonitorToolBase.h.

793{ 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 2112 of file ManagedMonitorToolBase.cxx.

2113 {
2114 std::string item;
2115 std::stringstream ss(line);
2116
2117 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
2118
2119 while ( std::getline(ss, item, ',') ) {
2120 std::stringstream iss(item); // remove
2121 iss >> item; // whitespace
2122 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
2123 result.push_back(item);
2124 }
2125
2126 msg(MSG::DEBUG) << endmsg;
2127 return StatusCode::SUCCESS;
2128}
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 1666 of file MuonPhysValMonitoringTool.cxx.

1666 {
1667 if (prt->pt() < 2000.) return false;
1668 if (std::abs(prt->eta()) > 2.7) return false;
1669 return true;
1670 }
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 1680 of file ManagedMonitorToolBase.cxx.

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

◆ printMuonDebug()

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

Definition at line 1271 of file MuonPhysValMonitoringTool.cxx.

1271 {
1272 const xAOD::TrackParticle* tp = mu->primaryTrackParticle();
1273 static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1274 TruthLink truthLink;
1275 if (tp) {
1276 truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
1277 }
1278 ATH_MSG_DEBUG("Muon: pt " << mu->pt() << " eta " << mu->eta() << " link " << truthLink.isValid());
1279 }

◆ printTruthMuonDebug()

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

Definition at line 1309 of file MuonPhysValMonitoringTool.cxx.

1309 {
1310 ATH_MSG_DEBUG("Truth muon: " << truthMu->pt() << " eta " << truthMu->eta());
1311 if (!mu) return;
1312 ATH_MSG_DEBUG("Reco muon: " << mu->pt() << " eta " << mu->eta());
1313 }
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 1315 of file MuonPhysValMonitoringTool.cxx.

1315 {
1316 ATH_MSG_INFO("Finalising hists " << name() << "...");
1317 for (const auto& plots : m_muonValidationPlots) plots->finalize();
1318 for (const auto& plots : m_TriggerMuonValidationPlots) plots->finalize();
1319 if (!m_isData) {
1320 m_oUnmatchedRecoMuonPlots->finalize();
1321 m_oUnmatchedTruthMuonPlots->finalize();
1322 }
1323
1324 for (const auto& plots : m_muonMSTrackValidationPlots) plots->finalize();
1325 for (const auto& plots : m_muonMETrackValidationPlots) plots->finalize();
1326 for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) plots->finalize();
1327 for (const auto& plots : m_muonIDTrackValidationPlots) plots->finalize();
1328 for (const auto& plots : m_muonIDSelectedTrackValidationPlots) plots->finalize();
1329 for (const auto& plots : m_muonIDForwardTrackValidationPlots) plots->finalize();
1330 if (!m_isData)
1331 if (m_oUnmatchedRecoMuonTrackPlots) m_oUnmatchedRecoMuonTrackPlots->finalize();
1332
1333 for (const auto& plots : m_muonSegmentValidationPlots) plots->finalize();
1334 if (!m_isData)
1335 if (m_oUnmatchedRecoMuonSegmentPlots) m_oUnmatchedRecoMuonSegmentPlots->finalize();
1336
1337 return StatusCode::SUCCESS;
1338 }//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 1445 of file ManagedMonitorToolBase.cxx.

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

◆ 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.

Definition at line 1499 of file ManagedMonitorToolBase.cxx.

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

◆ 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.

Definition at line 1489 of file ManagedMonitorToolBase.cxx.

1492{
1493 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1494 return regGraph( g, group );
1495}
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:1490

◆ 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.

Definition at line 1353 of file ManagedMonitorToolBase.cxx.

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

◆ 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.

Definition at line 1344 of file ManagedMonitorToolBase.cxx.

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

◆ registerMetadata()

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

Definition at line 946 of file ManagedMonitorToolBase.cxx.

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

◆ regManagedEfficiencies()

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

Definition at line 1140 of file ManagedMonitorToolBase.cxx.

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

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

◆ regManagedHistograms()

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

Definition at line 972 of file ManagedMonitorToolBase.cxx.

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

◆ regManagedTrees()

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

Definition at line 1200 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1555 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1545 of file ManagedMonitorToolBase.cxx.

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

◆ 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
SG::container
const SG::AuxVectorData * container() const
Return the container holding this element.

◆ runStat()

StatusCode ManagedMonitorToolBase::runStat ( )
virtualinherited

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

Implements IMonitorToolBase.

Definition at line 1662 of file ManagedMonitorToolBase.cxx.

1664{
1665 return StatusCode::SUCCESS;
1666}

◆ setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager * manager)
virtualinherited

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

Definition at line 1326 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1651 of file ManagedMonitorToolBase.cxx.

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

◆ streamNameFunction()

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

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

Definition at line 451 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1037 of file ManagedMonitorToolBase.cxx.

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

◆ trigChainsArePassed()

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

Definition at line 2093 of file ManagedMonitorToolBase.cxx.

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

◆ updateTriggersForGroups()

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

Definition at line 2131 of file ManagedMonitorToolBase.cxx.

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

◆ 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 1600 of file ManagedMonitorToolBase.cxx.

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

Member Data Documentation

◆ m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial
privateinherited

Definition at line 894 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 901 of file ManagedMonitorToolBase.h.

◆ m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType
protectedinherited

Definition at line 839 of file ManagedMonitorToolBase.h.

◆ m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr
protectedinherited

Definition at line 835 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 896 of file ManagedMonitorToolBase.h.

◆ m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel
protectedinherited

Definition at line 837 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 850 of file ManagedMonitorToolBase.h.

850{this,"FilterTools",{}};

◆ m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock
privateinherited

Definition at line 824 of file ManagedMonitorToolBase.h.

◆ m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat
privateinherited

Definition at line 824 of file ManagedMonitorToolBase.h.

◆ m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock
privateinherited

Definition at line 824 of file ManagedMonitorToolBase.h.

◆ m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun
privateinherited

Definition at line 824 of file ManagedMonitorToolBase.h.

◆ m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment
protectedinherited

Definition at line 840 of file ManagedMonitorToolBase.h.

◆ m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr
protectedinherited

Definition at line 836 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 834 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 198 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_authors

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

Definition at line 200 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_category

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

Definition at line 199 of file MuonPhysValMonitoringTool.h.

199{nullptr};

◆ m_h_overview_Z_mass

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

Definition at line 202 of file MuonPhysValMonitoringTool.h.

202{nullptr};

◆ m_h_overview_Z_mass_ID

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

Definition at line 204 of file MuonPhysValMonitoringTool.h.

204{nullptr};

◆ m_h_overview_Z_mass_ME

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

Definition at line 203 of file MuonPhysValMonitoringTool.h.

203{nullptr};

◆ m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock
protectedinherited

Definition at line 867 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 862 of file ManagedMonitorToolBase.h.

◆ m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval
protectedinherited

Definition at line 862 of file ManagedMonitorToolBase.h.

◆ m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock
protectedinherited

Definition at line 860 of file ManagedMonitorToolBase.h.

◆ m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval
protectedinherited

Definition at line 862 of file ManagedMonitorToolBase.h.

◆ m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lbDurationDataKey

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

Definition at line 889 of file ManagedMonitorToolBase.h.

890{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 887 of file ManagedMonitorToolBase.h.

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

◆ m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager
protectedinherited

Definition at line 830 of file ManagedMonitorToolBase.h.

◆ m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp
protectedinherited

Definition at line 832 of file ManagedMonitorToolBase.h.

◆ m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap
protectedinherited

Definition at line 828 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 188 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDSelectedTrackValidationPlots

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

Definition at line 187 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDTrackValidationPlots

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

Definition at line 186 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 184 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 185 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSTrackValidationPlots

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

Definition at line 183 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 189 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 181 of file MuonPhysValMonitoringTool.h.

◆ m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents
protectedinherited

Definition at line 864 of file ManagedMonitorToolBase.h.

◆ m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger
protectedinherited

Definition at line 865 of file ManagedMonitorToolBase.h.

◆ m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat
privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

◆ m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock
privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

◆ m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newRun

bool ManagedMonitorToolBase::m_newRun
privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

◆ m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks
protectedinherited

Definition at line 866 of file ManagedMonitorToolBase.h.

◆ m_oUnmatchedRecoMuonPlots

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

Definition at line 190 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonSegmentPlots

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

Definition at line 193 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonTrackPlots

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

Definition at line 192 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedTruthMuonPlots

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

Definition at line 191 of file MuonPhysValMonitoringTool.h.

◆ m_path

std::string ManagedMonitorToolBase::m_path
protectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

◆ m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp
protectedinherited

Definition at line 854 of file ManagedMonitorToolBase.h.

◆ m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp
protectedinherited

Definition at line 852 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 195 of file MuonPhysValMonitoringTool.h.

◆ m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn
protectedinherited

Definition at line 842 of file ManagedMonitorToolBase.h.

◆ m_supportedIntervalsForRebooking

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

Definition at line 897 of file ManagedMonitorToolBase.h.

◆ m_templateEfficiencies

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

Definition at line 677 of file ManagedMonitorToolBase.h.

◆ m_templateGraphs

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

Definition at line 669 of file ManagedMonitorToolBase.h.

◆ m_templateHistograms

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

Definition at line 665 of file ManagedMonitorToolBase.h.

◆ m_templateTrees

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

Definition at line 673 of file ManagedMonitorToolBase.h.

◆ m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc
protectedinherited

Definition at line 844 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 846 of file ManagedMonitorToolBase.h.

846{this, "TrigDecisionTool",""};

◆ m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp
protectedinherited

Definition at line 855 of file ManagedMonitorToolBase.h.

◆ m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp
protectedinherited

Definition at line 856 of file ManagedMonitorToolBase.h.

◆ m_TriggerMuonValidationPlots

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

Definition at line 182 of file MuonPhysValMonitoringTool.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 891 of file ManagedMonitorToolBase.h.

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

◆ m_trigTranslator

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

Definition at line 848 of file ManagedMonitorToolBase.h.

848{this,"TriggerTranslatorTool",""};

◆ m_useLumi

bool ManagedMonitorToolBase::m_useLumi
privateinherited

Definition at line 895 of file ManagedMonitorToolBase.h.

◆ m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger
protectedinherited

Definition at line 858 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 214 of file MuonPhysValMonitoringTool.h.

◆ m_vEFMuonsSelected

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

Definition at line 215 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 218 of file MuonPhysValMonitoringTool.h.

◆ m_vL2CBMuonsSelected

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

Definition at line 219 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuons

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

Definition at line 216 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuonsSelected

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

Definition at line 217 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuons

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

Definition at line 207 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonSegments

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

Definition at line 210 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonTracks

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

Definition at line 209 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedSlowMuons

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

Definition at line 208 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedTruthMuons

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

Definition at line 206 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons

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

Definition at line 220 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen

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

Definition at line 223 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_CB

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

Definition at line 221 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_MS

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

Definition at line 222 of file MuonPhysValMonitoringTool.h.

◆ m_vTrigChainNames

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

Definition at line 681 of file ManagedMonitorToolBase.h.

◆ m_vTrigGroupNames

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

Definition at line 681 of file ManagedMonitorToolBase.h.

◆ m_vZmumuIDTracks

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

Definition at line 211 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMETracks

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

Definition at line 212 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMuons

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

Definition at line 213 of file MuonPhysValMonitoringTool.h.

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