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 the interval over which a particular monitoring object is filled (i.e., interval over which the method Fill(...) is called). 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.
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 Interval_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 733 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 376 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 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 61 of file ManagedMonitorToolBase.h.

61 { file = 0, eventsBlock, lumiBlock,
62 lowStat, medStat, higStat,
63 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 75 of file ManagedMonitorToolBase.h.

75{ 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:45
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:1239
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 1179 of file ManagedMonitorToolBase.cxx.

1181{
1182 if( m_newEventsBlock ) { }
1183 if( m_newLumiBlock ) { }
1184 if( m_newRun ) { }
1185
1186 return StatusCode::SUCCESS;
1187}

◆ bookHists()

StatusCode ManagedMonitorToolBase::bookHists ( )
virtualinherited

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

Implements IMonitorToolBase.

Definition at line 646 of file ManagedMonitorToolBase.cxx.

648{
649 // The Run/LumiBlock numbers are not set when beginRun() is called. Therefore,
650 // book histograms on the first call to fillHists(), which is called from execute().
651 return StatusCode::SUCCESS;
652}

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

1563{
1564 // Histograms will be checked using the data-quality monitoring framework (DQMF)
1565
1566 return StatusCode::SUCCESS;
1567}

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

1517{
1518 return m_THistSvc->deReg( g );
1519}
ManagedMonitorToolBase::m_THistSvc
ServiceHandle< ITHistSvc > m_THistSvc
Definition ManagedMonitorToolBase.h:750

◆ deregHist()

StatusCode ManagedMonitorToolBase::deregHist ( TH1 * h)
virtualinherited

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

Definition at line 1507 of file ManagedMonitorToolBase.cxx.

1509{
1510 return m_THistSvc->deReg( h );
1511}

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

1535{
1536 std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
1537 return m_THistSvc->deReg( streamName );
1538}
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:438

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

1526{
1527 MonGroup group( this, system, interval );
1528 return deregObject( objName, group );
1529}
ManagedMonitorToolBase::MonGroup
A container of information describing a monitoring object.
Definition ManagedMonitorToolBase.h:82
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:1524
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:43
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 721 of file ManagedMonitorToolBase.h.

721{ return m_endOfEventsBlock; }

◆ endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 722 of file ManagedMonitorToolBase.h.

722{ return m_endOfLowStat; }

◆ endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 723 of file ManagedMonitorToolBase.h.

723{ return m_endOfLumiBlock; }

◆ endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const
inlineprotectedinherited

Definition at line 724 of file ManagedMonitorToolBase.h.

724{ 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:861
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
int mu
Definition CaloNoise_fillDB.py:173
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:281
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 656 of file ManagedMonitorToolBase.cxx.

658{
659
660 if (m_d->m_warnAboutMissingInitialize) {
661 m_d->m_warnAboutMissingInitialize = false;
662 msg(MSG::WARNING) << "ManagedMonitorToolBase::initialize() never called from reimplementation!" << endmsg;
663 }
664
665
666 bool isNewEventsBlock = ( m_procNEventsProp > 0 && ((m_nEvents % m_procNEventsProp) == 1) && m_haveClearedLastEventBlock );
667 if (isNewEventsBlock) m_haveClearedLastEventBlock = false;
668
669 m_newLowStat = false;
670 m_newLumiBlock = false;
671 m_newRun = false;
672
673 m_newLowStatInterval = false;
674 m_newMedStatInterval = false;
675 m_newHigStatInterval = false;
676
677 m_useTrigger = ( (m_triggerChainProp != "" || m_triggerGroupProp != "") && (!m_trigDecTool.empty()) );
678
679 if( m_manager != 0 ) {
680 m_newLumiBlock = ( (m_lastLumiBlock != m_manager->lumiBlockNumber()) || m_manager->forkedProcess());
681 m_newRun = ( m_lastRun != m_manager->runNumber() );
682
683 if(m_newRun) {
684 m_newLumiBlock = true;
685 isNewEventsBlock = true;
686 }
687
688 m_newEventsBlock = isNewEventsBlock;
689
690 if( m_newLumiBlock ) {
691 // check if a new LB interval has started
692 // lowest lumiBlockNumber() is 1
693 // m_lastLowStatInterval is -1 initially
694 int currentLB = m_manager->lumiBlockNumber();
695 int LBsLowStat = m_manager->getLBsLowStat();
696 int LBsMedStat = m_manager->getLBsMedStat();
697 int LBsHigStat = m_manager->getLBsHigStat();
698
699 if( LBsLowStat*LBsMedStat*LBsHigStat == 0) {
700 msg(MSG::WARNING) << "zero LBs requested for interval" << endmsg;
701 }
702 else {
703 if( ((currentLB-1)/LBsLowStat) != m_lastLowStatInterval ) m_newLowStatInterval = true;
704 if( ((currentLB-1)/LBsMedStat) != m_lastMedStatInterval ) m_newMedStatInterval = true;
705 if( ((currentLB-1)/LBsHigStat) != m_lastHigStatInterval ) m_newHigStatInterval = true;
706 }
707 }
708
709 // Allow inheriting classes the option of using the lastLumiBloc/lastRun values
710 // before updating them
711 }
712
713
714 StatusCode sc0( StatusCode::SUCCESS );
715 StatusCode sc1( StatusCode::SUCCESS );
716 StatusCode sc2( StatusCode::SUCCESS );
717 StatusCode sc3( StatusCode::SUCCESS );
718
719 // Set end of LowStat, LumiBlock and Run variables
720 // These are needed to be used in procHistograms().
721 m_endOfEventsBlock = m_newEventsBlock;
722 m_endOfLowStat = m_newLowStatInterval;
723 m_endOfLumiBlock = m_newLumiBlock;
724 m_endOfRun = m_newRun;
725
726 // just duplicates m_newLowStatInterval
727 m_newLowStat = m_newLowStatInterval;
728
729 if( m_newEventsBlock || m_newLumiBlock || m_newRun ) {
730 ATH_MSG_DEBUG("Interval transition processing");
731 // Process histograms from the previous lumiBlock/run
732 if( m_nEvents != 1 ) {
733 m_d->benchPreProcHistograms();
734 sc0 = procHistograms();
735 m_d->benchPostProcHistograms();
736 }
737 // Re-book new histograms
738 m_d->benchPreBookHistograms();
739
740 if (!m_bookHistogramsInitial) {
741 sc1 = bookHistograms();
742 m_bookHistogramsInitial = true;
743 } else {
744 std::vector<Interval_t> intervals_to_process;
745 if (m_newEventsBlock) intervals_to_process.push_back(eventsBlock);
746 if (m_newLumiBlock) intervals_to_process.push_back(lumiBlock);
747 if (m_newLowStatInterval) intervals_to_process.push_back(lowStat);
748 if (m_newRun) intervals_to_process.push_back(run);
749 for (const auto interval: intervals_to_process) {
750 sc1 = regManagedHistograms(m_templateHistograms[interval]);
751 sc1 = regManagedGraphs(m_templateGraphs[interval]);
752 sc1 = regManagedTrees(m_templateTrees[interval]);
753 }
754 }
755 for (const auto& interval: std::vector<Interval_t>{ eventsBlock, lumiBlock, lowStat, run }) {
756 for (const auto& it: m_templateHistograms[interval]) {
757 // is histogram too small in x axis for LB range?
758 if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
759 //ATH_MSG_WARNING("We are rebinning for " << it.m_templateHist->GetName());
760 while ( it.m_templateHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
761 it.m_templateHist->LabelsInflate("X");
762 }
763 }
764 }
765 for (auto& it: m_templateEfficiencies[interval]) {
766 if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
767 // get the underlying passed and total TH1's from the TEfficiency
768 TH1* passedHist = it.m_templateHist->GetCopyPassedHisto();
769 TH1* totalHist = it.m_templateHist->GetCopyTotalHisto();
770 // inflate them until they exceed the lumi-block number
771 while (passedHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
772 passedHist->LabelsInflate("X");
773 totalHist->LabelsInflate("X");
774 }
775 // Replace them in the TEfficiency. First one has force ("f") option, since the
776 // histograms will not be consistent. This is corrected in the next line, so we
777 // do check for consistency then.
778 it.m_templateHist->SetPassedHistogram(*passedHist, "f");
779 it.m_templateHist->SetTotalHistogram(*totalHist, " ");
780 delete passedHist; // not owned by THistSvc, so need to be deleted.
781 delete totalHist;
782 }
783 }
784 }
785
786 if (auto streamname = dynamic_cast<OfflineStream*>(streamNameFunction())) {
787 streamname->updateRunLB();
788 }
789
790 sc3 = bookHistogramsRecurrent( );
791
792 m_d->benchPostBookHistograms();
793
794 }//end if new RUN/LB/Block
795
796 // check filters
797 bool filterresult(true);
798 if (! m_DQFilterTools.empty()) {
799 ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
800 for (; filterresult && (ifilter != filterend);
801 ++ifilter) {
802 filterresult = (filterresult && (*ifilter)->accept(ctx));
803 }
804 }
805
806
807 // ...and fill as normal
808 if(filterresult &&
809 (!m_useTrigger
810 || (m_vTrigChainNames.size()>0 && trigChainsArePassed(m_vTrigChainNames))
811 || (m_vTrigGroupNames.size()>0 && trigChainsArePassed(m_vTrigGroupNames))) ) {
812 ATH_MSG_DEBUG("Passed trigger, presumably");
813 m_d->benchPreFillHistograms();
814 fillHistograms(ctx).ignore();
815 m_haveClearedLastEventBlock = true;
816 m_d->benchPostFillHistograms();
817 ++m_nEvents;
818 } else { ATH_MSG_DEBUG("Failed trigger, presumably"); }
819
820 ++m_nEventsIgnoreTrigger;
821 if( m_newLumiBlock && (m_nEventsIgnoreTrigger != 1) ) {
822 ++m_nLumiBlocks;
823 }
824 if( m_manager != 0 ) {
825 m_lastRun = m_manager->runNumber();
826 if( m_newLumiBlock ) {
827 m_lastLumiBlock = m_manager->lumiBlockNumber();
828
829 int LBsLowStat = m_manager->getLBsLowStat();
830 int LBsMedStat = m_manager->getLBsMedStat();
831 int LBsHigStat = m_manager->getLBsHigStat();
832 if( LBsLowStat*LBsMedStat*LBsHigStat > 0) {
833 if( m_newLowStatInterval ) m_lastLowStatInterval = (m_lastLumiBlock-1)/LBsLowStat;
834 if( m_newMedStatInterval ) m_lastMedStatInterval = (m_lastLumiBlock-1)/LBsMedStat;
835 if( m_newHigStatInterval ) m_lastHigStatInterval = (m_lastLumiBlock-1)/LBsHigStat;
836 }
837 }
838 }
839
840 return StatusCode::SUCCESS;
841}
endmsg
#define endmsg
Definition AnalysisConfig_Ntuple.cxx:54
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:1099
ManagedMonitorToolBase::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Definition ManagedMonitorToolBase.h:756
ManagedMonitorToolBase::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx)
An inheriting class should either override this function or fillHists().
Definition ManagedMonitorToolBase.cxx:1200
ManagedMonitorToolBase::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition ManagedMonitorToolBase.cxx:1180
ManagedMonitorToolBase::m_vTrigGroupNames
std::vector< std::string > m_vTrigGroupNames
Definition ManagedMonitorToolBase.h:608
ManagedMonitorToolBase::m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
Definition ManagedMonitorToolBase.h:592
ManagedMonitorToolBase::m_trigDecTool
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool
Definition ManagedMonitorToolBase.h:752
ManagedMonitorToolBase::regManagedGraphs
StatusCode regManagedGraphs(std::vector< MgmtParams< TGraph > > &templateGraphs)
Definition ManagedMonitorToolBase.cxx:968
ManagedMonitorToolBase::m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
Definition ManagedMonitorToolBase.h:596
ManagedMonitorToolBase::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition ManagedMonitorToolBase.cxx:1192
ManagedMonitorToolBase::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Definition ManagedMonitorToolBase.h:608
ManagedMonitorToolBase::m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
Definition ManagedMonitorToolBase.h:600
ManagedMonitorToolBase::m_templateEfficiencies
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
Definition ManagedMonitorToolBase.h:604
ManagedMonitorToolBase::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition ManagedMonitorToolBase.cxx:1208
ManagedMonitorToolBase::regManagedHistograms
StatusCode regManagedHistograms(std::vector< MgmtParams< TH1 > > &templateHistograms)
Definition ManagedMonitorToolBase.cxx:871
ManagedMonitorToolBase::trigChainsArePassed
virtual bool trigChainsArePassed(std::vector< std::string > &)
Definition ManagedMonitorToolBase.cxx:1967
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 1153 of file ManagedMonitorToolBase.cxx.

