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>
using Quality = xAOD::Muon::Quality
using Author = xAOD::Muon::Author
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)
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::set< int > > m_selectMuonWPs
Gaudi::Property< std::set< int > > m_selectMuonAuthors
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

◆ Author

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::Author = xAOD::Muon::Author
private

Definition at line 148 of file MuonPhysValMonitoringTool.h.

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

◆ Quality

using MuonPhysValMonitoring::MuonPhysValMonitoringTool::Quality = xAOD::Muon::Quality
private

Definition at line 143 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 112 of file MuonPhysValMonitoringTool.cxx.

112 {
113 ATH_MSG_INFO("Booking hists " << name() << "...");
114
115
116 static const std::map<int,std::string> theMuonCategories = {
117 {ALL, "All"},
118 {PROMPT, "Prompt"},
119 {INFLIGHT, "InFlight"},
120 {NONISO, "NonIsolated"},
121 {REST, "Rest"}
122 };
123
124 for (const auto& category : m_selectMuonCategories) m_selectMuonCategoriesStr.emplace_back(theMuonCategories.at(category));
125
126 // no such muons in case of SlowMuon reco
127 bool separateSAFMuons = m_slowMuonsName.empty();
128
129 std::string muonContainerName = m_muonsName.key();
130 for (const auto& category : m_selectMuonCategoriesStr) {
131 std::string categoryPath = muonContainerName + "/" + category + "/";
132
133 m_muonValidationPlots.emplace_back(std::make_unique<MuonValidationPlots>(
134 nullptr, categoryPath, m_selectMuonWPs, m_selectMuonAuthors, m_isData,
135 (category == theMuonCategories.at(ALL) ? false : m_doBinnedResolutionPlots.value()), separateSAFMuons));
136
137 if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots.emplace_back(std::make_unique<SlowMuonValidationPlots>(nullptr, categoryPath, m_isData));
138 if (m_doTrigMuonValidation) {
139 if (category == "All") {
140 m_TriggerMuonValidationPlots.emplace_back(std::make_unique<TriggerMuonValidationPlots>(
141 nullptr, categoryPath, m_selectMuonAuthors, m_isData, m_doTrigMuonL1Validation, m_doTrigMuonL2Validation,
142 m_doTrigMuonEFValidation, m_selectHLTMuonItems, m_L1MuonItems));
143 }
144 }
145 if (!m_muonTracksName.empty()) {
146 m_muonMSTrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "MSTrackParticles", m_isData));
147 if (!m_isData)
148 m_oUnmatchedRecoMuonTrackPlots = std::make_unique<Muon::RecoMuonTrackPlotOrganizer>(nullptr, muonContainerName + "/UnmatchedRecoMuonTracks/");
149 }
150 if (!m_muonExtrapolatedTracksName.empty())
151 m_muonMETrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "METrackParticles", m_isData));
152 if (!m_muonMSOnlyExtrapolatedTracksName.empty())
153 m_muonMSOnlyMETrackValidationPlots.emplace_back(
154 std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "MSOnlyMETrackParticles", m_isData));
155
156 if (!m_tracksName.empty()) {
157 m_muonIDTrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDTrackParticles", m_isData));
158 m_muonIDSelectedTrackValidationPlots.emplace_back(
159 std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDSelectedTrackParticles", m_isData));
160 }
161 if (!m_fwdtracksName.empty())
162 m_muonIDForwardTrackValidationPlots.emplace_back(
163 std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDForwardTrackParticles", m_isData));
164
165 if (!m_muonSegmentsName.empty()) {
166 if (category != theMuonCategories.at(ALL)) continue; // cannot identify the truth origin of segments...
167 m_muonSegmentValidationPlots.emplace_back(std::make_unique<MuonSegmentValidationPlots>(nullptr, categoryPath, m_isData));
168 if (!m_isData)
169 m_oUnmatchedRecoMuonSegmentPlots.reset(
170 new Muon::MuonSegmentPlots(nullptr, Form("%s/UnmatchedRecoMuonSegments/", muonContainerName.c_str())));
171 }
172 }
173
174 if (!m_isData) {
175 m_oUnmatchedRecoMuonPlots = std::make_unique<Muon::RecoMuonPlotOrganizer>(nullptr, muonContainerName +"/UnmatchedRecoMuons/");
176 m_oUnmatchedTruthMuonPlots = std::make_unique<Muon::TruthMuonPlotOrganizer>(nullptr, muonContainerName +"/UnmatchedTruthMuons/");
177 }
178
179 for (const auto& plots : m_muonValidationPlots) bookValidationPlots(*plots).ignore();
180 for (const auto& plots : m_slowMuonValidationPlots) bookValidationPlots(*plots).ignore();
181 for (const auto& plots : m_TriggerMuonValidationPlots) bookValidationPlots(*plots).ignore();
182 for (const auto& plots : m_muonIDTrackValidationPlots) bookValidationPlots(*plots).ignore();
183 for (const auto& plots : m_muonIDSelectedTrackValidationPlots) bookValidationPlots(*plots).ignore();
184 for (const auto& plots : m_muonIDForwardTrackValidationPlots) bookValidationPlots(*plots).ignore();
185 for (const auto& plots : m_muonMSTrackValidationPlots) bookValidationPlots(*plots).ignore();
186 for (const auto& plots : m_muonMETrackValidationPlots) bookValidationPlots(*plots).ignore();
187 for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) bookValidationPlots(*plots).ignore();
188 if (!m_isData) {
189 bookValidationPlots(*m_oUnmatchedRecoMuonPlots).ignore();
190 bookValidationPlots(*m_oUnmatchedTruthMuonPlots).ignore();
191 if (m_oUnmatchedRecoMuonTrackPlots) bookValidationPlots(*m_oUnmatchedRecoMuonTrackPlots).ignore();
192 for (const auto& plots : m_muonSegmentValidationPlots) bookValidationPlots(*plots).ignore();
193 if (m_oUnmatchedRecoMuonSegmentPlots) bookValidationPlots(*m_oUnmatchedRecoMuonSegmentPlots).ignore();
194 }
195 // book overview hists
196 m_h_overview_Z_mass = new TH1F(Form("%s_Overview_Z_mass", muonContainerName.c_str()), "", 20, 76, 106);
197 ATH_CHECK(regHist(m_h_overview_Z_mass, Form("%s/Overview", muonContainerName.c_str()), all));
198 m_h_overview_Z_mass_ME = new TH1F(Form("%s_Overview_Z_mass_ME", muonContainerName.c_str()), "", 20, 76, 106);
199 ATH_CHECK(regHist(m_h_overview_Z_mass_ME, Form("%s/Overview", muonContainerName.c_str()), all));
200 m_h_overview_Z_mass_ID = new TH1F(Form("%s_Overview_Z_mass_ID", muonContainerName.c_str()), "", 20, 76, 106);
201 ATH_CHECK(regHist(m_h_overview_Z_mass_ID, Form("%s/Overview", muonContainerName.c_str()), all));
202
203 m_h_overview_nObjects.clear();
204 m_h_overview_nObjects.emplace_back(new TH1F(Form("%s_Overview_N_perevent_truth_muons", muonContainerName.c_str()),
205 "Number of truth Muons per event", 20, -0.5, 19.5));
206 m_h_overview_nObjects.emplace_back(
207 new TH1F(Form("%s_Overview_N_perevent_muons", muonContainerName.c_str()), "Number of Muons per event", 20, -0.5, 19.5));
208 m_h_overview_nObjects.emplace_back(
209 new TH1F(Form("%s_Overview_N_perevent_tracks", muonContainerName.c_str()), "Number of Tracks per event", 50, -0.5, 49.5));
210 m_h_overview_nObjects.emplace_back(new TH1F(Form("%s_Overview_N_perevent_truth_segments", muonContainerName.c_str()),
211 "Number of truth Segments per event", 200, -0.5, 199.5));
212 m_h_overview_nObjects.emplace_back(
213 new TH1F(Form("%s_Overview_N_perevent_segments", muonContainerName.c_str()), "Number of Segments per event", 200, -0.5, 199.5));
214 for (const auto& hist : m_h_overview_nObjects) {
215 if (hist) ATH_CHECK(regHist(hist, Form("%s/Overview", muonContainerName.c_str()), all));
216 }
217
218 m_h_overview_reco_category =
219 new TH1F(Form("%s_Overview_reco_category", muonContainerName.c_str()), "", 4, 0, 4); // prompt/in-flight/non-isolated/other
220 for (int i = 1; i < 4; i++) { // skip 'All'
221 m_h_overview_reco_category->GetXaxis()->SetBinLabel(i, theMuonCategories.at(i).c_str());
222 }
223 m_h_overview_reco_category->GetXaxis()->SetBinLabel(4, "Other"); // of some other origin or fakes
224 ATH_CHECK(regHist(m_h_overview_reco_category, Form("%s/Overview", muonContainerName.c_str()), all));
225
226 int nAuth = static_cast<int>(xAOD::Muon::Author::NumberOfMuonAuthors);
227 for (int i = 1; i < 4; i++) {
228 m_h_overview_reco_authors.emplace_back(new TH1F((muonContainerName + "_" + theMuonCategories.at(i) + "_reco_authors").c_str(),
229 (muonContainerName + "_" + theMuonCategories.at(i) + "_reco_authors").c_str(),
230 nAuth + 1, -0.5, nAuth + 0.5));
231 }
232 m_h_overview_reco_authors.emplace_back(new TH1F((muonContainerName + "_Overview_Other_reco_authors").c_str(),
233 (muonContainerName + "_Other_reco_authors").c_str(), nAuth + 1, -0.5, nAuth + 0.5));
234
235 for (const auto& hist : m_h_overview_reco_authors) {
236 if (hist) ATH_CHECK(regHist(hist, Form("%s/Overview", muonContainerName.c_str()), all));
237 }
238
239 return StatusCode::SUCCESS;
240 }//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:200
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentValidationPlots
std::vector< std::unique_ptr< MuonSegmentValidationPlots > > m_muonSegmentValidationPlots
Definition MuonPhysValMonitoringTool.h:196
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedTruthMuonPlots
std::unique_ptr< Muon::TruthMuonPlotOrganizer > m_oUnmatchedTruthMuonPlots
Definition MuonPhysValMonitoringTool.h:198
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonValidationPlots
std::vector< std::unique_ptr< SlowMuonValidationPlots > > m_slowMuonValidationPlots
Definition MuonPhysValMonitoringTool.h:202
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonPlots
std::unique_ptr< Muon::RecoMuonPlotOrganizer > m_oUnmatchedRecoMuonPlots
Definition MuonPhysValMonitoringTool.h:197
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonTrackPlots
std::unique_ptr< Muon::RecoMuonTrackPlotOrganizer > m_oUnmatchedRecoMuonTrackPlots
Definition MuonPhysValMonitoringTool.h:199
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDForwardTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDForwardTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:195
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMETrackValidationPlots
Definition MuonPhysValMonitoringTool.h:191
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_TriggerMuonValidationPlots
std::vector< std::unique_ptr< TriggerMuonValidationPlots > > m_TriggerMuonValidationPlots
Definition MuonPhysValMonitoringTool.h:189
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:190
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_L1MuonItems
Gaudi::Property< std::vector< std::string > > m_L1MuonItems
Definition MuonPhysValMonitoringTool.h:159
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategories
Gaudi::Property< std::vector< unsigned int > > m_selectMuonCategories
Definition MuonPhysValMonitoringTool.h:160
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonValidationPlots
std::vector< std::unique_ptr< MuonValidationPlots > > m_muonValidationPlots
Definition MuonPhysValMonitoringTool.h:188
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectHLTMuonItems
Gaudi::Property< std::vector< std::vector< std::string > > > m_selectHLTMuonItems
Definition MuonPhysValMonitoringTool.h:158
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSOnlyMETrackValidationPlots
Definition MuonPhysValMonitoringTool.h:192
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:193
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDSelectedTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDSelectedTrackValidationPlots
Definition MuonPhysValMonitoringTool.h:194
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 242 of file MuonPhysValMonitoringTool.cxx.