1155{
1156
1157 // This assumes that the end of a file will naturally end a run, which is not always true.
1158 // A merging application run afterwards should be able to put parts of a run together.
1159 if( m_nEvents != 1 ) {
1160 m_d->benchPreProcHistograms();
1161
1162 // Set end flags for the LowStat, LumiBlock and Run variables.
1163 // This is needed to be used in the procHistograms method below.
1164 m_endOfEventsBlock = true;
1165 m_endOfLowStat = true;
1166 m_endOfLumiBlock = true;
1167 m_endOfRun = true;
1168
1169 StatusCode sc = procHistograms();
1170
1171 m_d->benchPostProcHistograms();
1172 return sc;
1173 }
1174 return StatusCode::SUCCESS;
1175}
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 620 of file ManagedMonitorToolBase.h.

620 {
621 return m_nEvents;
622 }

◆ get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const
inlineprotectedinherited

Definition at line 624 of file ManagedMonitorToolBase.h.

624 {
625 return m_procNEventsProp;
626 }

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

1312{
1313 std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1314 return m_THistSvc->getHist( streamName, h );
1315}

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

1303{
1304 MonGroup group( this, system, interval );
1305 return getHist( h, hName, group );
1306}
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:1301

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

1331{
1332 std::string streamName = streamNameFunction()->getStreamName( this, group, hName );
1333 return m_THistSvc->getHist( streamName, h );
1334}

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

1322{
1323 MonGroup group( this, system, interval );
1324 return getHist( h, hName, group );
1325}

◆ 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:46
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 2029 of file ManagedMonitorToolBase.cxx.

2031{
2032 StreamNameFcn* fcn(0);
2033
2034 switch( m_environment ) {
2035 case AthenaMonManager::noOutput:
2036 fcn = new NoOutputStream();
2037 break;
2038 case AthenaMonManager::online:
2039 fcn = new OnlineStream();
2040 break;
2041 case AthenaMonManager::user:
2042 fcn = new DefaultStream( m_fileKey );
2043 break;
2044 case AthenaMonManager::tier0:
2045 case AthenaMonManager::tier0Raw:
2046 case AthenaMonManager::tier0ESD:
2047 case AthenaMonManager::AOD:
2048 case AthenaMonManager::altprod:
2049 default:
2050 fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
2051 }
2052
2053 return fcn;
2054}
ManagedMonitorToolBase::StreamNameFcn
A function-object base class allowing the specific implementation of getStreamName to be decided at r...
Definition ManagedMonitorToolBase.h:268
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition ManagedMonitorToolBase.h:746
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition ManagedMonitorToolBase.h:745

◆ 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:47
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:46

◆ 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 Interval_t to a string of the same name.

Definition at line 452 of file ManagedMonitorToolBase.cxx.

454{
455 std::string str("file");
456
457 switch( interval ) {
458 case all:
459 str = "all";
460 break;
461 case fill:
462 str = "fill";
463 break;
464 case run:
465 str = "run";
466 break;
467 case lowStat:
468 str = "lowStat";
469 break;
470 case medStat:
471 str = "medStat";
472 break;
473 case higStat:
474 str = "higStat";
475 break;
476 case lumiBlock:
477 str = "lumiBlock";
478 break;
479 case eventsBlock:
480 str = "eventsBlock";
481 break;
482 case file:
483 str = "file";
484 break;
485 default:
486 str = "unknown";
487 }
488
489 return str;
490}

◆ intervalStringToEnum()

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

Converts a string to the corresponding Interval_t.

Definition at line 494 of file ManagedMonitorToolBase.cxx.

496{
497 std::string lcstr( strToLower(str) );
498
499 if( lcstr == "all" )
500 return all;
501 else if( lcstr == "fill" )
502 return fill;
503 else if( lcstr == "run" )
504 return run;
505 else if( lcstr == "lowStat" )
506 return lowStat;
507 else if( lcstr == "medStat" )
508 return medStat;
509 else if( lcstr == "higStat" )
510 return higStat;
511 else if( lcstr == "lumiBlock" )
512 return lumiBlock;
513 else if( lcstr == "eventsBlock" )
514 return eventsBlock;
515 else if( lcstr == "file" )
516 return file;
517
518 if( Imp::s_svcLocator ) {
519 SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
520 if( ms.isValid() ) {
521 MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
522 log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
523 << str << "\", returning \"file\"" << endmsg;
524 }
525 }
526
527 return file;
528}
ManagedMonitorToolBase::Imp::s_svcLocator
static std::atomic< ISvcLocator * > s_svcLocator
Definition ManagedMonitorToolBase.cxx:37

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