242 {
243 valPlots.initialize();
244 std::vector<HistData> hists = valPlots.retrieveBookedHistograms();
245
246 for (auto& hist : hists) {
247 TString sHistName = hist.first->GetName();
248 ATH_MSG_VERBOSE("Initializing " << hist.first << " " << sHistName << " " << hist.second << "...");
249
250 // check for histograms that are useless and skip regHist:
251 if (sHistName.Contains("momentumPulls")) {
252 if (sHistName.Contains(xAOD::Muon::toString(xAOD::Muon::Author::MuidSA).data())) continue; // empty for standalone muons
253 if (!(sHistName.Contains("Prompt") && (sHistName.Contains("AllMuons") || sHistName.Contains("SiAssocForward"))))
254 continue; // don't need binned eloss plots for separate muon types, keep only for Prompt AllMuons
255 }
256 if ((sHistName.Contains("resolution") || sHistName.Contains("pulls")) && !sHistName.Contains("Prompt"))
257 continue; // don't need resolution plots except for prompt muons
258 if (sHistName.Contains("trigger") && sHistName.Contains("wrt") && sHistName.Contains("Features")) continue;
259 modifyHistogram(hist.first);
260 ATH_CHECK(regHist(hist.first, hist.second, all));
261 }
262
263 // register trees
264 std::vector<TreeData> trees = valPlots.retrieveBookedTrees();
265 for (auto& tree : trees) {
266 std::string sTreeName = tree.first->GetName();
267 ATH_MSG_VERBOSE("Initializing " << tree.first << " " << sTreeName << " " << tree.second << "...");
268 ATH_CHECK(regTree(tree.first, tree.second, all));
269 }
270
271 return StatusCode::SUCCESS;
272 }
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
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 1191 of file MuonPhysValMonitoringTool.cxx.