1585{
1586 if (!m_lumiDataKey.empty()) {
1587 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1588 return lumi->lbAverageInteractionsPerCrossing();
1589 } else {
1590 ATH_MSG_DEBUG("Warning: lbAverageInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1591 return -1.0;
1592 }
1593 // not reached
1594}
ManagedMonitorToolBase::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition ManagedMonitorToolBase.h:794

◆ lbAverageLivefraction()

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

Average luminosity livefraction.

Definition at line 1648 of file ManagedMonitorToolBase.cxx.

1650{
1651 if (m_environment == AthenaMonManager::online)
1652 return 1.0;
1653
1654 if (!m_trigLiveFractionDataKey.empty()) {
1655 SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
1656 return live->lbAverageLiveFraction();
1657 } else {
1658 ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
1659 return -1.0;
1660 }
1661 // not reached
1662}
ManagedMonitorToolBase::m_trigLiveFractionDataKey
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey
Definition ManagedMonitorToolBase.h:798

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

1619{
1620 if (!m_lumiDataKey.empty()) {
1621 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1622 return lumi->lbAverageLuminosity();
1623 } else {
1624 ATH_MSG_DEBUG("Warning: lbAverageLuminosity() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1625 return -1.0;
1626 }
1627 // not reached
1628}

◆ lbDuration()

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

Luminosity block time (in seconds).

Definition at line 1699 of file ManagedMonitorToolBase.cxx.

1701{
1702 if ( m_environment == AthenaMonManager::online ) {
1703 return m_defaultLBDuration;
1704 }
1705 if (!m_lbDurationDataKey.empty()) {
1706 SG::ReadCondHandle<LBDurationCondData> dur (m_lbDurationDataKey, ctx);
1707 return dur->lbDuration();
1708 } else {
1709 ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1710 return m_defaultLBDuration;
1711 }
1712 // not reached
1713}
ManagedMonitorToolBase::m_lbDurationDataKey
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey
Definition ManagedMonitorToolBase.h:796

◆ lbInteractionsPerCrossing()

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

Instantaneous number of interactions, i.e.

mu

Definition at line 1598 of file ManagedMonitorToolBase.cxx.

1600{
1601 if (!m_lumiDataKey.empty()) {
1602 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1603 float muToLumi = lumi->muToLumi();
1604 if (muToLumi > 0) {
1605 return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id()) / muToLumi;
1606 }
1607 return 0;
1608 } else {
1609 ATH_MSG_DEBUG("Warning: lbInteractionsPerCrossing() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1610 return -1.0;
1611 }
1612 // not reached
1613}

◆ lbLuminosityPerBCID()

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

Instantaneous luminosity.

Definition at line 1632 of file ManagedMonitorToolBase.cxx.

1634{
1635 if (!m_lumiDataKey.empty()) {
1636 SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
1637 return lumi->lbLuminosityPerBCIDVector().at (ctx.eventID().bunch_crossing_id());
1638 } else {
1639 ATH_MSG_DEBUG("Warning: lbLuminosityPerBCID() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1640 return -1.0;
1641 }
1642 // not reached
1643}

◆ lbLumiWeight()

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

Average Integrated Luminosity Live Fraction.

Definition at line 1684 of file ManagedMonitorToolBase.cxx.

1686{
1687 if (!m_lumiDataKey.empty()) {
1688 return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
1689 } else{
1690 ATH_MSG_DEBUG("Warning: lbLumiWeight() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1691 return -1.0;
1692 }
1693 // not reached
1694}
ManagedMonitorToolBase::lbDuration
virtual double lbDuration(const EventContext &ctx) const
Luminosity block time (in seconds).
Definition ManagedMonitorToolBase.cxx:1700
ManagedMonitorToolBase::lbAverageLivefraction
virtual float lbAverageLivefraction(const EventContext &ctx) const
Average luminosity livefraction.
Definition ManagedMonitorToolBase.cxx:1649
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:1618

◆ livefractionPerBCID()

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

Livefraction per bunch crossing ID.

Definition at line 1666 of file ManagedMonitorToolBase.cxx.

1668{
1669 if (m_environment == AthenaMonManager::online)
1670 return 1.0;
1671
1672 if (!m_trigLiveFractionDataKey.empty()) {
1673 SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
1674 return live->l1LiveFractionVector().at (ctx.eventID().bunch_crossing_id());
1675 } else {
1676 ATH_MSG_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
1677 return -1.0;
1678 }
1679 // not reached
1680}

◆ ManagedMonitorToolBase()

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

Constructor with parameters:

Definition at line 316 of file ManagedMonitorToolBase.cxx.

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

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

720{ return m_newEventsBlock; }

◆ newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 716 of file ManagedMonitorToolBase.h.

716{ return m_newHigStatInterval; }

◆ newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 717 of file ManagedMonitorToolBase.h.

717{ 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 714 of file ManagedMonitorToolBase.h.

714{ return m_newLowStatInterval; }

◆ newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 718 of file ManagedMonitorToolBase.h.

718{ return m_newLumiBlock; }

◆ newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 715 of file ManagedMonitorToolBase.h.

715{ return m_newMedStatInterval; }

◆ newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const
inlineprotectedinherited

Definition at line 719 of file ManagedMonitorToolBase.h.

719{ 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 1985 of file ManagedMonitorToolBase.cxx.

1986 {
1987 std::string item;
1988 std::stringstream ss(line);
1989
1990 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
1991
1992 while ( std::getline(ss, item, ',') ) {
1993 std::stringstream iss(item); // remove
1994 iss >> item; // whitespace
1995 if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
1996 result.push_back(item);
1997 }
1998
1999 msg(MSG::DEBUG) << endmsg;
2000 return StatusCode::SUCCESS;
2001}
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 1571 of file ManagedMonitorToolBase.cxx.

1573{
1574 if( m_preScaleProp > 1 ) {
1575 return ( (m_nEvents % m_preScaleProp) == 1 );
1576 }
1577 return true;
1578}

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

1337 {
1338 if (!e)
1339 return StatusCode::FAILURE;
1340
1341 TGraph* g = reinterpret_cast<TGraph*>(e);
1342 std::string name = e->GetName();
1343
1344 // MANAGED
1345 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1346 // warn about not using merge algorithms
1347 if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1348 ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
1349 }
1350 // add the efficiency to rebooking vector
1351 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1352 m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
1353 } else {
1354 ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
1355 return StatusCode::FAILURE;
1356 }
1357
1358 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1359 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1360 registerMetadata(streamName, name, group).ignore();
1361 return m_THistSvc->regGraph( streamName, g );
1362 } else {
1363 // UNMANAGED
1364 if( m_manager != 0 ) {
1365 std::string genericName = NoOutputStream().getStreamName( this, group, name );
1366 m_manager->writeAndDelete( genericName );
1367 m_manager->passOwnership( e, genericName );
1368 }
1369
1370 std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
1371 StatusCode smd = registerMetadata(streamName, name, group);
1372 if (smd != StatusCode::SUCCESS)
1373 return StatusCode::FAILURE;
1374
1375 return m_THistSvc->regGraph( streamName, g );
1376 }
1377}
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:1815
ManagedMonitorToolBase::registerMetadata
StatusCode registerMetadata(const std::string &streamName, const std::string &hName, const MonGroup &group)
Definition ManagedMonitorToolBase.cxx:845
ManagedMonitorToolBase::intervalEnumToString
static std::string intervalEnumToString(Interval_t interval)
Converts a Interval_t to a string of the same name.
Definition ManagedMonitorToolBase.cxx:453

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

1393{
1394 if (!g)
1395 return StatusCode::FAILURE;
1396
1397 // This part of the code deals with MANAGED type
1398 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1399 // Create an unmanaged group based on the original MonGroup instance passed
1400 // This is needed because managed graph is presented as a number of unmanaged
1401 // graphs (one per each interval)
1402 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1403
1404 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1405 m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
1406 } else {
1407 ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1408 return StatusCode::FAILURE;
1409 }
1410
1411 std::string name = g->GetName();
1412 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1413 registerMetadata(streamName, name, group).ignore();
1414 return m_THistSvc->regGraph( streamName, g );
1415 }
1416
1417 // This part of the code deals with UNMANAGED type
1418 std::string gName = g->GetName();
1419
1420 if( m_manager != 0 ) {
1421 std::string genericName = NoOutputStream().getStreamName( this, group, gName );
1422 m_manager->writeAndDelete( genericName );
1423 m_manager->passOwnership( g, genericName );
1424 }
1425
1426 std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1427
1428 StatusCode smd = registerMetadata(streamName, gName, group);
1429 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1430
1431 return m_THistSvc->regGraph( streamName, g );
1432}

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

1384{
1385 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1386 return regGraph( g, group );
1387}
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:1382

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

1249{
1250 if (!h)
1251 return StatusCode::FAILURE;
1252
1253 // This part of the code deals with MANAGED type
1254 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1255 /*
1256 Create an unmanaged group based on the original MonGroup instance passed
1257 It is needed because managed histogram is presented as a number of unmanaged
1258 histograms (one per each interval)
1259 Update (PUEO) - I don't think it actually matters, and need to keep
1260 track of "proper" attribute for X_VS_LB
1261 */
1262
1263 if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
1264 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.");
1265 }
1266
1267 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1268 m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
1269 } else {
1270 ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1271 return StatusCode::FAILURE;
1272 }
1273
1274 std::string hName = h->GetName();
1275 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1276 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
1277 registerMetadata(streamName, hName, group).ignore();
1278 return m_THistSvc->regHist( streamName, h );
1279 }
1280
1281 // This part of the code deals with UNMANAGED type
1282 std::string hName = h->GetName();
1283
1284 if( m_manager != 0 ) {
1285 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1286 m_manager->writeAndDelete( genericName );
1287 m_manager->passOwnership( h, genericName );
1288 }
1289
1290 std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
1291
1292 StatusCode smd = registerMetadata(streamName, hName, group);
1293 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1294
1295 return m_THistSvc->regHist( streamName, h );
1296}

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