1191 {
1192 int k_EFMu_MinDeltaR = -1;
1193 float MinDeltaR = 0.;
1194 std::vector<int> vAvailableAuthors;
1195
1196 vAvailableAuthors.emplace_back(static_cast<int>(m_vEFMuons[0]->author()));
1197 unsigned int iter = 0;
1198 for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1199 iter = 0;
1200 for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1201 if (static_cast<int>(m_vEFMuons[k]->author()) != vAvailableAuthors[l]) iter++;
1202 }
1203 if (iter == vAvailableAuthors.size()) vAvailableAuthors.emplace_back(
1204 static_cast<int>(m_vEFMuons[k]->author()));
1205 }
1206 ATH_MSG_DEBUG(" m_vEFMuons.size()" << m_vEFMuons.size());
1207 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1208 ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1209 << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1210 }
1211 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1212 if ((m_vRecoMuons.at(i)->author() != xAOD::Muon::Author::MuidCo) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1213 ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1214 << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1215 for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1216 k_EFMu_MinDeltaR = -1;
1217 MinDeltaR = 1000;
1218 for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1219 ATH_MSG_DEBUG(" :::::::: TEST: EF pt=" << m_vEFMuons.at(k)->pt() << " eta=" << m_vEFMuons.at(k)->eta()
1220 << " phi=" << m_vEFMuons.at(k)->phi()
1221 << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k))
1222 << " author=" << m_vEFMuons.at(k)->author());
1223 if (static_cast<int>(m_vEFMuons.at(k)->author()) == vAvailableAuthors.at(l) &&
1224 (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < 0.1 &&
1225 (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < MinDeltaR))) {
1226 k_EFMu_MinDeltaR = k;
1227 MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k));
1228 }
1229 }
1230 if (k_EFMu_MinDeltaR == -1) continue;
1231 for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1232 if (m_selectMuonCategories[c] == ALL) {
1233 m_TriggerMuonValidationPlots[c]->fill(*m_vEFMuons.at(k_EFMu_MinDeltaR), *m_vRecoMuons.at(i));
1234 }
1235 }
1236 }
1237 }
1238 }
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 274 of file MuonPhysValMonitoringTool.cxx.

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

1324 {
1325 TH1F* h = nullptr;
1326 for (const auto& hist : hists) {
1327 if (hist.second.find(hdirTag) != std::string::npos || hdirTag.empty()) {
1328 std::string histname = hist.first->GetName();
1329 if (histname.find(hnameTag) != std::string::npos) {
1330 h = (TH1F*)hist.first->Clone(hNewName.c_str());
1331 return h;
1332 }
1333 }
1334 }
1335 return h;
1336 }

◆ findRecoMuon()

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

Definition at line 1250 of file MuonPhysValMonitoringTool.cxx.

1250 {
1251 static const SG::ConstAccessor<MuonLink> acc_muon("recoMuonLink");
1252 if (!acc_muon.isAvailable(*truthMu)) return nullptr;
1253 MuonLink link = acc_muon(*truthMu);
1254 if (!link.isValid()) return nullptr;
1255 const xAOD::Muon* reco_mu = (*link);
1256 m_vMatchedMuons.emplace_back(reco_mu);
1257 return reco_mu;
1258 }
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 1308 of file MuonPhysValMonitoringTool.cxx.

1308 {
1309 static const SG::ConstAccessor<MuonSegmentLink> recoSegmentLinkAcc("recoSegmentLink");
1310 if (!recoSegmentLinkAcc.isAvailable(*truthMuSeg)) {
1311 ATH_MSG_DEBUG("recoSegmentLink not found");
1312 return nullptr;
1313 }
1314 MuonSegmentLink link = recoSegmentLinkAcc(*truthMuSeg);
1315 if (!link.isValid()) {
1316 ATH_MSG_DEBUG("recoSegmentLink not valid");
1317 return nullptr;
1318 }
1319 m_vMatchedMuonSegments.emplace_back(*link);
1320 return (*link);
1321 }

◆ findRecoSlowMuon()

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

Definition at line 1260 of file MuonPhysValMonitoringTool.cxx.

1260 {
1261 const xAOD::SlowMuonContainer* SlowMuons = nullptr;
1262 SG::get(SlowMuons, m_slowMuonsName, Gaudi::Hive::currentContext()).ignore();
1263 if (!SlowMuons) return nullptr;
1264 for (const auto smu : *SlowMuons) {
1265 const MuonLink muLink = smu->muonLink();
1266 if (!muLink.isValid()) continue;
1267 float DR = deltaR(*muLink , truthMu);
1268 if (DR < 0.005) {
1269 m_vMatchedSlowMuons.emplace_back(smu);
1270 return smu;
1271 }
1272 }
1273
1274 return nullptr;
1275 }

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

1371 {
1372 std::unique_ptr<xAOD::Muon> mu_c;
1373 if (mu.m() <= 0) return mu_c;
1374 mu_c = std::make_unique<xAOD::Muon>();
1375 mu_c->makePrivateStore(mu);
1376
1377 // add decorations too fool the muon selector tool
1378 const xAOD::TrackParticle* idtrk{mu_c->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)};
1379 const xAOD::TrackParticle* metrk{mu_c->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)};
1380 if (idtrk && metrk) {
1381 const static SG::Decorator<float> InnerDetectorPtDec("InnerDetectorPt");
1382 const static SG::Decorator<float> MuonSpectrometerPtDec("MuonSpectrometerPt");
1383 InnerDetectorPtDec(*mu_c) = idtrk->pt();
1384 MuonSpectrometerPtDec(*mu_c) = metrk->pt();
1385 }
1386 m_muonSelectionTool->setQuality(*mu_c);
1387 m_muonSelectionTool->setPassesIDCuts(*mu_c);
1388 return mu_c;
1389 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition MuonPhysValMonitoringTool.h:175
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 1338 of file MuonPhysValMonitoringTool.cxx.

1339 {
1340 static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1341 TruthLink truthLink;
1342 if (truthParticleLinkAcc.isAvailable(*truthMuSeg)) {
1343 truthLink = truthParticleLinkAcc(*truthMuSeg);
1344 if (truthLink.isValid()) {
1345 const int theUniqueID = HepMC::uniqueID(*truthLink);
1346 if (std::abs((*truthLink)->pdgId()) != 13) return REST;
1347
1348 for (const auto muTruthPart : *muonTruthContainer) {
1349 if ( HepMC::uniqueID(muTruthPart) == theUniqueID ) { return getMuonTruthCategory(muTruthPart); }
1350 }
1351 }
1352 } else
1353 ATH_MSG_WARNING("No truth link available for muon truth segment");
1354
1355 return REST;
1356 }
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
TruthLink
ElementLink< xAOD::TruthParticleContainer > TruthLink
Definition TruthRelatedMuonPlotOrganizer.cxx:13
MuonPhysValMonitoring::MuonPhysValMonitoringTool::getMuonTruthCategory
MuonPhysValMonitoringTool::MUCATEGORY getMuonTruthCategory(const xAOD::IParticle *prt)
Definition MuonPhysValMonitoringTool.cxx:1358
HepMC::uniqueID
int uniqueID(const T &p)
Definition MagicNumbers.h:89

◆ getMuonTruthCategory()

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

Definition at line 1358 of file MuonPhysValMonitoringTool.cxx.

1358 {
1359 static const SG::ConstAccessor<int> truthTypeAcc("truthType");
1360 static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
1361 int truthType = truthTypeAcc(*mu);
1362 if (truthType == 6)
1363 return PROMPT;
1364 else if (truthType == 8 && (truthOriginAcc(*mu) == 34 || truthOriginAcc(*mu) == 35))
1365 return INFLIGHT;
1366 else if (truthType == 7)
1367 return NONISO;
1368 return REST;
1369 }
IDTPM::truthType
int truthType(const U &p)
Definition TrackParametersHelper.h:273

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

864 {
865 if (!mu) return;
866
867 if (msgLvl(MSG::DEBUG)) printMuonDebug(mu);
868
869 // make deep copy of muon and decorate with quality
870 std::unique_ptr<xAOD::Muon> mu_c;
871 try {
872 mu_c = getCorrectedMuon(*mu);
873 } catch (const SG::ExcBadAuxVar&) {
874 ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
875 return;
876 }
877
878 if (m_isData) {
879 MUCATEGORY thisMuonCategory = ALL;
880 // for events with a Zmumu candidate, separate Z muons from the rest:
881 if (m_vZmumuMuons.size() > 0) {
882 thisMuonCategory = REST;
883 if (std::find(m_vZmumuMuons.begin(), m_vZmumuMuons.end(), mu) != m_vZmumuMuons.end()) { thisMuonCategory = PROMPT; }
884 }
885 // fill plots
886 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
887 if (m_selectMuonCategories[i] == ALL or m_selectMuonCategories[i] == thisMuonCategory) {
888 if (mu_c){
889 // histos
890 m_muonValidationPlots[i]->fill(*mu_c, weight);
891 if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
892 }
893 }
894 }
895 }
896
898 // SELECT MUON MEDIUM QUALITY FOR TRIGGER VALIDATION
899 xAOD::Muon::Quality my_quality = m_muonSelectionTool->getQuality(*mu_c);
900 if (my_quality <= xAOD::Muon::Quality::Medium && m_isoTool->accept(*mu_c)) m_vRecoMuons.emplace_back(mu);
902
903 if (smu) {
904 if (std::find(std::begin(m_vMatchedSlowMuons), std::end(m_vMatchedSlowMuons), smu) != std::end(m_vMatchedSlowMuons)) { return; }
905 } else {
906 if (std::find(std::begin(m_vMatchedMuons), std::end(m_vMatchedMuons), mu) != std::end(m_vMatchedMuons)) { return; }
907 }
908
909 // unmatched reco muons (not matched with any kind of truth particle, fakes)
910 if (!m_isData) m_oUnmatchedRecoMuonPlots->fill(*mu_c, weight);
911
912 m_h_overview_reco_category->Fill("Other", weight);
913 m_h_overview_reco_authors[3]->Fill(static_cast<int>(mu->author()), weight);
914
915 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
916 if (m_selectMuonCategories[i] == ALL) {
917 if (mu_c){// histos
918 m_muonValidationPlots[i]->fill(*mu_c);
919 if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
920 break;
921 }
922 }
923 }
924 }
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:1371
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 1075 of file MuonPhysValMonitoringTool.cxx.

1075 {
1076 ATH_MSG_DEBUG("MuonRoI L1 Trigger: ptThr " << TrigL1mu->thrValue() << " phi " << TrigL1mu->phi() << " eta " << TrigL1mu->eta());
1077 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1078 if (m_selectMuonCategories[i] == ALL) {
1079 m_TriggerMuonValidationPlots[i]->fill(*TrigL1mu);
1080 break;
1081 }
1082 }
1083 }
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 1133 of file MuonPhysValMonitoringTool.cxx.