1241{
1242 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1243 return regHist( h, group );
1244}

◆ registerMetadata()

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

Definition at line 844 of file ManagedMonitorToolBase.cxx.

846 {
847 if( m_environment != AthenaMonManager::online ) {
848 TTree* metadata(0);
849 std::string mdStreamName( streamName );
850 size_t found=mdStreamName.rfind('/');
851
852 if ( found != std::string::npos )
853 mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
854
855 MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
856 if( i == m_metadataMap.end() ) {
857 metadata = new TTree( "metadata", "Monitoring Metadata" );
858 if (! metadata) return StatusCode::FAILURE;
859 StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
860 if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
861 i = m_metadataMap.emplace( mdStreamName, new OutputMetadata(metadata) ).first;
862 }
863
864 i->second->fill( hName, group.interval(), group.chain(), group.merge() );
865 }
866 return StatusCode::SUCCESS;
867}
LCE_postprocessing.found
bool found
Definition LCE_postprocessing.py:46

◆ regManagedEfficiencies()

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

Definition at line 1038 of file ManagedMonitorToolBase.cxx.

1038 {
1039 bool allIsOk = true;
1040 for( auto& it : templateEfficiencies ) {
1041 // get components of MgmtParams and copy efficiency
1042 MonGroup group = it.m_group;
1043 TEfficiency* theEfficiency = it.m_templateHist;
1044 TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
1045 int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
1046 int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
1047 int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
1048 e->SetBins(nbins,xlow,xhigh); // reset histogram
1049 std::string name = e->GetName();
1050
1051 // make TGraph casts of TEfficiencies
1052 TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
1053 TGraph* g = reinterpret_cast<TGraph*>(e);
1054
1055 // Get the streamName for the previous interval
1056 std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1057
1058 // RE-REGISTER
1059 // 1) De-register the original graph with the THistSvc
1060 StatusCode sc1 = m_THistSvc->deReg( theGraph );
1061 if (sc1 == StatusCode::FAILURE) allIsOk = false;
1062 // 2) Fix THistSvc->deReg for TGraphs
1063 bool doneCleaning = false;
1064 std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
1065 TSeqCollection *filelist=gROOT->GetListOfFiles();
1066 for (int i=0; i<filelist->GetEntries(); i++) {
1067 ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1068 TFile* file = static_cast<TFile*>(filelist->At(i));
1069 StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1070 if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
1071 }
1072 // 3) Check if TGraph fix has been applied successfully
1073 if (!doneCleaning) {
1074 ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1075 allIsOk = false;
1076 }
1077 // 4) Register cloned histogram under previous interval streamName
1078 StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1079 if (sc3 == StatusCode::FAILURE)
1080 allIsOk = false;
1081
1082 // get streamname for interval
1083 streamName = streamNameFunction()->getStreamName( this, group, name, false );
1084 // store metadata
1085 StatusCode smd = registerMetadata(streamName, name, group);
1086 if (smd != StatusCode::SUCCESS) allIsOk = false;
1087 // Re-register the original graph
1088 StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1089 if (sc4 == StatusCode::FAILURE) allIsOk = false;
1090 }
1091
1092 if (!allIsOk) return StatusCode::FAILURE;
1093 return StatusCode::SUCCESS;
1094}
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:936
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 967 of file ManagedMonitorToolBase.cxx.

969{
970 // See the description for the regManagedHistograms method
971 bool allIsOk = true;
972
973 for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
974 MonGroup group = (*it).m_group;
975
976 // Get a handle to the graph
977 TGraph* theGraph = (*it).m_templateHist;
978
979 // Clone the graph
980 TGraph* g = static_cast<TGraph*>(theGraph->Clone());
981 theGraph->Set(0); // equivalent to Reset() for TH1
982
983 // Get name
984 std::string gName = g->GetName();
985
986 // Get the streamName for the previous interval
987 std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
988
989 // De-register the original graph with the THistSvc
990 StatusCode sc1 = m_THistSvc->deReg( theGraph );
991 if (sc1 == StatusCode::FAILURE)
992 allIsOk = false;
993
994 // *** begin ***
995 // Fix THistSvc->deReg for TGraphs
996 bool doneCleaning = false;
997 std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
998 TSeqCollection *filelist=gROOT->GetListOfFiles();
999 for (int i=0; i<filelist->GetEntries(); i++) {
1000 ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
1001 TFile* file = static_cast<TFile*>(filelist->At(i));
1002 StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
1003 if (sc2 == StatusCode::SUCCESS)
1004 doneCleaning = true;
1005 }
1006
1007 // Check if TGraph fix has been applied successfully
1008 if (!doneCleaning) {
1009 ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
1010 allIsOk = false;
1011 }
1012 // *** end ***
1013
1014 // Register clonned histogram under previous interval streamName
1015 StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
1016 if (sc3 == StatusCode::FAILURE)
1017 allIsOk = false;
1018
1019 // Get streamName for the current interval
1020 streamName = streamNameFunction()->getStreamName( this, group, gName, false );
1021 // Register metadata information with the current interval streamname
1022 StatusCode smd = registerMetadata(streamName, gName, group);
1023 if (smd != StatusCode::SUCCESS)
1024 allIsOk = false;
1025
1026 // Re-register the original graph with the current interval streamName
1027 StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
1028 if (sc4 == StatusCode::FAILURE)
1029 allIsOk = false;
1030
1031 }
1032
1033 if (!allIsOk) return StatusCode::FAILURE;
1034
1035 return StatusCode::SUCCESS;
1036}

◆ regManagedHistograms()

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

Definition at line 870 of file ManagedMonitorToolBase.cxx.

872{
873 // The method registers histograms with the THistSvc and saves them to file.
874
875 // The funky business with registering and deregistering the histogram is needed
876 // to get the correct directory when saving histograms. THistSvc deals with ROOT
877 // to set up proper TDirectory, so we rely on it.
878 // E.g.
879 // m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
880 // m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
881 // at the end of execution
882 // use passownership of the histogram and save it to file
883 // m_manager->passOwnership( h, genericName );
884 // m_manager->writeAndDelete( genericName );
885 bool allIsOk = true;
886
887 for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
888 MonGroup& group = (*it).m_group;
889
890 // Get a handle to the histogram
891 TH1* theHist = (*it).m_templateHist;
892
893 // Clone the histogram
894 TH1* h = static_cast<TH1*>(theHist->Clone());
895 theHist->Reset();
896
897 // Get name
898 std::string hName = h->GetName();
899
900 // Get the streamName for the previous interval
901 std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
902
903 // Register the histogram with the THistSvc
904 StatusCode sc1 = m_THistSvc->deReg( theHist );
905 if (sc1 == StatusCode::FAILURE) allIsOk = false;
906
907 // Register clonned histogram under previous interval streamName
908 StatusCode sc2 = m_THistSvc->regHist( streamName, h );
909 if (sc2 == StatusCode::FAILURE) allIsOk = false;
910
911 if( m_manager != 0 ) {
912 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
913 m_manager->passOwnership( h, genericName );
914 m_manager->writeAndDelete( genericName );
915 }
916
917 // Get streamName for the current interval
918 streamName = streamNameFunction()->getStreamName( this, group, hName, false );
919 // Register metadata information with the current interval streamname
920 StatusCode smd = registerMetadata(streamName, hName, group);
921 if (smd != StatusCode::SUCCESS) allIsOk = false;
922
923 // Re-register the original histogram with the current interval streamName
924 StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
925 if (sc3 == StatusCode::FAILURE) allIsOk = false;
926
927 }
928
929 if (!allIsOk) return StatusCode::FAILURE;
930
931 return StatusCode::SUCCESS;
932}

◆ regManagedTrees()

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

Definition at line 1098 of file ManagedMonitorToolBase.cxx.