1133 {
1134 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1135 if (m_selectMuonCategories[i] == ALL) {
1136 m_TriggerMuonValidationPlots[i]->fill(*L2CBMu);
1137 break;
1138 }
1139 }
1140 ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2CB Trigger : pt " << L2CBMu->pt() << " phi " << L2CBMu->phi() << " eta "
1141 << L2CBMu->eta());
1142 }
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 1085 of file MuonPhysValMonitoringTool.cxx.

1085 {
1086 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1087 if (m_selectMuonCategories[i] == ALL) {
1088 m_TriggerMuonValidationPlots[i]->fill(*L2SAMu);
1089 break;
1090 }
1091 }
1092 ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2SA Trigger : pt " << L2SAMu->pt() << " phi " << L2SAMu->phi() << " eta "
1093 << L2SAMu->eta() << " roiWord " << L2SAMu->roiWord()
1094 << " sAddress " << L2SAMu->sAddress());
1095 }
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 848 of file MuonPhysValMonitoringTool.cxx.

848 {
849 if (!muSeg) {
850 ATH_MSG_WARNING("No muon segment found");
851 return;
852 }
853 if (std::find(std::begin(m_vMatchedMuonSegments), std::end(m_vMatchedMuonSegments), muSeg) != std::end(m_vMatchedMuonSegments))
854 return;
855 if (!m_isData) m_oUnmatchedRecoMuonSegmentPlots->fill(*muSeg, weight);
856 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
857 if (m_selectMuonCategories[i] == ALL) {
858 m_muonSegmentValidationPlots[i]->fill(muSeg, weight);
859 break;
860 }
861 }
862 }

◆ handleMuonTrack()

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

Definition at line 974 of file MuonPhysValMonitoringTool.cxx.

974 {
975 if (!tp) {
976 ATH_MSG_WARNING("No track particle found");
977 return;
978 }
979
980 // if ID track, check that it passes standard combined mu reco selections
981 bool passesMuonTrackSel = false;
982 if (type == xAOD::Muon::InnerDetectorTrackParticle) { passesMuonTrackSel = m_trackSelector->decision(*tp); }
983
984 if (m_isData) {
985 if (type == xAOD::Muon::InnerDetectorTrackParticle) {
986 MUCATEGORY thisTrkCategory = ALL;
987 // for events with a Zmumu candidate, separate Z muon tracks from the rest:
988 if (m_vZmumuIDTracks.size() > 0) {
989 thisTrkCategory = REST;
990 for (const auto& zmu : m_vZmumuIDTracks) {
991 if (deltaR(zmu, tp) < 0.01) {
992 thisTrkCategory = PROMPT;
993 break;
994 }
995 }
996 }
997
998 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
999 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisTrkCategory) {
1000 m_muonIDTrackValidationPlots[i]->fill(*tp, weight);
1001 if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*tp, weight);
1002 }
1003 }
1004 } else if (type == xAOD::Muon::MuonSpectrometerTrackParticle)
1005 m_muonMSTrackValidationPlots[ALL]->fill(*tp, weight);
1006 else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)
1007 m_muonMETrackValidationPlots[ALL]->fill(*tp, weight);
1008 else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle)
1009 m_muonMSOnlyMETrackValidationPlots[ALL]->fill(*tp, weight);
1010
1011 return;
1012 }
1013
1014 static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1015 TruthLink truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
1016
1017 if (!truthLink.isValid()) {
1018 ATH_MSG_DEBUG("No truth link available");
1019 if (type == xAOD::Muon::InnerDetectorTrackParticle) return;
1020 if (!passesAcceptanceCuts(tp)) return;
1021
1022 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1023 if (m_selectMuonCategories[i] == ALL) {
1024 // ID track plots for any track
1025 // if (type==xAOD::Muon::InnerDetectorTrackParticle) {
1026 // m_muonIDTrackValidationPlots[i]->fill(*tp);
1027 // if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*tp);
1028 // } else
1029 if (type == xAOD::Muon::MuonSpectrometerTrackParticle) {
1030 if (!m_isData) m_oUnmatchedRecoMuonTrackPlots->fill(*tp, weight);
1031 m_muonMSTrackValidationPlots[i]->fill(*tp, weight);
1032 } else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) {
1033 m_muonMETrackValidationPlots[i]->fill(*tp, weight);
1034 } else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle) {
1035 m_muonMSOnlyMETrackValidationPlots[i]->fill(*tp, weight);
1036 }
1037 break;
1038 }
1039 }
1040 } // end if no valid truth link
1041 else { // here: valid truth link and truthType
1042
1043 if (type ==
1044 xAOD::Muon::InnerDetectorTrackParticle) { // don't fill histograms for any ID track, only for muons; buys a lot of time
1045 if ((*truthLink)->absPdgId() != 13 || !MC::isStable(*truthLink)) return; // not a muon
1046 if (HepMC::uniqueID(*truthLink) == HepMC::UNDEFINED_ID || HepMC::is_simulation_particle((*truthLink))) return; // must have valid barcode
1047 }
1048
1049 if (!passesAcceptanceCuts(*truthLink)) return;
1050 unsigned int thisMuonCategory = getMuonTruthCategory(tp);
1051
1052 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1053 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
1054 if (type == xAOD::Muon::InnerDetectorTrackParticle) {
1055 if (!m_fwdtracksName.empty() && std::abs((*truthLink)->eta()) > 2.5)
1056 m_muonIDForwardTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1057 else if (!m_tracksName.empty()) {
1058 m_muonIDTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1059 if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1060 }
1061 } else if (type == xAOD::Muon::MuonSpectrometerTrackParticle) {
1062 m_muonMSTrackValidationPlots[i]->fill(*truthLink, tp, weight);
1063 } else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) {
1064 m_muonMETrackValidationPlots[i]->fill(*truthLink, tp, weight);
1065 } else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle) {
1066 m_muonMSOnlyMETrackValidationPlots[i]->fill(*truthLink, tp, weight);
1067 }
1068 }
1069 }
1070 }
1071
1072 return;
1073 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_trackSelector
ToolHandle< Trk::ITrackSelectorTool > m_trackSelector
Definition MuonPhysValMonitoringTool.h:178
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:322
MC::isStable
bool isStable(const T &p)
Identify if the particle is stable, i.e. has not decayed.
Definition HepMCHelpers.h:51

◆ handleMuonTrigger()

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

Definition at line 1180 of file MuonPhysValMonitoringTool.cxx.