1100{
1101 // See the description for the regManagedHistograms method
1102 bool allIsOk = true;
1103
1104 for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
1105 MonGroup group = (*it).m_group;
1106
1107 // Get a handle to the original tree
1108 TTree* theTree = (*it).m_templateHist;
1109
1110 // Clone the tree
1111 TTree* t = static_cast<TTree*>(theTree->Clone());
1112 theTree->Reset();
1113
1114 // Dumping the tree
1115 std::string name = t->GetName();
1116
1117 // Get the streamName for the previous interval
1118 std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
1119
1120 // De-register original tree with the THistSvc
1121 StatusCode sc1 = m_THistSvc->deReg( theTree );
1122 if (sc1 == StatusCode::FAILURE) allIsOk = false;
1123
1124 // Register clonned tree under previous interval streamName
1125 StatusCode sc2 = m_THistSvc->regTree( streamName, t );
1126 if (sc2 == StatusCode::FAILURE) allIsOk = false;
1127
1128 if( m_manager != 0 ) {
1129 std::string genericName = NoOutputStream().getStreamName( this, group, name );
1130 m_manager->passOwnership( t, genericName );
1131 m_manager->writeAndDelete( genericName );
1132 }
1133
1134 // Get streamName for the current interval
1135 streamName = streamNameFunction()->getStreamName( this, group, name, false );
1136 // Register metadata information with the current interval streamname
1137 StatusCode smd = registerMetadata(streamName, name, group);
1138 if (smd != StatusCode::SUCCESS) allIsOk = false;
1139
1140 // Re-register the original graph with the current interval streamName
1141 StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
1142 if (sc3 == StatusCode::FAILURE) allIsOk = false;
1143
1144 }
1145
1146 if (!allIsOk) return StatusCode::FAILURE;
1147
1148 return StatusCode::SUCCESS;
1149}
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 1446 of file ManagedMonitorToolBase.cxx.

1448{
1449
1450 // This part of the code deals with MANAGED type
1451 if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
1452 // Create an unmanaged group based on the original MonGroup instance passed
1453 // This is needed because managed tree is presented as a number of unmanaged
1454 // trees (one per each interval)
1455 MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
1456
1457 if (m_supportedIntervalsForRebooking.count(group.interval())) {
1458 m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
1459 } else {
1460 ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
1461 return StatusCode::FAILURE;
1462 }
1463
1464 std::string name = t->GetName();
1465 std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
1466 std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
1467 registerMetadata(streamName, name, group).ignore();
1468 return m_THistSvc->regTree( streamName, t );
1469 }
1470
1471
1472 // This part of the code deals with UNMANAGED type
1473 std::string tName = t->GetName();
1474
1475 if( m_manager != 0 ) {
1476 std::string genericName = NoOutputStream().getStreamName( this, group, tName );
1477 m_manager->writeAndDelete( genericName );
1478 m_manager->passOwnership( t, genericName );
1479 }
1480
1481 std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
1482
1483 StatusCode smd = registerMetadata(streamName, tName, group);
1484 if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
1485
1486 return m_THistSvc->regTree( streamName, t );
1487}

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

1439{
1440 MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1441 return regTree( t, group );
1442}

◆ 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 368 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 352 of file AthCommonDataStore.h.

352 {
353 handlesArray.renounce();
354 }

◆ runStat()

StatusCode ManagedMonitorToolBase::runStat ( )
virtualinherited

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

Implements IMonitorToolBase.

Definition at line 1553 of file ManagedMonitorToolBase.cxx.

1555{
1556 return StatusCode::SUCCESS;
1557}

◆ setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager * manager)
virtualinherited

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

Definition at line 1220 of file ManagedMonitorToolBase.cxx.

1222{
1223 ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
1224 m_manager = manager;
1225 if( m_manager != 0 ) {
1226 ATH_MSG_DEBUG( " --> Setting manager");
1227 m_managerNameProp = m_manager->name();
1228 m_fileKey = m_manager->fileKey();
1229 m_dataType = m_manager->dataType();
1230 m_environment = m_manager->environment();
1231 delete m_streamNameFcn;
1232 m_streamNameFcn = getNewStreamNameFcn();
1233 }
1234 ATH_MSG_DEBUG( " --> Exiting successfully");
1235}
ManagedMonitorToolBase::getNewStreamNameFcn
virtual StreamNameFcn * getNewStreamNameFcn() const
Definition ManagedMonitorToolBase.cxx:2030

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

1544{
1545 // All instances should write to the stream(s) defined by the
1546 // AthenaMonManager.
1547
1548 return StatusCode::SUCCESS;
1549}

◆ streamNameFunction()

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

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

Definition at line 437 of file ManagedMonitorToolBase.cxx.

439{
440 if( m_streamNameFcn == 0 ) {
441 msg(MSG::ERROR) << "!! streamNameFunction() has not been initialized !!" << endmsg;
442 msg(MSG::ERROR) << " --> neither ManagedMonitorToolBase::initialize() nor" << endmsg;
443 msg(MSG::ERROR) << " --> ManagedMonitorToolBase::setMonManager() has been called." << endmsg;
444 msg(MSG::ERROR) << " --> Correct configuration cannot be guaranteed from this point." << endmsg;
445 m_streamNameFcn = getNewStreamNameFcn();
446 }
447 return m_streamNameFcn;
448}

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

937{
938 // THistSvc employs TDirectory Append method when registering TGraph.
939 // When deReg is used to de-register TGraph object, THistSvc only removes the object
940 // from its internal management but forgets to delete from TDirectory.
941 // The current method fixes this problem by removing the TGraph object manually
942 // after THistSvc->deReg(TGraph* obj) is called.
943
944 // Saves and restores gFile and gDirectory
945 GlobalDirectoryRestore restore;
946
947 // This check is true when TGraph object is removed successfully
948 bool graphRemoved = false;
949
950 file->cd("/");
951 TDirectory* dir = file->GetDirectory(directoryName.c_str());
952 if (dir != 0) {
953 dir->cd();
954 TObject* obj = dir->Remove(theGraph);
955 if (obj != 0)
956 graphRemoved = true;
957 }
958
959 if (!graphRemoved) {
960 return StatusCode::FAILURE;
961 }
962
963 return StatusCode::SUCCESS;
964}

◆ trigChainsArePassed()

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

Definition at line 1966 of file ManagedMonitorToolBase.cxx.

1968{
1969 ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
1970
1971 for(unsigned int i=0; i<vTrigNames.size(); i++) {
1972 if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
1973 ATH_MSG_DEBUG( " + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
1974 return true;
1975 }
1976 else {
1977 ATH_MSG_DEBUG( " - \"" << vTrigNames[i] << "\" did not pass");
1978 }
1979 }
1980
1981 return false;
1982}

◆ updateTriggersForGroups()

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

Definition at line 2004 of file ManagedMonitorToolBase.cxx.

2005 {
2006 for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
2007 std::string& thisName = vTrigChainNames[i];
2008 if (thisName.compare(0, 9, "CATEGORY_") ==0) {
2009 ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
2010 std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
2011 std::ostringstream oss;
2012 oss << "(";
2013 for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
2014 if (itrig != 0) {
2015 oss << "|";
2016 }
2017 oss << triggers[itrig];
2018 }
2019 oss << ")";
2020 // replace with new value
2021 std::string newval = oss.str();
2022 ATH_MSG_DEBUG("Replaced with " << newval);
2023 vTrigChainNames[i] = std::move(newval);
2024 }
2025 }
2026}
ManagedMonitorToolBase::m_trigTranslator
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator
Definition ManagedMonitorToolBase.h:754

◆ updateVHKA()

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

Definition at line 298 of file AthCommonDataStore.h.

298 {
299 for (auto &a : m_vhka) {
300 std::vector<SG::VarHandleKey*> keys = a->keys();
301 for (auto k : keys) {
302 k->setOwner(this);
303 }
304 }
305 }
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition AthCommonDataStore.h:386

◆ writeAndDelete()

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

Write out histogram and delete it.

Definition at line 1491 of file ManagedMonitorToolBase.cxx.

1492 {
1493 if (!h)
1494 return StatusCode::FAILURE;
1495
1496 std::string hName = h->GetName();
1497
1498 if( m_manager != 0 ) {
1499 std::string genericName = NoOutputStream().getStreamName( this, group, hName );
1500 m_manager->writeAndDelete( genericName );
1501 }
1502 return StatusCode::SUCCESS;
1503}

Member Data Documentation

◆ m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial
privateinherited

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

◆ m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType
protectedinherited

Definition at line 745 of file ManagedMonitorToolBase.h.

◆ m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr
protectedinherited

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

◆ m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel
protectedinherited

Definition at line 743 of file ManagedMonitorToolBase.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

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

756{this,"FilterTools",{}};

◆ m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock
privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

◆ m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat
privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

◆ m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock
privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

◆ m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun
privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

◆ m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment
protectedinherited

Definition at line 746 of file ManagedMonitorToolBase.h.

◆ m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr
protectedinherited

Definition at line 742 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 378 of file AthCommonDataStore.h.

◆ m_fileKey

std::string ManagedMonitorToolBase::m_fileKey
protectedinherited

Definition at line 740 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 773 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 768 of file ManagedMonitorToolBase.h.

◆ m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval
protectedinherited

Definition at line 768 of file ManagedMonitorToolBase.h.

◆ m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock
protectedinherited

Definition at line 766 of file ManagedMonitorToolBase.h.

◆ m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval
protectedinherited

Definition at line 768 of file ManagedMonitorToolBase.h.

◆ m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun
protectedinherited

Definition at line 767 of file ManagedMonitorToolBase.h.

◆ m_lbDurationDataKey

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

Definition at line 795 of file ManagedMonitorToolBase.h.

796{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 793 of file ManagedMonitorToolBase.h.

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

◆ m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager
protectedinherited

Definition at line 736 of file ManagedMonitorToolBase.h.

◆ m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp
protectedinherited

Definition at line 738 of file ManagedMonitorToolBase.h.

◆ m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap
protectedinherited

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

◆ m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger
protectedinherited

Definition at line 771 of file ManagedMonitorToolBase.h.

◆ m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock
privateinherited

Definition at line 729 of file ManagedMonitorToolBase.h.

◆ m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval
privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

◆ m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat
privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

◆ m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval
privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

◆ m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock
privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

◆ m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval
privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

◆ m_newRun

bool ManagedMonitorToolBase::m_newRun
privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

◆ m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks
protectedinherited

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

◆ m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp
protectedinherited

Definition at line 760 of file ManagedMonitorToolBase.h.

◆ m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp
protectedinherited

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

◆ m_supportedIntervalsForRebooking

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

Definition at line 803 of file ManagedMonitorToolBase.h.

◆ m_templateEfficiencies

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

Definition at line 604 of file ManagedMonitorToolBase.h.

◆ m_templateGraphs

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

Definition at line 596 of file ManagedMonitorToolBase.h.

◆ m_templateHistograms

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

Definition at line 592 of file ManagedMonitorToolBase.h.

◆ m_templateTrees

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

Definition at line 600 of file ManagedMonitorToolBase.h.

◆ m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc
protectedinherited

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

752{this, "TrigDecisionTool",""};

◆ m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp
protectedinherited

Definition at line 761 of file ManagedMonitorToolBase.h.

◆ m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp
protectedinherited

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

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

◆ m_trigTranslator

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

Definition at line 754 of file ManagedMonitorToolBase.h.

754{this,"TriggerTranslatorTool",""};

◆ m_useLumi

bool ManagedMonitorToolBase::m_useLumi
privateinherited

Definition at line 801 of file ManagedMonitorToolBase.h.

◆ m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger
protectedinherited

Definition at line 764 of file ManagedMonitorToolBase.h.

◆ m_varHandleArraysDeclared

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

Definition at line 387 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 386 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 608 of file ManagedMonitorToolBase.h.

◆ m_vTrigGroupNames

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

Definition at line 608 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.17.0