1180 {
1181 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1182 if (m_selectMuonCategories[i] == ALL) {
1183 m_TriggerMuonValidationPlots[i]->fill(*EFMu);
1184 break;
1185 }
1186 }
1187 ATH_MSG_DEBUG("==> Geometrical selection of EF Trigger muons: pt " << EFMu->pt() << " phi " << EFMu->phi() << " eta " << EFMu->eta()
1188 << " author " << EFMu->author());
1189 }

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

926 {
927 const xAOD::SlowMuon* smu = nullptr;
928 const xAOD::Muon* mu = nullptr;
929 if (!m_slowMuonsName.empty()) {
930 smu = findRecoSlowMuon(truthMu);
931 if (smu) {
932 const MuonLink muLink = smu->muonLink();
933 if (muLink.isValid()) mu = *muLink;
934
935 if (!mu) {
936 ATH_MSG_WARNING("Found SlowMuon without valid muon link");
937 smu = nullptr;
938 }
939 }
940 } else {
941 mu = findRecoMuon(truthMu);
942 }
943
944 if (msgLvl(MSG::DEBUG)) printTruthMuonDebug(truthMu, mu);
945 if (!passesAcceptanceCuts(truthMu)) return;
946
947 std::unique_ptr<xAOD::Muon> mu_c;
948 if (mu) {
949 try {
950 mu_c = getCorrectedMuon(*mu);
951 } catch (const SG::ExcBadAuxVar&) {
952 ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
953 return;
954 }
955 }
956
957 unsigned int thisMuonCategory = getMuonTruthCategory(truthMu);
958 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
959 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
960 // histos
961 m_muonValidationPlots[i]->fill(
962 truthMu, mu_c.get(), m_MSTracks,
963 weight); // if no muon is found a protection inside MuonValidationPlots will ensure, its plots won't be filled
964 if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots[i]->fill(truthMu, smu, mu_c.get(), weight);
965 }
966 }
967 if (mu_c) {
968 m_h_overview_reco_category->Fill(thisMuonCategory - 1, weight);
969 m_h_overview_reco_authors[thisMuonCategory - 1]->Fill(static_cast<int>(mu_c->author()), weight);
970 } else if (!m_isData)
971 m_oUnmatchedTruthMuonPlots->fill(*truthMu, weight);
972 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoSlowMuon
const xAOD::SlowMuon * findRecoSlowMuon(const xAOD::TruthParticle *truthMu)
Definition MuonPhysValMonitoringTool.cxx:1260
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuon
const xAOD::Muon * findRecoMuon(const xAOD::TruthParticle *truthMu)
Definition MuonPhysValMonitoringTool.cxx:1250
MuonPhysValMonitoring::MuonPhysValMonitoringTool::printTruthMuonDebug
void printTruthMuonDebug(const xAOD::TruthParticle *truthMu, const xAOD::Muon *mu)
Definition MuonPhysValMonitoringTool.cxx:1277
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 832 of file MuonPhysValMonitoringTool.cxx.

833 {
834 const xAOD::MuonSegment* muSeg = findRecoMuonSegment(truthMuSeg);
836
837 unsigned int thisMuonCategory = ALL; // getMuonSegmentTruthCategory(truthMuSeg, muonTruthContainer) @@@ Does not work...
838
839 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
840 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
841 m_muonSegmentValidationPlots[i]->fill(truthMuSeg, muSeg,
842 weight); // if no reco muon segment is found a protection inside
843 // MuonSegmentValidationPlots will ensure, its plots won't be filled
844 }
845 }
846 }
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuonSegment
const xAOD::MuonSegment * findRecoMuonSegment(const xAOD::MuonSegment *truthMuSeg)
Definition MuonPhysValMonitoringTool.cxx:1308
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 44 of file MuonPhysValMonitoringTool.cxx.

44 {
45 ATH_MSG_INFO("Initializing " << name() << "...");
46 ATH_CHECK(ManagedMonitorToolBase::initialize());
47
48 for (unsigned int i = 0; i < m_selectHLTMuonItems.size(); i++) {
49 if (m_selectHLTMuonItems[i][0] == "" || m_selectHLTMuonItems[i][1] == "") continue;
50 m_muonItems.emplace_back(m_selectHLTMuonItems[i][0]);
51 m_L1Seed.emplace_back(m_selectHLTMuonItems[i][1]);
52 }
53
54 // setup flags
55 if (m_doTrigMuonValidation == false) {
56 m_doTrigMuonL1Validation = false;
57 m_doTrigMuonL2Validation = false;
58 m_doTrigMuonEFValidation = false;
59 }
60 ATH_CHECK(m_trigDec.retrieve(DisableTool{!m_doTrigMuonValidation}));
61
62 ATH_CHECK(m_eventInfo.initialize());
63 ATH_CHECK(m_muonSelectionTool.retrieve());
64 ATH_CHECK(m_trackSelector.retrieve());
65 ATH_CHECK(m_isoTool.retrieve());
66
67 ATH_CHECK(m_tracksName.initialize());
68 ATH_CHECK(m_fwdtracksName.initialize(!m_fwdtracksName.empty()));
69 ATH_CHECK(m_muonsName.initialize());
70 ATH_CHECK(m_slowMuonsName.initialize(!m_slowMuonsName.empty()));
71
72 ATH_CHECK(m_muonTracksName.initialize());
73 ATH_CHECK(m_muonExtrapolatedTracksName.initialize());
74 ATH_CHECK(m_muonMSOnlyExtrapolatedTracksName.initialize());
75
76 ATH_CHECK(m_muonSegmentsName.initialize());
77 ATH_CHECK(m_muonsTruthName.initialize(!m_isData));
78 ATH_CHECK(m_muonSegmentsTruthName.initialize(!m_isData));
79 ATH_CHECK(m_muonL1TrigName.initialize(m_doTrigMuonL1Validation));
80 ATH_CHECK(m_muonL2SAName.initialize(m_doTrigMuonL2Validation));
81 ATH_CHECK(m_muonL2CBName.initialize(m_doTrigMuonL2Validation));
82 ATH_CHECK(m_muonEFCombTrigName.initialize(m_doTrigMuonEFValidation));
83
84 if (!m_isData) {
85 const std::vector<std::string> truthDecors{"truthOrigin", "truthType", "truthParticleLink"};
86 const std::vector<std::string> keys{m_tracksName.key(), m_fwdtracksName.key(), m_muonsName.key(),
87 m_slowMuonsName.key(), m_muonTracksName.key(), m_muonExtrapolatedTracksName.key(),
88 m_muonMSOnlyExtrapolatedTracksName.key()};
89 for (const std::string& key : keys) {
90 if (key.empty()) continue;
91 for (const std::string& decor : truthDecors){
92 m_decorDep.emplace_back(std::format("{:}.{:}", key , decor));
93 }
94 }
95 const std::vector<std::string> truthPartDecors{"MuonEntryLayer_px", "nprecLayers",
96 "truthOrigin", "truthType"};
97
98 for (const std::string& decor: truthPartDecors) {
99 m_decorDep.emplace_back(m_muonsTruthName, decor);
100 }
101
102
103
104 }
105
106 ATH_CHECK(m_decorDep.initialize());
107 return StatusCode::SUCCESS;
108 }
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:179

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

1144 {
1145 int k_L2CBMu_MinDeltaR = -1;
1146 float MinDeltaR = 0.;
1147 ATH_MSG_DEBUG(" m_vL2CBMuons.size()" << m_vL2CBMuons.size());
1148 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1149 ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1150 << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1151 }
1152 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1153 if ((m_vRecoMuons.at(i)->author() != xAOD::Muon::Author::MuidCo) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1154 ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1155 << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1156 k_L2CBMu_MinDeltaR = -1;
1157 MinDeltaR = 1000;
1158 ATH_MSG_DEBUG("==============>>>> k_L2CBMu_MinDeltaR=" << k_L2CBMu_MinDeltaR << " MinDeltaR" << MinDeltaR);
1159 for (unsigned int k = 0; k < m_vL2CBMuons.size(); k++) {
1160 ATH_MSG_DEBUG(" :::::::: TEST: L2CB pt=" << m_vL2CBMuons.at(k)->pt() << " eta=" << m_vL2CBMuons.at(k)->eta()
1161 << " phi=" << m_vL2CBMuons.at(k)->phi()
1162 << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)));
1163 if ((deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)) < 0.1 &&
1164 (deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)) < MinDeltaR))) {
1165 k_L2CBMu_MinDeltaR = k;
1166 MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k));
1167 ATH_MSG_DEBUG("==============>>>> taken!!!! k_L2CBMu_MinDeltaR=" << k_L2CBMu_MinDeltaR << " MinDeltaR"
1168 << MinDeltaR);
1169 }
1170 }
1171 if (k_L2CBMu_MinDeltaR == -1) continue;
1172 for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1173 if (m_selectMuonCategories[c] == ALL) {
1174 m_TriggerMuonValidationPlots[c]->fill(*m_vL2CBMuons.at(k_L2CBMu_MinDeltaR), *m_vRecoMuons.at(i));
1175 }
1176 }
1177 }
1178 }

◆ L2SATriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2SATriggerResolution ( )
private

Definition at line 1097 of file MuonPhysValMonitoringTool.cxx.

1097 {
1098 int k_L2SAMu_MinDeltaR = -1;
1099 float MinDeltaR = 0.;
1100 ATH_MSG_DEBUG(" m_vL2SAMuons.size()" << m_vL2SAMuons.size());
1101 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1102 ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1103 << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1104 }
1105 for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1106 if ((m_vRecoMuons.at(i)->author() != xAOD::Muon::Author::MuidCo) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1107 ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1108 << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1109 k_L2SAMu_MinDeltaR = -1;
1110 MinDeltaR = 1000;
1111 ATH_MSG_DEBUG("==============>>>> k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << " MinDeltaR" << MinDeltaR);
1112 for (unsigned int k = 0; k < m_vL2SAMuons.size(); k++) {
1113 ATH_MSG_DEBUG(" :::::::: TEST: L2SA pt=" << m_vL2SAMuons.at(k)->pt() << " eta=" << m_vL2SAMuons.at(k)->eta()
1114 << " phi=" << m_vL2SAMuons.at(k)->phi()
1115 << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)));
1116 if ((deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < 0.1 &&
1117 (deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < MinDeltaR))) {
1118 k_L2SAMu_MinDeltaR = k;
1119 MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k));
1120 ATH_MSG_DEBUG("==============>>>> taken!!!! k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << " MinDeltaR"
1121 << MinDeltaR);
1122 }
1123 }
1124 if (k_L2SAMu_MinDeltaR == -1) continue;
1125 for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1126 if (m_selectMuonCategories[c] == ALL) {
1127 m_TriggerMuonValidationPlots[c]->fill(*m_vL2SAMuons.at(k_L2SAMu_MinDeltaR), *m_vRecoMuons.at(i));
1128 }
1129 }
1130 }
1131 }

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

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

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

1634 {
1635 if (prt->pt() < 2000.) return false;
1636 if (std::abs(prt->eta()) > 2.7) return false;
1637 return true;
1638 }
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 1240 of file MuonPhysValMonitoringTool.cxx.

1240 {
1241 const xAOD::TrackParticle* tp = mu->trackParticle(xAOD::Muon::TrackParticleType::Primary);
1242 static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1243 TruthLink truthLink;
1244 if (tp) {
1245 truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
1246 }
1247 ATH_MSG_DEBUG("Muon: pt " << mu->pt() << " eta " << mu->eta() << " link " << truthLink.isValid());
1248 }

◆ printTruthMuonDebug()

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

Definition at line 1277 of file MuonPhysValMonitoringTool.cxx.

1277 {
1278 ATH_MSG_DEBUG("Truth muon: " << truthMu->pt() << " eta " << truthMu->eta());
1279 if (!mu) return;
1280 ATH_MSG_DEBUG("Reco muon: " << mu->pt() << " eta " << mu->eta());
1281 }
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 1283 of file MuonPhysValMonitoringTool.cxx.

1283 {
1284 ATH_MSG_INFO("Finalising hists " << name() << "...");
1285 for (const auto& plots : m_muonValidationPlots) plots->finalize();
1286 for (const auto& plots : m_TriggerMuonValidationPlots) plots->finalize();
1287 if (!m_isData) {
1288 m_oUnmatchedRecoMuonPlots->finalize();
1289 m_oUnmatchedTruthMuonPlots->finalize();
1290 }
1291
1292 for (const auto& plots : m_muonMSTrackValidationPlots) plots->finalize();
1293 for (const auto& plots : m_muonMETrackValidationPlots) plots->finalize();
1294 for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) plots->finalize();
1295 for (const auto& plots : m_muonIDTrackValidationPlots) plots->finalize();
1296 for (const auto& plots : m_muonIDSelectedTrackValidationPlots) plots->finalize();
1297 for (const auto& plots : m_muonIDForwardTrackValidationPlots) plots->finalize();
1298 if (!m_isData)
1299 if (m_oUnmatchedRecoMuonTrackPlots) m_oUnmatchedRecoMuonTrackPlots->finalize();
1300
1301 for (const auto& plots : m_muonSegmentValidationPlots) plots->finalize();
1302 if (!m_isData)
1303 if (m_oUnmatchedRecoMuonSegmentPlots) m_oUnmatchedRecoMuonSegmentPlots->finalize();
1304
1305 return StatusCode::SUCCESS;
1306 }//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 }

◆ 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 >, and AthCheckedComponent<::AthAlgTool >.

◆ 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 165 of file MuonPhysValMonitoringTool.h.

165{this, "DoBinnedResolutionPlots", true};

◆ m_doTrigMuonEFValidation

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

Definition at line 169 of file MuonPhysValMonitoringTool.h.

169{this, "DoTrigMuonEFValidation", false};

◆ m_doTrigMuonL1Validation

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

Definition at line 167 of file MuonPhysValMonitoringTool.h.

167{this, "DoTrigMuonL1Validation", false};

◆ m_doTrigMuonL2Validation

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

Definition at line 168 of file MuonPhysValMonitoringTool.h.

168{this, "DoTrigMuonL2Validation", false};

◆ m_doTrigMuonValidation

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

Definition at line 166 of file MuonPhysValMonitoringTool.h.

166{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 172 of file MuonPhysValMonitoringTool.h.

172{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 205 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_authors

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

Definition at line 207 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_category

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

Definition at line 206 of file MuonPhysValMonitoringTool.h.

206{nullptr};

◆ m_h_overview_Z_mass

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

Definition at line 209 of file MuonPhysValMonitoringTool.h.

209{nullptr};

◆ m_h_overview_Z_mass_ID

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

Definition at line 211 of file MuonPhysValMonitoringTool.h.

211{nullptr};

◆ m_h_overview_Z_mass_ME

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

Definition at line 210 of file MuonPhysValMonitoringTool.h.

210{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 170 of file MuonPhysValMonitoringTool.h.

170{this, "IsData", false};

◆ m_isoTool

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

Definition at line 179 of file MuonPhysValMonitoringTool.h.

179{this, "IsoTool", ""};

◆ m_L1MuonItems

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

Definition at line 159 of file MuonPhysValMonitoringTool.h.

159{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 195 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDSelectedTrackValidationPlots

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

Definition at line 194 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDTrackValidationPlots

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

Definition at line 193 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 191 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 192 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSTrackValidationPlots

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

Definition at line 190 of file MuonPhysValMonitoringTool.h.

◆ m_muonPrinter

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

Definition at line 176 of file MuonPhysValMonitoringTool.h.

176{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 196 of file MuonPhysValMonitoringTool.h.

◆ m_muonSelectionTool

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

Definition at line 175 of file MuonPhysValMonitoringTool.h.

175{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 188 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 197 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonSegmentPlots

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

Definition at line 200 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonTrackPlots

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

Definition at line 199 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedTruthMuonPlots

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

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

158{this, "SelectHLTMuonItems", {}};

◆ m_selectMuonAuthors

Gaudi::Property<std::set<int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonAuthors
private
Initial value:
{
this,
"SelectMuonAuthors",
{ static_cast<int>(Author::MuidCo),
static_cast<int>(Author::MuTagIMO),
static_cast<int>(Author::MuidSA),
static_cast<int>(Author::MuGirl),
static_cast<int>(Author::CaloTag),
static_cast<int>(Author::CaloScore)}}

Definition at line 149 of file MuonPhysValMonitoringTool.h.

149 {
150 this,
151 "SelectMuonAuthors",
152 { static_cast<int>(Author::MuidCo),
153 static_cast<int>(Author::MuTagIMO),
154 static_cast<int>(Author::MuidSA),
155 static_cast<int>(Author::MuGirl),
156 static_cast<int>(Author::CaloTag),
157 static_cast<int>(Author::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 160 of file MuonPhysValMonitoringTool.h.

160 {
161 this,
162 "SelectMuonCategories",
163 {MUCATEGORY::ALL, MUCATEGORY::PROMPT, MUCATEGORY::INFLIGHT, MUCATEGORY::NONISO, MUCATEGORY::REST}};

◆ m_selectMuonCategoriesStr

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

Definition at line 181 of file MuonPhysValMonitoringTool.h.

◆ m_selectMuonWPs

Gaudi::Property<std::set<int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonWPs
private
Initial value:
{
this, "SelectMuonWorkingPoints", {static_cast<int>(Quality::Loose),
static_cast<int>(Quality::Medium),
static_cast<int>(Quality::Tight)}}

Definition at line 144 of file MuonPhysValMonitoringTool.h.

144 {
145 this, "SelectMuonWorkingPoints", {static_cast<int>(Quality::Loose),
146 static_cast<int>(Quality::Medium),
147 static_cast<int>(Quality::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 202 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 178 of file MuonPhysValMonitoringTool.h.

178{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 177 of file MuonPhysValMonitoringTool.h.

177{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 189 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 221 of file MuonPhysValMonitoringTool.h.

◆ m_vEFMuonsSelected

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

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

◆ m_vL2CBMuonsSelected

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

Definition at line 226 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuons

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

Definition at line 223 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuonsSelected

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

Definition at line 224 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuons

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

Definition at line 214 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonSegments

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

Definition at line 217 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonTracks

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

Definition at line 216 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedSlowMuons

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

Definition at line 215 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedTruthMuons

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

Definition at line 213 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons

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

Definition at line 227 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen

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

Definition at line 230 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_CB

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

Definition at line 228 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_MS

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

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

◆ m_vZmumuMETracks

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

Definition at line 219 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMuons

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

Definition at line 220 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