Loading [MathJax]/jax/input/TeX/config.js
ATLAS Offline Software
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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:
Collaboration diagram for MuonPhysValMonitoring::MuonPhysValMonitoringTool:

Public Types

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

Public Member Functions

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

Static Public Member Functions

static std::string intervalEnumToString (Interval_t interval)
 Converts a LevelOfDetail_t to a string of the same name. More...
 
static Interval_t intervalStringToEnum (const std::string &str)
 Converts a string to the corresponding Interval_t. More...
 
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. More...
 
unsigned int get_nEvents () const
 
long get_procNEventsProp () const
 
virtual bool trigChainsArePassed (std::vector< std::string > &)
 
virtual StreamNameFcngetNewStreamNameFcn () 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. More...
 
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 More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

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
 
AthenaMonManagerm_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
 
StreamNameFcnm_streamNameFcn
 
ServiceHandle< ITHistSvc > m_THistSvc
 
PublicToolHandle< Trig::ITrigDecisionToolm_trigDecTool {this, "TrigDecisionTool",""}
 
PublicToolHandle< ITriggerTranslatorToolm_trigTranslator {this,"TriggerTranslatorTool",""}
 
ToolHandleArray< IDQFilterToolm_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
}
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_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 handleMuonTrees (const xAOD::EventInfo *eventInfo, bool isData)
 
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::MuonfindRecoMuon (const xAOD::TruthParticle *truthMu)
 
const xAOD::SlowMuonfindRecoSlowMuon (const xAOD::TruthParticle *truthMu)
 
const xAOD::MuonSegmentfindRecoMuonSegment (const xAOD::MuonSegment *truthMuSeg)
 
std::unique_ptr< xAOD::MuongetCorrectedMuon (const xAOD::Muon &mu)
 
TH1F * findHistogram (const std::vector< HistData > &hists, const std::string &hnameTag, const std::string &hdirTag, const std::string &hNewName)
 
void modifyHistogram (TH1 *hist)
 
MuonPhysValMonitoringTool::MUCATEGORY getMuonSegmentTruthCategory (const xAOD::MuonSegment *truthMuSeg, const xAOD::TruthParticleContainer *muonTruthContainer)
 
MuonPhysValMonitoringTool::MUCATEGORY getMuonTruthCategory (const xAOD::IParticle *prt)
 
bool passesAcceptanceCuts (const xAOD::IParticle *prt)
 
void SplitString (TString x, const TString &delim, std::vector< TString > &v)
 
template<class T >
const T * getContainer (const std::string &containerName)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

const xAOD::TrackParticleContainerm_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}
 
Gaudi::Property< std::string > m_tracksName {this, "TrackContainerName", "InDetTrackParticles"}
 
Gaudi::Property< std::string > m_fwdtracksName {this, "FwdTrackContainerName", ""}
 
Gaudi::Property< std::string > m_muonsName {this, "MuonContainerName", "Muons"}
 
Gaudi::Property< std::string > m_slowMuonsName {this, "SlowMuonContainerName", "SlowMuons"}
 
Gaudi::Property< std::string > m_muonsTruthName {this, "MuonTruthParticleContainerName", "MuonTruthParticles"}
 
Gaudi::Property< std::string > m_muonTracksName {this, "MuonTrackContainerName", "MuonSpectrometerTrackParticles"}
 
Gaudi::Property< std::string > m_muonExtrapolatedTracksName
 
Gaudi::Property< std::string > m_muonMSOnlyExtrapolatedTracksName
 
Gaudi::Property< std::string > m_muonSegmentsName {this, "MuonSegmentContainerName", "MuonSegments"}
 
Gaudi::Property< std::string > m_muonSegmentsTruthName {this, "MuonTruthSegmentContainerName", "MuonTruthSegments"}
 
Gaudi::Property< std::string > m_muonL1TrigName {this, "L1TrigMuonContainerName", "LVL1MuonRoIs"}
 
Gaudi::Property< std::string > m_muonL2SAName {this, "L2SAMuonContainerName", "HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo"}
 
Gaudi::Property< std::string > m_muonL2CBName {this, "L2CBMuonContainerName", "HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfo"}
 
Gaudi::Property< std::string > m_muonEFCombTrigName {this, "EFCombTrigMuonContainerName", "HLT_xAOD__MuonContainer_MuonEFInfo"}
 
Gaudi::Property< std::vector< int > > m_selectMuonWPs
 
Gaudi::Property< std::vector< unsigned int > > m_selectMuonAuthors
 
Gaudi::Property< bool > m_selectComissioning {this, "SelectComissioningMuons", false}
 Flag to tell whether muons with the comissioning author will be selected or not. More...
 
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_doMuonTree {this, "DoMuonTree", false}
 
Gaudi::Property< bool > m_isData {this, "IsData", false}
 
SG::ReadHandleKey< xAOD::EventInfom_eventInfo {this, "EventInfo", "EventInfo", "event info"}
 
ToolHandle< CP::IMuonSelectionToolm_muonSelectionTool {this, "MuonSelector", "CP::MuonSelectionTool/MuonSelectionTool"}
 
ToolHandle< Rec::IMuonPrintingToolm_muonPrinter {this, "MuonPrinter", "Rec::MuonPrintingTool/MuonPrintingTool"}
 
ToolHandle< Trig::TrigDecisionToolm_trigDec {this, "TrigDecTool", "Trig::TrigDecisionTool/TrigDecisionTool"}
 
ToolHandle< Trk::ITrackSelectorToolm_trackSelector {this, "TrackSelector", "InDet::InDetDetailedTrackSelectorTool/MuonCombinedInDetDetailedTrackSelectorTool"}
 
ToolHandle< CP::IIsolationSelectionToolm_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::RecoMuonPlotOrganizerm_oUnmatchedRecoMuonPlots
 
std::unique_ptr< Muon::TruthMuonPlotOrganizerm_oUnmatchedTruthMuonPlots
 
std::unique_ptr< Muon::RecoMuonTrackPlotOrganizerm_oUnmatchedRecoMuonTrackPlots
 
std::unique_ptr< Muon::MuonSegmentPlotsm_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< LuminosityCondDatam_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondDatam_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondDatam_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
 
bool m_bookHistogramsInitial
 
bool m_useLumi
 
float m_defaultLBDuration
 
std::set< Interval_tm_supportedIntervalsForRebooking
 
Impm_d
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 57 of file MuonPhysValMonitoringTool.h.

Member Typedef Documentation

◆ MDMap_t

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

Definition at line 826 of file ManagedMonitorToolBase.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ Interval_t

An enumeration describing how detailed a particular monitoring object is.

summary: used to summarize the state of the system

runstat: same as summary

shift: used to flag potential problems

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

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

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

Enumerator
file 
eventsBlock 
lumiBlock 
lowStat 
medStat 
higStat 
run 
fill 
all 

Definition at line 113 of file ManagedMonitorToolBase.h.

113  { file = 0, eventsBlock, lumiBlock,
115  run, fill, all };

◆ MgmtAttr_t

An enumeration describing how the class handles the histogram.

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

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

Enumerator
ATTRIB_MANAGED 
ATTRIB_UNMANAGED 
ATTRIB_X_VS_LB 

Definition at line 130 of file ManagedMonitorToolBase.h.

◆ MUCATEGORY

Enumerator
ALL 
PROMPT 
INFLIGHT 
NONISO 
REST 

Definition at line 80 of file MuonPhysValMonitoringTool.h.

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

Constructor & Destructor Documentation

◆ MuonPhysValMonitoringTool()

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

Constructor with parameters:

Definition at line 66 of file MuonPhysValMonitoringTool.cxx.

66  :
68  m_counterBits(),
69  m_muonItems(),
70  m_L1Seed() {
71  }

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

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

◆ bookHistogramsRecurrent()

StatusCode ManagedMonitorToolBase::bookHistogramsRecurrent ( )
virtualinherited

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

Reimplemented in MdtVsTgcRawDataValAlg, MdtVsRpcRawDataValAlg, and ManagedMonitorToolTest.

Definition at line 1286 of file ManagedMonitorToolBase.cxx.

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

◆ bookHists()

StatusCode ManagedMonitorToolBase::bookHists ( )
virtualinherited

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

Implements IMonitorToolBase.

Reimplemented in TileRawChannelMonTool, and TileDigitsMonTool.

Definition at line 730 of file ManagedMonitorToolBase.cxx.

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

◆ bookValidationPlots()

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

Definition at line 238 of file MuonPhysValMonitoringTool.cxx.

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

◆ 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 TileRawChannelMonTool, TileDigitsMonTool, TileCellNoiseMonTool, and CscCalibMonToolBase.

Definition at line 1671 of file ManagedMonitorToolBase.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph *  g)
virtualinherited

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

Definition at line 1625 of file ManagedMonitorToolBase.cxx.

1627 {
1628  return m_THistSvc->deReg( g );
1629 }

◆ deregHist()

StatusCode ManagedMonitorToolBase::deregHist ( TH1 *  h)
virtualinherited

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

Definition at line 1617 of file ManagedMonitorToolBase.cxx.

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

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

1645 {
1646  std::string streamName = streamNameFunction()->getStreamName( this, group, objName );
1647  return m_THistSvc->deReg( streamName );
1648 }

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

1636 {
1637  MonGroup group( this, system, interval );
1638  return deregObject( objName, group );
1639 }

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

1238  {
1239  int k_EFMu_MinDeltaR = -1;
1240  float MinDeltaR = 0.;
1241  std::vector<int> vAvailableAuthors;
1242  vAvailableAuthors.clear();
1243  vAvailableAuthors.emplace_back(m_vEFMuons[0]->author());
1244  unsigned int iter = 0;
1245  for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1246  iter = 0;
1247  for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1248  if (m_vEFMuons[k]->author() != vAvailableAuthors[l]) iter++;
1249  }
1250  if (iter == vAvailableAuthors.size()) vAvailableAuthors.emplace_back(m_vEFMuons[k]->author());
1251  }
1252  ATH_MSG_DEBUG(" m_vEFMuons.size()" << m_vEFMuons.size());
1253  for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1254  ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta() << " phi="
1255  << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1256  }
1257  for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
1258  if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
1259  ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << " eta=" << m_vRecoMuons.at(i)->eta()
1260  << " phi=" << m_vRecoMuons.at(i)->phi() << " auth=" << m_vRecoMuons.at(i)->author());
1261  for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
1262  k_EFMu_MinDeltaR = -1;
1263  MinDeltaR = 1000;
1264  for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
1265  ATH_MSG_DEBUG(" :::::::: TEST: EF pt=" << m_vEFMuons.at(k)->pt() << " eta=" << m_vEFMuons.at(k)->eta()
1266  << " phi=" << m_vEFMuons.at(k)->phi()
1267  << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k))
1268  << " author=" << m_vEFMuons.at(k)->author());
1269  if (m_vEFMuons.at(k)->author() == vAvailableAuthors.at(l) &&
1270  (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < 0.1 &&
1271  (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < MinDeltaR))) {
1272  k_EFMu_MinDeltaR = k;
1273  MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k));
1274  }
1275  }
1276  if (k_EFMu_MinDeltaR == -1) continue;
1277  for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
1278  if (m_selectMuonCategories[c] == ALL) {
1279  m_TriggerMuonValidationPlots[c]->fill(*m_vEFMuons.at(k_EFMu_MinDeltaR), *m_vRecoMuons.at(i));
1280  }
1281  }
1282  }
1283  }
1284  }

◆ endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 794 of file ManagedMonitorToolBase.h.

794 { return m_endOfEventsBlock; }

◆ endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 795 of file ManagedMonitorToolBase.h.

795 { return m_endOfLowStat; }

◆ endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 796 of file ManagedMonitorToolBase.h.

796 { return m_endOfLumiBlock; }

◆ endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const
inlineprotectedinherited

Definition at line 797 of file ManagedMonitorToolBase.h.

797 { return m_endOfRun; }

◆ evtStore() [1/2]

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; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ fillHistograms()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::fillHistograms ( )
overridevirtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 270 of file MuonPhysValMonitoringTool.cxx.

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

◆ fillHists()

StatusCode ManagedMonitorToolBase::fillHists ( )
virtualinherited

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

Implements IMonitorToolBase.

Reimplemented in TileRawChannelMonTool, and TileDigitsMonTool.

Definition at line 740 of file ManagedMonitorToolBase.cxx.

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

◆ finalHists()

StatusCode ManagedMonitorToolBase::finalHists ( )
virtualinherited

Calls procHists( true, true, true ).

Implements IMonitorToolBase.

Reimplemented in TileRawChannelMonTool, TileDigitsMonTool, and TileCellNoiseMonTool.

Definition at line 1256 of file ManagedMonitorToolBase.cxx.

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

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

1378  {
1379  TH1F* h = nullptr;
1380  for (const auto& hist : hists) {
1381  if (hist.second.find(hdirTag) != std::string::npos || hdirTag.empty()) {
1382  std::string histname = hist.first->GetName();
1383  if (histname.find(hnameTag) != std::string::npos) {
1384  h = (TH1F*)hist.first->Clone(hNewName.c_str());
1385  return h;
1386  }
1387  }
1388  }
1389  return h;
1390  }

◆ findRecoMuon()

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

Definition at line 1296 of file MuonPhysValMonitoringTool.cxx.

1296  {
1297  static const SG::ConstAccessor<MuonLink> acc_muon("recoMuonLink");
1298  if (!acc_muon.isAvailable(*truthMu)) return nullptr;
1299  MuonLink link = acc_muon(*truthMu);
1300  if (!link.isValid()) return nullptr;
1301  const xAOD::Muon* reco_mu = (*link);
1302  if (!m_selectComissioning && reco_mu->allAuthors() & comm_bit) return nullptr;
1303  m_vMatchedMuons.emplace_back(reco_mu);
1304  return reco_mu;
1305  }

◆ findRecoMuonSegment()

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

Definition at line 1362 of file MuonPhysValMonitoringTool.cxx.

1362  {
1363  static const SG::ConstAccessor<MuonSegmentLink> recoSegmentLinkAcc("recoSegmentLink");
1364  if (!recoSegmentLinkAcc.isAvailable(*truthMuSeg)) {
1365  ATH_MSG_DEBUG("recoSegmentLink not found");
1366  return nullptr;
1367  }
1368  MuonSegmentLink link = recoSegmentLinkAcc(*truthMuSeg);
1369  if (!link.isValid()) {
1370  ATH_MSG_DEBUG("recoSegmentLink not valid");
1371  return nullptr;
1372  }
1373  m_vMatchedMuonSegments.emplace_back(*link);
1374  return (*link);
1375  }

◆ findRecoSlowMuon()

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

Definition at line 1307 of file MuonPhysValMonitoringTool.cxx.

1307  {
1308  if (m_slowMuonsName.empty()) return nullptr;
1309 
1310  const xAOD::SlowMuonContainer* SlowMuons = nullptr;
1311  SlowMuons = getContainer<xAOD::SlowMuonContainer>(m_slowMuonsName);
1312  for (const auto smu : *SlowMuons) {
1313  const MuonLink muLink = smu->muonLink();
1314  if (!muLink.isValid()) continue;
1315  float DR = deltaR(*muLink , truthMu);
1316  if (DR < 0.005) {
1317  m_vMatchedSlowMuons.emplace_back(smu);
1318  return smu;
1319  }
1320  }
1321 
1322  return nullptr;
1323  }

◆ get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const
inlineprotectedinherited

Definition at line 692 of file ManagedMonitorToolBase.h.

692  {
693  return m_nEvents;
694  }

◆ get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const
inlineprotectedinherited

Definition at line 696 of file ManagedMonitorToolBase.h.

696  {
697  return m_procNEventsProp;
698  }

◆ getContainer()

template<class T >
const T * MuonPhysValMonitoring::MuonPhysValMonitoringTool::getContainer ( const std::string &  containerName)
private

Definition at line 223 of file MuonPhysValMonitoringTool.h.

223  {
224  const T* ptr = evtStore()->retrieve<const T>(containerName);
225  if (!ptr) { ATH_MSG_WARNING("Container '" << containerName << "' could not be retrieved"); }
226  return ptr;
227  }

◆ getCorrectedMuon()

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

Definition at line 1425 of file MuonPhysValMonitoringTool.cxx.

1425  {
1426  std::unique_ptr<xAOD::Muon> mu_c;
1427  if (mu.m() <= 0) return mu_c;
1428  mu_c = std::make_unique<xAOD::Muon>();
1429  mu_c->makePrivateStore(mu);
1430 
1431  // add decorations too fool the muon selector tool
1432  const xAOD::TrackParticle* idtrk{mu_c->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)};
1433  const xAOD::TrackParticle* metrk{mu_c->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)};
1434  if (idtrk && metrk) {
1435  const static SG::Decorator<float> InnerDetectorPtDec("InnerDetectorPt");
1436  const static SG::Decorator<float> MuonSpectrometerPtDec("MuonSpectrometerPt");
1437  InnerDetectorPtDec(*mu_c) = idtrk->pt();
1438  MuonSpectrometerPtDec(*mu_c) = metrk->pt();
1439  }
1440  m_muonSelectionTool->setQuality(*mu_c);
1441  m_muonSelectionTool->setPassesIDCuts(*mu_c);
1442  return mu_c;
1443  }

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

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

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

1412 {
1413  MonGroup group( this, system, interval );
1414  return getHist( h, hName, group );
1415 }

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

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

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

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

◆ getMuonSegmentTruthCategory()

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

Definition at line 1392 of file MuonPhysValMonitoringTool.cxx.

1393  {
1394  static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1395  TruthLink truthLink;
1396  if (truthParticleLinkAcc.isAvailable(*truthMuSeg)) {
1397  truthLink = truthParticleLinkAcc(*truthMuSeg);
1398  if (truthLink.isValid()) {
1399  const int theUniqueID = HepMC::uniqueID(*truthLink);
1400  if (std::abs((*truthLink)->pdgId()) != 13) return REST;
1401 
1402  for (const auto muTruthPart : *muonTruthContainer) {
1403  if ( HepMC::uniqueID(muTruthPart) == theUniqueID ) { return getMuonTruthCategory(muTruthPart); }
1404  }
1405  }
1406  } else
1407  ATH_MSG_WARNING("No truth link available for muon truth segment");
1408 
1409  return REST;
1410  }

◆ getMuonTruthCategory()

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

Definition at line 1412 of file MuonPhysValMonitoringTool.cxx.

1412  {
1413  static const SG::ConstAccessor<int> truthTypeAcc("truthType");
1414  static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
1415  int truthType = truthTypeAcc(*mu);
1416  if (truthType == 6)
1417  return PROMPT;
1418  else if (truthType == 8 && (truthOriginAcc(*mu) == 34 || truthOriginAcc(*mu) == 35))
1419  return INFLIGHT;
1420  else if (truthType == 7)
1421  return NONISO;
1422  return REST;
1423  }

◆ getNewStreamNameFcn()

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

Definition at line 2157 of file ManagedMonitorToolBase.cxx.

2159 {
2160  StreamNameFcn* fcn(0);
2161 
2162  switch( m_environment ) {
2164  fcn = new NoOutputStream();
2165  break;
2167  fcn = new OnlineStream();
2168  break;
2170  fcn = new DefaultStream( m_fileKey );
2171  break;
2175  case AthenaMonManager::AOD:
2177  default:
2178  fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
2179  }
2180 
2181  return fcn;
2182 }

◆ handleMuon()

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

Definition at line 890 of file MuonPhysValMonitoringTool.cxx.

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

◆ handleMuonL1Trigger()

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

Definition at line 1122 of file MuonPhysValMonitoringTool.cxx.

1122  {
1123  ATH_MSG_DEBUG("MuonRoI L1 Trigger: ptThr " << TrigL1mu->thrValue() << " phi " << TrigL1mu->phi() << " eta " << TrigL1mu->eta());
1124  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1125  if (m_selectMuonCategories[i] == ALL) {
1126  m_TriggerMuonValidationPlots[i]->fill(*TrigL1mu);
1127  break;
1128  }
1129  }
1130  }

◆ handleMuonL2Trigger() [1/2]

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL2Trigger ( const xAOD::L2CombinedMuon L2CBMu)
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(*L2CBMu);
1184  break;
1185  }
1186  }
1187  ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2CB Trigger : pt " << L2CBMu->pt() << " phi " << L2CBMu->phi() << " eta "
1188  << L2CBMu->eta());
1189  }

◆ handleMuonL2Trigger() [2/2]

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

Definition at line 1132 of file MuonPhysValMonitoringTool.cxx.

1132  {
1133  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1134  if (m_selectMuonCategories[i] == ALL) {
1135  m_TriggerMuonValidationPlots[i]->fill(*L2SAMu);
1136  break;
1137  }
1138  }
1139  ATH_MSG_DEBUG(" ==> Geometrical selection of Muon L2SA Trigger : pt " << L2SAMu->pt() << " phi " << L2SAMu->phi() << " eta "
1140  << L2SAMu->eta() << " roiWord " << L2SAMu->roiWord()
1141  << " sAddress " << L2SAMu->sAddress());
1142  }

◆ handleMuonSegment()

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

Definition at line 874 of file MuonPhysValMonitoringTool.cxx.

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

◆ handleMuonTrack()

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

Definition at line 1021 of file MuonPhysValMonitoringTool.cxx.

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

◆ handleMuonTrees()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrees ( const xAOD::EventInfo eventInfo,
bool  isData 
)
private

Definition at line 1010 of file MuonPhysValMonitoringTool.cxx.

1010  {
1011  ATH_MSG_DEBUG("Filling MuonTree " << name() << "...");
1012 
1013  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1014  m_muonValidationPlots[i]->fillTree(eventInfo, isData);
1015 
1016  ATH_MSG_DEBUG("MuonTree is filled for muon category = " << m_selectMuonCategories[i] << " with event # "
1017  << eventInfo->eventNumber());
1018  }
1019  }

◆ handleMuonTrigger()

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

Definition at line 1227 of file MuonPhysValMonitoringTool.cxx.

1227  {
1228  for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
1229  if (m_selectMuonCategories[i] == ALL) {
1230  m_TriggerMuonValidationPlots[i]->fill(*EFMu);
1231  break;
1232  }
1233  }
1234  ATH_MSG_DEBUG("==> Geometrical selection of EF Trigger muons: pt " << EFMu->pt() << " phi " << EFMu->phi() << " eta " << EFMu->eta()
1235  << " author " << EFMu->author());
1236  }

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

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

◆ handleTruthMuonSegment()

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

Definition at line 858 of file MuonPhysValMonitoringTool.cxx.

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

◆ initialize()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::initialize ( )
overridevirtual

Reimplemented from ManagedMonitorToolBase.

Definition at line 75 of file MuonPhysValMonitoringTool.cxx.

75  {
76  ATH_MSG_INFO("Initializing " << name() << "...");
78 
80 
81  for (unsigned int i = 0; i < m_selectHLTMuonItems.size(); i++) {
82  if (m_selectHLTMuonItems[i][0] == "" || m_selectHLTMuonItems[i][1] == "") continue;
83  m_muonItems.emplace_back(m_selectHLTMuonItems[i][0]);
84  m_L1Seed.emplace_back(m_selectHLTMuonItems[i][1]);
85  }
86 
87  // setup flags
88  if (m_doTrigMuonValidation == false) {
92  }
93  ATH_CHECK(m_trigDec.retrieve(DisableTool{!m_doTrigMuonValidation}));
94 
96  ATH_CHECK(m_muonSelectionTool.retrieve());
97  ATH_CHECK(m_trackSelector.retrieve());
98  ATH_CHECK(m_isoTool.retrieve());
99 
100  return StatusCode::SUCCESS;
101  }

◆ 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()

static const InterfaceID& IMonitorToolBase::interfaceID ( )
inlinestaticinherited

Definition at line 29 of file IMonitorToolBase.h.

29 { return IID_IMonitorToolBase; }

◆ intervalEnumToString()

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

Converts a LevelOfDetail_t to a string of the same name.

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

Definition at line 536 of file ManagedMonitorToolBase.cxx.

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

◆ intervalStringToEnum()

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

Converts a string to the corresponding Interval_t.

Definition at line 578 of file ManagedMonitorToolBase.cxx.

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

◆ L2CBTriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2CBTriggerResolution ( )
private

Definition at line 1191 of file MuonPhysValMonitoringTool.cxx.

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

◆ L2SATriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2SATriggerResolution ( )
private

Definition at line 1144 of file MuonPhysValMonitoringTool.cxx.

1144  {
1145  int k_L2SAMu_MinDeltaR = -1;
1146  float MinDeltaR = 0.;
1147  ATH_MSG_DEBUG(" m_vL2SAMuons.size()" << m_vL2SAMuons.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() != 1) || (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_L2SAMu_MinDeltaR = -1;
1157  MinDeltaR = 1000;
1158  ATH_MSG_DEBUG("==============>>>> k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << " MinDeltaR" << MinDeltaR);
1159  for (unsigned int k = 0; k < m_vL2SAMuons.size(); k++) {
1160  ATH_MSG_DEBUG(" :::::::: TEST: L2SA pt=" << m_vL2SAMuons.at(k)->pt() << " eta=" << m_vL2SAMuons.at(k)->eta()
1161  << " phi=" << m_vL2SAMuons.at(k)->phi()
1162  << " DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)));
1163  if ((deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < 0.1 &&
1164  (deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < MinDeltaR))) {
1165  k_L2SAMu_MinDeltaR = k;
1166  MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k));
1167  ATH_MSG_DEBUG("==============>>>> taken!!!! k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << " MinDeltaR"
1168  << MinDeltaR);
1169  }
1170  }
1171  if (k_L2SAMu_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_vL2SAMuons.at(k_L2SAMu_MinDeltaR), *m_vRecoMuons.at(i));
1175  }
1176  }
1177  }
1178  }

◆ lbAverageInteractionsPerCrossing()

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

Average mu, i.e.

<mu>

Definition at line 1693 of file ManagedMonitorToolBase.cxx.

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

◆ lbAverageLivefraction()

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

Average luminosity livefraction.

Definition at line 1762 of file ManagedMonitorToolBase.cxx.

1764 {
1766  return 1.0;
1767 
1770  return live->lbAverageLiveFraction();
1771  } else {
1772  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
1773  ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
1774  return -1.0;
1775  }
1776  // not reached
1777 }

◆ lbAverageLuminosity()

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

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

Definition at line 1729 of file ManagedMonitorToolBase.cxx.

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

◆ lbDuration()

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

Luminosity block time (in seconds)

Definition at line 1816 of file ManagedMonitorToolBase.cxx.

1818 {
1820  return m_defaultLBDuration;
1821  }
1822  if (!m_lbDurationDataKey.empty()) {
1824  return dur->lbDuration();
1825  } else {
1826  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbDuration() can't work properly! ");
1827  ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1828  return m_defaultLBDuration;
1829  }
1830  // not reached
1831 }

◆ lbInteractionsPerCrossing()

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

Instantaneous number of interactions, i.e.

mu

Definition at line 1709 of file ManagedMonitorToolBase.cxx.

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

◆ lbLuminosityPerBCID()

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

Instantaneous luminosity.

Definition at line 1745 of file ManagedMonitorToolBase.cxx.

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

◆ lbLumiWeight()

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

Average Integrated Luminosity Live Fraction.

Definition at line 1800 of file ManagedMonitorToolBase.cxx.

1802 {
1803  if (!m_lumiDataKey.empty()) {
1804  return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
1805  } else{
1806  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbLumiWeight() can't work properly! ");
1807  ATH_MSG_DEBUG("Warning: lbLumiWeight() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
1808  return -1.0;
1809  }
1810  // not reached
1811 }

◆ livefractionPerBCID()

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

Livefraction per bunch crossing ID.

Definition at line 1781 of file ManagedMonitorToolBase.cxx.

1783 {
1785  return 1.0;
1786 
1789  return live->l1LiveFractionVector().at (ctx.eventID().bunch_crossing_id());
1790  } else {
1791  //ATH_MSG_FATAL("! Luminosity tool has been disabled ! livefractionPerBCID() can't work properly! ");
1792  ATH_MSG_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
1793  return -1.0;
1794  }
1795  // not reached
1796 }

◆ MMTB_DEPRECATED() [1/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfEventsBlock  )
inherited

◆ MMTB_DEPRECATED() [2/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLowStat  )
inherited

◆ MMTB_DEPRECATED() [3/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLumiBlock  )
inherited

◆ MMTB_DEPRECATED() [4/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfRun  )
inherited

◆ MMTB_DEPRECATED() [5/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newEventsBlock  )
inherited

◆ MMTB_DEPRECATED() [6/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newHigStatInterval  )
inherited

◆ MMTB_DEPRECATED() [7/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStat  )
inherited

◆ MMTB_DEPRECATED() [8/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStatInterval  )
inherited

◆ MMTB_DEPRECATED() [9/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLumiBlock  )
inherited

◆ MMTB_DEPRECATED() [10/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newMedStatInterval  )
inherited

◆ MMTB_DEPRECATED() [11/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newRun  )
inherited

◆ modifyHistogram()

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

Definition at line 1445 of file MuonPhysValMonitoringTool.cxx.

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

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ newEventsBlockFlag()

bool ManagedMonitorToolBase::newEventsBlockFlag ( ) const
inlineprotectedinherited

Definition at line 793 of file ManagedMonitorToolBase.h.

793 { return m_newEventsBlock; }

◆ newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 789 of file ManagedMonitorToolBase.h.

789 { return m_newHigStatInterval; }

◆ newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const
inlineprotectedinherited

Definition at line 790 of file ManagedMonitorToolBase.h.

790 { return m_newLowStat; }

◆ newLowStatIntervalFlag()

bool ManagedMonitorToolBase::newLowStatIntervalFlag ( ) const
inlineprotectedinherited

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

Definition at line 787 of file ManagedMonitorToolBase.h.

787 { return m_newLowStatInterval; }

◆ newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const
inlineprotectedinherited

Definition at line 791 of file ManagedMonitorToolBase.h.

791 { return m_newLumiBlock; }

◆ newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const
inlineprotectedinherited

Definition at line 788 of file ManagedMonitorToolBase.h.

788 { return m_newMedStatInterval; }

◆ newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const
inlineprotectedinherited

Definition at line 792 of file ManagedMonitorToolBase.h.

792 { return m_newRun; }

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ parseList()

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

Definition at line 2113 of file ManagedMonitorToolBase.cxx.

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

◆ passesAcceptanceCuts()

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

Definition at line 1690 of file MuonPhysValMonitoringTool.cxx.

1690  {
1691  if (prt->pt() < 2000.) return false;
1692  if (std::abs(prt->eta()) > 2.7) return false;
1693  return true;
1694  }

◆ preSelector()

bool ManagedMonitorToolBase::preSelector ( )
virtualinherited

Implements IMonitorToolBase.

Definition at line 1681 of file ManagedMonitorToolBase.cxx.

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

◆ printMuonDebug()

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

Definition at line 1286 of file MuonPhysValMonitoringTool.cxx.

1286  {
1287  const xAOD::TrackParticle* tp = mu->primaryTrackParticle();
1288  static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
1289  TruthLink truthLink;
1290  if (tp) {
1291  truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
1292  }
1293  ATH_MSG_DEBUG("Muon: pt " << mu->pt() << " eta " << mu->eta() << " link " << truthLink.isValid());
1294  }

◆ printTruthMuonDebug()

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

Definition at line 1325 of file MuonPhysValMonitoringTool.cxx.

1325  {
1326  ATH_MSG_DEBUG("Truth muon: " << truthMu->pt() << " eta " << truthMu->eta());
1327  if (!mu) return;
1328  ATH_MSG_DEBUG("Reco muon: " << mu->pt() << " eta " << mu->eta());
1329  }

◆ procHistograms()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::procHistograms ( )
overridevirtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 1331 of file MuonPhysValMonitoringTool.cxx.

1331  {
1332  ATH_MSG_INFO("Finalising hists " << name() << "...");
1333  for (const auto& plots : m_muonValidationPlots) plots->finalize();
1334  for (const auto& plots : m_TriggerMuonValidationPlots) plots->finalize();
1335  if (!m_isData) {
1336  m_oUnmatchedRecoMuonPlots->finalize();
1337  m_oUnmatchedTruthMuonPlots->finalize();
1338  }
1339 
1340  for (const auto& plots : m_muonMSTrackValidationPlots) plots->finalize();
1341  for (const auto& plots : m_muonMETrackValidationPlots) plots->finalize();
1342  for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) plots->finalize();
1343  for (const auto& plots : m_muonIDTrackValidationPlots) plots->finalize();
1344  for (const auto& plots : m_muonIDSelectedTrackValidationPlots) plots->finalize();
1345  for (const auto& plots : m_muonIDForwardTrackValidationPlots) plots->finalize();
1346  if (!m_isData)
1348 
1349  for (const auto& plots : m_muonSegmentValidationPlots) plots->finalize();
1350  if (!m_isData)
1352 
1353  if (m_doMuonTree) {
1354  for (const auto& plots : m_muonValidationPlots) {
1355  if (plots->getMuonTree()) { plots->getMuonTree()->getTree()->Write(); }
1356  }
1357  }
1358 
1359  return StatusCode::SUCCESS;
1360  }//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 1446 of file ManagedMonitorToolBase.cxx.

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

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

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

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

1493 {
1494  MonGroup group( this, system, interval, histo_mgmt, chain, merge );
1495  return regGraph( g, group );
1496 }

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

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

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

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

◆ registerMetadata()

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

Definition at line 946 of file ManagedMonitorToolBase.cxx.

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

◆ regManagedEfficiencies()

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

Definition at line 1141 of file ManagedMonitorToolBase.cxx.

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

◆ regManagedGraphs()

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

Definition at line 1070 of file ManagedMonitorToolBase.cxx.

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

◆ regManagedHistograms()

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

Definition at line 973 of file ManagedMonitorToolBase.cxx.

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

◆ regManagedTrees()

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

Definition at line 1201 of file ManagedMonitorToolBase.cxx.

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

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

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

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

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ runStat()

StatusCode ManagedMonitorToolBase::runStat ( )
virtualinherited

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

Implements IMonitorToolBase.

Definition at line 1663 of file ManagedMonitorToolBase.cxx.

1665 {
1666  return StatusCode::SUCCESS;
1667 }

◆ setMonManager()

void ManagedMonitorToolBase::setMonManager ( AthenaMonManager manager)
virtualinherited

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

Definition at line 1327 of file ManagedMonitorToolBase.cxx.

1329 {
1330  ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
1331  m_manager = manager;
1332  if( m_manager != 0 ) {
1333  ATH_MSG_DEBUG( " --> Setting manager");
1334  m_managerNameProp = m_manager->name();
1338  delete m_streamNameFcn;
1340  }
1341  ATH_MSG_DEBUG( " --> Exiting successfully");
1342 }

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

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

◆ SplitString()

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

Definition at line 1696 of file MuonPhysValMonitoringTool.cxx.

1696  {
1697  v.clear();
1698  int stringLength = x.Length();
1699  int delimLength = delim.Length();
1700 
1701  int stop = 1;
1702  TString temp = "---";
1703  while (stop != -1) {
1704  stop = x.First(delim);
1705 
1706  if (stop != -1) {
1707  temp = x(0, stop);
1708  TSubString newString = x(stop + delimLength, stringLength);
1709  x = newString;
1710  stringLength = x.Length();
1711  } else {
1712  stringLength = x.Length();
1713  temp = x(0, stringLength);
1714  }
1715 
1716  v.emplace_back(temp);
1717  }
1718  }

◆ streamNameFunction()

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

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

Definition at line 451 of file ManagedMonitorToolBase.cxx.

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

◆ sysInitialize()

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

Perform system initialization for an algorithm.

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

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

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

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

◆ trigChainsArePassed()

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

Definition at line 2094 of file ManagedMonitorToolBase.cxx.

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

◆ updateTriggersForGroups()

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

Definition at line 2132 of file ManagedMonitorToolBase.cxx.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

◆ writeAndDelete()

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

Write out histogram and delete it.

Definition at line 1601 of file ManagedMonitorToolBase.cxx.

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

Member Data Documentation

◆ m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial
privateinherited

Definition at line 893 of file ManagedMonitorToolBase.h.

◆ m_counterBits

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

Definition at line 110 of file MuonPhysValMonitoringTool.h.

◆ m_d

Imp* ManagedMonitorToolBase::m_d
privateinherited

Definition at line 900 of file ManagedMonitorToolBase.h.

◆ m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType
protectedinherited

Definition at line 838 of file ManagedMonitorToolBase.h.

◆ m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr
protectedinherited

Definition at line 834 of file ManagedMonitorToolBase.h.

◆ m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration
privateinherited

Definition at line 895 of file ManagedMonitorToolBase.h.

◆ m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel
protectedinherited

Definition at line 836 of file ManagedMonitorToolBase.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doBinnedResolutionPlots

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

Definition at line 151 of file MuonPhysValMonitoringTool.h.

◆ m_doMuonTree

Gaudi::Property<bool> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doMuonTree {this, "DoMuonTree", false}
private

Definition at line 156 of file MuonPhysValMonitoringTool.h.

◆ m_doTrigMuonEFValidation

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

Definition at line 155 of file MuonPhysValMonitoringTool.h.

◆ m_doTrigMuonL1Validation

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

Definition at line 153 of file MuonPhysValMonitoringTool.h.

◆ m_doTrigMuonL2Validation

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

Definition at line 154 of file MuonPhysValMonitoringTool.h.

◆ m_doTrigMuonValidation

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

Definition at line 152 of file MuonPhysValMonitoringTool.h.

◆ m_DQFilterTools

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

Definition at line 849 of file ManagedMonitorToolBase.h.

◆ m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun
privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

◆ m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment
protectedinherited

Definition at line 839 of file ManagedMonitorToolBase.h.

◆ m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr
protectedinherited

Definition at line 835 of file ManagedMonitorToolBase.h.

◆ m_eventInfo

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

Definition at line 159 of file MuonPhysValMonitoringTool.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fileKey

std::string ManagedMonitorToolBase::m_fileKey
protectedinherited

Definition at line 833 of file ManagedMonitorToolBase.h.

◆ m_fwdtracksName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_fwdtracksName {this, "FwdTrackContainerName", ""}
private

Definition at line 120 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_nObjects

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

Definition at line 193 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_authors

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

Definition at line 195 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_category

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

Definition at line 194 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_Z_mass

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

Definition at line 197 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_Z_mass_ID

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

Definition at line 199 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_Z_mass_ME

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

Definition at line 198 of file MuonPhysValMonitoringTool.h.

◆ m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock
protectedinherited

Definition at line 866 of file ManagedMonitorToolBase.h.

◆ m_isData

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

Definition at line 157 of file MuonPhysValMonitoringTool.h.

◆ m_isoTool

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

Definition at line 166 of file MuonPhysValMonitoringTool.h.

◆ m_L1MuonItems

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

Definition at line 145 of file MuonPhysValMonitoringTool.h.

◆ m_L1Seed

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

Definition at line 112 of file MuonPhysValMonitoringTool.h.

◆ m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock
protectedinherited

Definition at line 859 of file ManagedMonitorToolBase.h.

◆ m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval
protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun
protectedinherited

Definition at line 860 of file ManagedMonitorToolBase.h.

◆ m_lbDurationDataKey

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

Definition at line 888 of file ManagedMonitorToolBase.h.

◆ m_lumiDataKey

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

Definition at line 886 of file ManagedMonitorToolBase.h.

◆ m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager
protectedinherited

Definition at line 829 of file ManagedMonitorToolBase.h.

◆ m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp
protectedinherited

Definition at line 831 of file ManagedMonitorToolBase.h.

◆ m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap
protectedinherited

Definition at line 827 of file ManagedMonitorToolBase.h.

◆ m_MSTracks

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

Definition at line 109 of file MuonPhysValMonitoringTool.h.

◆ m_muonEFCombTrigName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonEFCombTrigName {this, "EFCombTrigMuonContainerName", "HLT_xAOD__MuonContainer_MuonEFInfo"}
private

Definition at line 134 of file MuonPhysValMonitoringTool.h.

◆ m_muonExtrapolatedTracksName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonExtrapolatedTracksName
private
Initial value:
{this, "MuonExtrapolatedTrackContainerName",
"ExtrapolatedMuonTrackParticles"}

Definition at line 125 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDForwardTrackValidationPlots

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

Definition at line 183 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDSelectedTrackValidationPlots

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

Definition at line 182 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDTrackValidationPlots

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

Definition at line 181 of file MuonPhysValMonitoringTool.h.

◆ m_muonItems

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

Definition at line 111 of file MuonPhysValMonitoringTool.h.

◆ m_muonL1TrigName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL1TrigName {this, "L1TrigMuonContainerName", "LVL1MuonRoIs"}
private

Definition at line 131 of file MuonPhysValMonitoringTool.h.

◆ m_muonL2CBName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL2CBName {this, "L2CBMuonContainerName", "HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfo"}
private

Definition at line 133 of file MuonPhysValMonitoringTool.h.

◆ m_muonL2SAName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL2SAName {this, "L2SAMuonContainerName", "HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo"}
private

Definition at line 132 of file MuonPhysValMonitoringTool.h.

◆ m_muonMETrackValidationPlots

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

Definition at line 179 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSOnlyExtrapolatedTracksName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyExtrapolatedTracksName
private
Initial value:
{this, "MuonOnlyExtrapolatedTrackContainerName",
"MSOnlyExtrapolatedMuonTrackParticles"}

Definition at line 127 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSOnlyMETrackValidationPlots

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

Definition at line 180 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSTrackValidationPlots

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

Definition at line 178 of file MuonPhysValMonitoringTool.h.

◆ m_muonPrinter

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

Definition at line 163 of file MuonPhysValMonitoringTool.h.

◆ m_muonSegmentsName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentsName {this, "MuonSegmentContainerName", "MuonSegments"}
private

Definition at line 129 of file MuonPhysValMonitoringTool.h.

◆ m_muonSegmentsTruthName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentsTruthName {this, "MuonTruthSegmentContainerName", "MuonTruthSegments"}
private

Definition at line 130 of file MuonPhysValMonitoringTool.h.

◆ m_muonSegmentValidationPlots

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

Definition at line 184 of file MuonPhysValMonitoringTool.h.

◆ m_muonSelectionTool

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

Definition at line 162 of file MuonPhysValMonitoringTool.h.

◆ m_muonsName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonsName {this, "MuonContainerName", "Muons"}
private

Definition at line 121 of file MuonPhysValMonitoringTool.h.

◆ m_muonsTruthName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonsTruthName {this, "MuonTruthParticleContainerName", "MuonTruthParticles"}
private

Definition at line 123 of file MuonPhysValMonitoringTool.h.

◆ m_muonTracksName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonTracksName {this, "MuonTrackContainerName", "MuonSpectrometerTrackParticles"}
private

Definition at line 124 of file MuonPhysValMonitoringTool.h.

◆ m_muonValidationPlots

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

Definition at line 176 of file MuonPhysValMonitoringTool.h.

◆ m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents
protectedinherited

Definition at line 863 of file ManagedMonitorToolBase.h.

◆ m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger
protectedinherited

Definition at line 864 of file ManagedMonitorToolBase.h.

◆ m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock
privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

◆ m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval
privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newRun

bool ManagedMonitorToolBase::m_newRun
privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks
protectedinherited

Definition at line 865 of file ManagedMonitorToolBase.h.

◆ m_oUnmatchedRecoMuonPlots

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

Definition at line 185 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonSegmentPlots

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

Definition at line 188 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonTrackPlots

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

Definition at line 187 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedTruthMuonPlots

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

Definition at line 186 of file MuonPhysValMonitoringTool.h.

◆ m_path

std::string ManagedMonitorToolBase::m_path
protectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

◆ m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp
protectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

◆ m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp
protectedinherited

Definition at line 851 of file ManagedMonitorToolBase.h.

◆ m_selectComissioning

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

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

Definition at line 143 of file MuonPhysValMonitoringTool.h.

◆ m_SelectedAuthor

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

Definition at line 113 of file MuonPhysValMonitoringTool.h.

◆ m_selectHLTMuonItems

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

Definition at line 144 of file MuonPhysValMonitoringTool.h.

◆ m_selectMuonAuthors

Gaudi::Property<std::vector<unsigned int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonAuthors
private
Initial value:
{
this,
"SelectMuonAuthors",

Definition at line 138 of file MuonPhysValMonitoringTool.h.

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

◆ m_selectMuonCategoriesStr

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

Definition at line 168 of file MuonPhysValMonitoringTool.h.

◆ m_selectMuonWPs

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

Definition at line 136 of file MuonPhysValMonitoringTool.h.

◆ m_slowMuonsName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonsName {this, "SlowMuonContainerName", "SlowMuons"}
private

Definition at line 122 of file MuonPhysValMonitoringTool.h.

◆ m_slowMuonValidationPlots

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

Definition at line 190 of file MuonPhysValMonitoringTool.h.

◆ m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn
protectedinherited

Definition at line 841 of file ManagedMonitorToolBase.h.

◆ m_supportedIntervalsForRebooking

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

Definition at line 896 of file ManagedMonitorToolBase.h.

◆ m_templateEfficiencies

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

Definition at line 676 of file ManagedMonitorToolBase.h.

◆ m_templateGraphs

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

Definition at line 668 of file ManagedMonitorToolBase.h.

◆ m_templateHistograms

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

Definition at line 664 of file ManagedMonitorToolBase.h.

◆ m_templateTrees

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

Definition at line 672 of file ManagedMonitorToolBase.h.

◆ m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc
protectedinherited

Definition at line 843 of file ManagedMonitorToolBase.h.

◆ m_trackSelector

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

Definition at line 165 of file MuonPhysValMonitoringTool.h.

◆ m_tracksName

Gaudi::Property<std::string> MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_tracksName {this, "TrackContainerName", "InDetTrackParticles"}
private

Definition at line 119 of file MuonPhysValMonitoringTool.h.

◆ m_trigDec

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

Definition at line 164 of file MuonPhysValMonitoringTool.h.

◆ m_trigDecTool

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

Definition at line 845 of file ManagedMonitorToolBase.h.

◆ m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp
protectedinherited

Definition at line 854 of file ManagedMonitorToolBase.h.

◆ m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp
protectedinherited

Definition at line 855 of file ManagedMonitorToolBase.h.

◆ m_TriggerMuonValidationPlots

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

Definition at line 177 of file MuonPhysValMonitoringTool.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 890 of file ManagedMonitorToolBase.h.

◆ m_trigTranslator

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

Definition at line 847 of file ManagedMonitorToolBase.h.

◆ m_useLumi

bool ManagedMonitorToolBase::m_useLumi
privateinherited

Definition at line 894 of file ManagedMonitorToolBase.h.

◆ m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger
protectedinherited

Definition at line 857 of file ManagedMonitorToolBase.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vEFMuons

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

Definition at line 209 of file MuonPhysValMonitoringTool.h.

◆ m_vEFMuonsSelected

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

Definition at line 210 of file MuonPhysValMonitoringTool.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vL2CBMuons

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

Definition at line 213 of file MuonPhysValMonitoringTool.h.

◆ m_vL2CBMuonsSelected

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

Definition at line 214 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuons

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

Definition at line 211 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuonsSelected

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

Definition at line 212 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuons

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

Definition at line 202 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonSegments

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

Definition at line 205 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonTracks

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

Definition at line 204 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedSlowMuons

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

Definition at line 203 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedTruthMuons

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

Definition at line 201 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons

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

Definition at line 215 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen

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

Definition at line 218 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_CB

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

Definition at line 216 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_MS

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

Definition at line 217 of file MuonPhysValMonitoringTool.h.

◆ m_vTrigChainNames

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

Definition at line 680 of file ManagedMonitorToolBase.h.

◆ m_vTrigGroupNames

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

Definition at line 680 of file ManagedMonitorToolBase.h.

◆ m_vZmumuIDTracks

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

Definition at line 206 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMETracks

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

Definition at line 207 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMuons

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

Definition at line 208 of file MuonPhysValMonitoringTool.h.


The documentation for this class was generated from the following files:
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonExtrapolatedTracksName
Gaudi::Property< std::string > m_muonExtrapolatedTracksName
Definition: MuonPhysValMonitoringTool.h:125
ManagedMonitorToolBase::m_nEvents
unsigned int m_nEvents
Definition: ManagedMonitorToolBase.h:863
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen_MS
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen_MS
Definition: MuonPhysValMonitoringTool.h:217
xAOD::L2CombinedMuon_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleTruthMuonSegment
void handleTruthMuonSegment(const xAOD::MuonSegment *truthMuSeg, const xAOD::TruthParticleContainer *muonTruthContainer, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:858
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
LikeEnum::Loose
@ Loose
Definition: LikelihoodEnums.h:12
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:1039
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonPlots
std::unique_ptr< Muon::RecoMuonPlotOrganizer > m_oUnmatchedRecoMuonPlots
Definition: MuonPhysValMonitoringTool.h:185
temp
Definition: JetEventDict.h:21
ManagedMonitorToolBase::m_templateEfficiencies
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > > m_templateEfficiencies
Definition: ManagedMonitorToolBase.h:676
ManagedMonitorToolBase::streamNameFunction
virtual StreamNameFcn * streamNameFunction()
Returns the function object that converts logical paramters into a physical stream name.
Definition: ManagedMonitorToolBase.cxx:452
MuonPhysValMonitoring::MuonPhysValMonitoringTool::INFLIGHT
@ INFLIGHT
Definition: MuonPhysValMonitoringTool.h:80
ManagedMonitorToolBase::m_newRun
bool m_newRun
Definition: ManagedMonitorToolBase.h:821
ManagedMonitorToolBase::m_supportedIntervalsForRebooking
std::set< Interval_t > m_supportedIntervalsForRebooking
Definition: ManagedMonitorToolBase.h:896
xAOD::Muon_v1::allAuthors
uint16_t allAuthors() const
Get all the authors of this Muon.
defineDB.smd
string smd
Definition: JetTagCalibration/share/defineDB.py:44
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedTruthMuons
std::vector< const xAOD::TruthParticle * > m_vMatchedTruthMuons
Definition: MuonPhysValMonitoringTool.h:201
ManagedMonitorToolBase::bookHistograms
virtual StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition: ManagedMonitorToolBase.cxx:1299
ManagedMonitorToolBase::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Definition: ManagedMonitorToolBase.h:849
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_nObjects
std::vector< TH1F * > m_h_overview_nObjects
Definition: MuonPhysValMonitoringTool.h:193
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
checkFileSG.line
line
Definition: checkFileSG.py:75
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:1410
ManagedMonitorToolBase::m_newEventsBlock
bool m_newEventsBlock
Definition: ManagedMonitorToolBase.h:822
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons
std::vector< const xAOD::Muon * > m_vRecoMuons
Definition: MuonPhysValMonitoringTool.h:215
xAOD::SlowMuon_v1
Class describing a SlowMuon.
Definition: SlowMuon_v1.h:26
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL2CBName
Gaudi::Property< std::string > m_muonL2CBName
Definition: MuonPhysValMonitoringTool.h:133
xAOD::MuGirl
@ MuGirl
MuGirl.
Definition: TrackingPrimitives.h:141
ManagedMonitorToolBase::Imp::benchPreProcHistograms
void benchPreProcHistograms()
Definition: ManagedMonitorToolBase.cxx:119
get_generator_info.result
result
Definition: get_generator_info.py:21
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentsName
Gaudi::Property< std::string > m_muonSegmentsName
Definition: MuonPhysValMonitoringTool.h:129
PlotBase::retrieveBookedTrees
std::vector< TreeData > retrieveBookedTrees()
Retrieve all booked trees.
Definition: PlotBase.cxx:73
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentsTruthName
Gaudi::Property< std::string > m_muonSegmentsTruthName
Definition: MuonPhysValMonitoringTool.h:130
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::Muon_v1::trackParticle
const TrackParticle * trackParticle(TrackParticleType type) const
Returns a pointer (which can be NULL) to the TrackParticle used in identification of this muon.
Definition: Muon_v1.cxx:486
ManagedMonitorToolBase::higStat
@ higStat
Definition: ManagedMonitorToolBase.h:114
MuonPhysValMonitoring::MuonPhysValMonitoringTool::printMuonDebug
void printMuonDebug(const xAOD::Muon *mu)
Definition: MuonPhysValMonitoringTool.cxx:1286
ManagedMonitorToolBase::lumiBlock
@ lumiBlock
Definition: ManagedMonitorToolBase.h:113
ManagedMonitorToolBase::m_endOfLumiBlock
bool m_endOfLumiBlock
Definition: ManagedMonitorToolBase.h:823
MuonPhysValMonitoring::MuonPhysValMonitoringTool::MUCATEGORY
MUCATEGORY
Definition: MuonPhysValMonitoringTool.h:80
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuonSegment
const xAOD::MuonSegment * findRecoMuonSegment(const xAOD::MuonSegment *truthMuSeg)
Definition: MuonPhysValMonitoringTool.cxx:1362
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen_CB
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen_CB
Definition: MuonPhysValMonitoringTool.h:216
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_eventInfo
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfo
Definition: MuonPhysValMonitoringTool.h:159
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
ManagedMonitorToolBase::m_THistSvc
ServiceHandle< ITHistSvc > m_THistSvc
Definition: ManagedMonitorToolBase.h:843
ManagedMonitorToolBase::m_procNEventsProp
long m_procNEventsProp
Definition: ManagedMonitorToolBase.h:851
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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:1547
AthenaMonManager::runNumber
static unsigned int runNumber()
Definition: AthenaMonManager.cxx:341
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonValidation
Gaudi::Property< bool > m_doTrigMuonValidation
Definition: MuonPhysValMonitoringTool.h:152
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrees
void handleMuonTrees(const xAOD::EventInfo *eventInfo, bool isData)
Definition: MuonPhysValMonitoringTool.cxx:1010
plotmaker.hist
hist
Definition: plotmaker.py:148
AthenaMonManager::fileKey
virtual std::string fileKey() const
Definition: AthenaMonManager.cxx:648
CutsMETMaker::accept
StatusCode accept(const xAOD::Muon *mu)
Definition: CutsMETMaker.cxx:18
ManagedMonitorToolBase::Imp::benchPreFillHistograms
void benchPreFillHistograms()
Definition: ManagedMonitorToolBase.cxx:94
AthenaMonManager::AOD
@ AOD
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::regManagedGraphs
StatusCode regManagedGraphs(std::vector< MgmtParams< TGraph > > &templateGraphs)
Definition: ManagedMonitorToolBase.cxx:1071
TruthLink
ElementLink< xAOD::TruthParticleContainer > TruthLink
Definition: TruthRelatedMuonPlotOrganizer.cxx:12
AthenaMonManager::passOwnership
virtual void passOwnership(TObject *h, const std::string &key)
Pass ownership of a TObject to this manager so that it will be deleted appropriately.
Definition: AthenaMonManager.cxx:656
ManagedMonitorToolBase::Imp::benchPostFillHistograms
void benchPostFillHistograms()
Definition: ManagedMonitorToolBase.cxx:103
RTTAlgmain.trees
list trees
Definition: RTTAlgmain.py:40
tree
TChain * tree
Definition: tile_monitor.h:30
ManagedMonitorToolBase::regManagedHistograms
StatusCode regManagedHistograms(std::vector< MgmtParams< TH1 > > &templateHistograms)
Definition: ManagedMonitorToolBase.cxx:974
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vEFMuons
std::vector< const xAOD::Muon * > m_vEFMuons
Definition: MuonPhysValMonitoringTool.h:209
ManagedMonitorToolBase::lbDuration
virtual double lbDuration(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Luminosity block time (in seconds)
Definition: ManagedMonitorToolBase.cxx:1817
ManagedMonitorToolBase::m_trigDecTool
PublicToolHandle< Trig::ITrigDecisionTool > m_trigDecTool
Definition: ManagedMonitorToolBase.h:845
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMETrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:179
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
skel.it
it
Definition: skel.GENtoEVGEN.py:396
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyMETrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSOnlyMETrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:180
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuIDTracks
std::vector< const xAOD::TrackParticle * > m_vZmumuIDTracks
Definition: MuonPhysValMonitoringTool.h:206
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::MuonRoI_v1::eta
float eta() const
The pseudorapidity ( ) of the muon candidate.
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::MuonSegment_v1
Class describing a MuonSegment.
Definition: MuonSegment_v1.h:33
ParticleTest.tp
tp
Definition: ParticleTest.py:25
ManagedMonitorToolBase::m_d
Imp * m_d
Definition: ManagedMonitorToolBase.h:899
ManagedMonitorToolBase::m_lastLowStatInterval
int m_lastLowStatInterval
Definition: ManagedMonitorToolBase.h:861
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
xAOD::MuonRoI_v1::thrValue
float thrValue() const
The highest threshold value (in MeV) passed by the muon candidate.
ManagedMonitorToolBase::m_triggerGroupProp
std::string m_triggerGroupProp
Definition: ManagedMonitorToolBase.h:855
ManagedMonitorToolBase::Imp::benchPostProcHistograms
void benchPostProcHistograms()
Definition: ManagedMonitorToolBase.cxx:127
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleTruthMuon
void handleTruthMuon(const xAOD::TruthParticle *truthMu, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:957
ManagedMonitorToolBase::m_dataType
AthenaMonManager::DataType_t m_dataType
Definition: ManagedMonitorToolBase.h:838
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoMuon
const xAOD::Muon * findRecoMuon(const xAOD::TruthParticle *truthMu)
Definition: MuonPhysValMonitoringTool.cxx:1296
ALL
@ ALL
Definition: sTGCenumeration.h:14
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonValidationPlots
std::vector< std::unique_ptr< MuonValidationPlots > > m_muonValidationPlots
Definition: MuonPhysValMonitoringTool.h:176
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:1491
PixelModuleFeMask_create_db.stop
int stop
Definition: PixelModuleFeMask_create_db.py:76
xAOD::Muon_v1::author
Author author() const
ManagedMonitorToolBase::m_newLowStatInterval
bool m_newLowStatInterval
Definition: ManagedMonitorToolBase.h:820
SG::ConstAccessor
Helper class to provide constant type-safe access to aux data.
Definition: ConstAccessor.h:55
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_counterBits
std::map< std::string, int > m_counterBits
Definition: MuonPhysValMonitoringTool.h:110
ManagedMonitorToolBase::fill
@ fill
Definition: ManagedMonitorToolBase.h:115
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2SAMuons
std::vector< const xAOD::L2StandAloneMuon * > m_vL2SAMuons
Definition: MuonPhysValMonitoringTool.h:211
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
python.TrigTLAMonitorAlgorithm.triggers
triggers
Definition: TrigTLAMonitorAlgorithm.py:196
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
ManagedMonitorToolBase::procHistograms
virtual StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: ManagedMonitorToolBase.cxx:1315
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuons
std::vector< const xAOD::Muon * > m_vMatchedMuons
Definition: MuonPhysValMonitoringTool.h:202
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
xAOD::EventInfo_v1::IS_SIMULATION
@ IS_SIMULATION
true: simulation, false: data
Definition: EventInfo_v1.h:151
MuonParameters::CaloTag
@ CaloTag
Definition: MuonParamDefs.h:64
x
#define x
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonsName
Gaudi::Property< std::string > m_slowMuonsName
Definition: MuonPhysValMonitoringTool.h:122
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectHLTMuonItems
Gaudi::Property< std::vector< std::vector< std::string > > > m_selectHLTMuonItems
Definition: MuonPhysValMonitoringTool.h:144
ManagedMonitorToolBase::regManagedTrees
StatusCode regManagedTrees(std::vector< MgmtParams< TTree > > &templateTrees)
Definition: ManagedMonitorToolBase.cxx:1202
ManagedMonitorToolBase::registerMetadata
StatusCode registerMetadata(const std::string &streamName, const std::string &hName, const MonGroup &group)
Definition: ManagedMonitorToolBase.cxx:947
AthenaMonManager::getLBsLowStat
static unsigned int getLBsLowStat()
Definition: AthenaMonManager.cxx:303
xAOD::Muon_v1
Class describing a Muon.
Definition: Muon_v1.h:38
ManagedMonitorToolBase::m_newHigStatInterval
bool m_newHigStatInterval
Definition: ManagedMonitorToolBase.h:820
IDTPM::truthType
int truthType(const U &p)
Definition: TrackParametersHelper.h:274
ManagedMonitorToolBase::m_newMedStatInterval
bool m_newMedStatInterval
Definition: ManagedMonitorToolBase.h:820
xAOD::L2StandAloneMuon_v2::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
MuonPhysValMonitoring::MuonPhysValMonitoringTool::EFTriggerResolution
void EFTriggerResolution()
Definition: MuonPhysValMonitoringTool.cxx:1238
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
MuonParameters::MuTagIMO
@ MuTagIMO
Definition: MuonParamDefs.h:66
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_reco_category
TH1F * m_h_overview_reco_category
Definition: MuonPhysValMonitoringTool.h:194
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthenaMonManager::environment
static Environment_t environment()
Returns the running environment of the monitoring application to help ManagedMonitorToolBase objects ...
Definition: AthenaMonManager.cxx:298
python.CreateTierZeroArgdict.pairs
pairs
Definition: CreateTierZeroArgdict.py:201
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDTrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:181
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL2Trigger
void handleMuonL2Trigger(const xAOD::L2StandAloneMuon *L2SAMu)
Definition: MuonPhysValMonitoringTool.cxx:1132
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedSlowMuons
std::vector< const xAOD::SlowMuon * > m_vMatchedSlowMuons
Definition: MuonPhysValMonitoringTool.h:203
Trig::FeatureContainer
Definition: FeatureContainer.h:54
python.checkMetadata.metadata
metadata
Definition: checkMetadata.py:175
xAOD::Muon_v1::charge
float charge() const
AthenaMonManager::getLBsMedStat
static unsigned int getLBsMedStat()
Definition: AthenaMonManager.cxx:306
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyExtrapolatedTracksName
Gaudi::Property< std::string > m_muonMSOnlyExtrapolatedTracksName
Definition: MuonPhysValMonitoringTool.h:127
ManagedMonitorToolBase::m_bookHistogramsInitial
bool m_bookHistogramsInitial
Definition: ManagedMonitorToolBase.h:893
ManagedMonitorToolBase::Imp::m_warnAboutMissingInitialize
bool m_warnAboutMissingInitialize
Definition: ManagedMonitorToolBase.cxx:48
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
ManagedMonitorToolBase::getNewStreamNameFcn
virtual StreamNameFcn * getNewStreamNameFcn() const
Definition: ManagedMonitorToolBase.cxx:2158
ManagedMonitorToolBase::m_preScaleProp
long m_preScaleProp
Definition: ManagedMonitorToolBase.h:853
xAOD::TrackParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TrackParticle_v1.cxx:129
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonSegment
void handleMuonSegment(const xAOD::MuonSegment *muSeg, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:874
ManagedMonitorToolBase::trigChainsArePassed
virtual bool trigChainsArePassed(std::vector< std::string > &)
Definition: ManagedMonitorToolBase.cxx:2095
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
ManagedMonitorToolBase::m_fileKey
std::string m_fileKey
Definition: ManagedMonitorToolBase.h:833
ManagedMonitorToolBase::m_lastLumiBlock
unsigned int m_lastLumiBlock
Definition: ManagedMonitorToolBase.h:859
ManagedMonitorToolBase::m_vTrigGroupNames
std::vector< std::string > m_vTrigGroupNames
Definition: ManagedMonitorToolBase.h:680
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonTracksName
Gaudi::Property< std::string > m_muonTracksName
Definition: MuonPhysValMonitoringTool.h:124
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_L1MuonItems
Gaudi::Property< std::vector< std::string > > m_L1MuonItems
Definition: MuonPhysValMonitoringTool.h:145
xAOD::L2CombinedMuon_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
AthenaMonManager::tier0ESD
@ tier0ESD
Definition: AthenaMonManager.h:49
ManagedMonitorToolBase::lbAverageLivefraction
virtual float lbAverageLivefraction(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity livefraction.
Definition: ManagedMonitorToolBase.cxx:1763
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonEFValidation
Gaudi::Property< bool > m_doTrigMuonEFValidation
Definition: MuonPhysValMonitoringTool.h:155
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ManagedMonitorToolBase::m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TGraph > > > m_templateGraphs
Definition: ManagedMonitorToolBase.h:668
PlotBase::retrieveBookedHistograms
std::vector< HistData > retrieveBookedHistograms()
Retrieve all booked histograms.
Definition: PlotBase.cxx:63
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthenaMonManager::dataType
static DataType_t dataType()
Returns the data type that the monitoring application is running over to help ManagedMonitorToolBase ...
Definition: AthenaMonManager.cxx:315
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
PixelAthClusterMonAlgCfg.histname
histname
Definition: PixelAthClusterMonAlgCfg.py:106
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuonSegments
std::vector< const xAOD::MuonSegment * > m_vMatchedMuonSegments
Definition: MuonPhysValMonitoringTool.h:205
SG::ExcBadAuxVar
Exception — Attempt to retrieve nonexistent aux data item.
Definition: Control/AthContainers/AthContainers/exceptions.h:59
ManagedMonitorToolBase::m_manager
AthenaMonManager * m_manager
Definition: ManagedMonitorToolBase.h:829
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL1TrigName
Gaudi::Property< std::string > m_muonL1TrigName
Definition: MuonPhysValMonitoringTool.h:131
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_L1Seed
std::vector< std::string > m_L1Seed
Definition: MuonPhysValMonitoringTool.h:112
ManagedMonitorToolBase::initialize
virtual StatusCode initialize()
Definition: ManagedMonitorToolBase.cxx:617
ManagedMonitorToolBase::m_lumiDataKey
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey
Definition: ManagedMonitorToolBase.h:887
ManagedMonitorToolBase::m_streamNameFcn
StreamNameFcn * m_streamNameFcn
Definition: ManagedMonitorToolBase.h:841
SG::Decorator< float >
HepMC::is_simulation_particle
bool is_simulation_particle(const T &p)
Method to establish if a particle (or barcode) was created during the simulation (TODO update to be s...
Definition: MagicNumbers.h:355
xAOD::L2StandAloneMuon_v2::sAddress
int sAddress() const
Get the station address of the muon.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonEFCombTrigName
Gaudi::Property< std::string > m_muonEFCombTrigName
Definition: MuonPhysValMonitoringTool.h:134
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrigger
void handleMuonTrigger(const xAOD::Muon *mu)
Definition: MuonPhysValMonitoringTool.cxx:1227
lumiFormat.i
int i
Definition: lumiFormat.py:85
PlotBase::initialize
void initialize()
Definition: PlotBase.cxx:39
AthenaMonManager::tier0
@ tier0
Definition: AthenaMonManager.h:49
h
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_isData
Gaudi::Property< bool > m_isData
Definition: MuonPhysValMonitoringTool.h:157
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDForwardTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDForwardTrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:183
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
extractSporadic.h
list h
Definition: extractSporadic.py:97
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthenaMonManager::online
@ online
Definition: AthenaMonManager.h:49
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSegmentValidationPlots
std::vector< std::unique_ptr< MuonSegmentValidationPlots > > m_muonSegmentValidationPlots
Definition: MuonPhysValMonitoringTool.h:184
ManagedMonitorToolBase::file
@ file
Definition: ManagedMonitorToolBase.h:113
ReweightUtils.category
category
Definition: ReweightUtils.py:15
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_reco_authors
std::vector< TH1F * > m_h_overview_reco_authors
Definition: MuonPhysValMonitoringTool.h:195
AthenaMonManager::writeAndDelete
virtual void writeAndDelete(const std::string &key)
If the TObject is owned by this manager, its Write() method is called and it is deleted.
Definition: AthenaMonManager.cxx:665
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_TriggerMuonValidationPlots
std::vector< std::unique_ptr< TriggerMuonValidationPlots > > m_TriggerMuonValidationPlots
Definition: MuonPhysValMonitoringTool.h:177
MuonPhysValMonitoring::MuonPhysValMonitoringTool::getMuonTruthCategory
MuonPhysValMonitoringTool::MUCATEGORY getMuonTruthCategory(const xAOD::IParticle *prt)
Definition: MuonPhysValMonitoringTool.cxx:1412
getLatestRuns.interval
interval
Definition: getLatestRuns.py:24
xAOD::L2CombinedMuon_v1::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonsName
Gaudi::Property< std::string > m_muonsName
Definition: MuonPhysValMonitoringTool.h:121
HepMC::uniqueID
int uniqueID(const T &p)
Definition: MagicNumbers.h:116
ManagedMonitorToolBase::ATTRIB_UNMANAGED
@ ATTRIB_UNMANAGED
Definition: ManagedMonitorToolBase.h:130
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectComissioning
Gaudi::Property< bool > m_selectComissioning
Flag to tell whether muons with the comissioning author will be selected or not.
Definition: MuonPhysValMonitoringTool.h:143
ManagedMonitorToolBase::Imp::benchPostBookHistograms
void benchPostBookHistograms()
Definition: ManagedMonitorToolBase.cxx:84
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaMonManager::tier0Raw
@ tier0Raw
Definition: AthenaMonManager.h:49
MuonPhysValMonitoring::MuonPhysValMonitoringTool::SplitString
void SplitString(TString x, const TString &delim, std::vector< TString > &v)
Definition: MuonPhysValMonitoringTool.cxx:1696
ManagedMonitorToolBase::m_triggerChainProp
std::string m_triggerChainProp
Definition: ManagedMonitorToolBase.h:854
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonAuthors
Gaudi::Property< std::vector< unsigned int > > m_selectMuonAuthors
Definition: MuonPhysValMonitoringTool.h:138
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
MakeTH3DFromTH2Ds.hists
hists
Definition: MakeTH3DFromTH2Ds.py:72
AthenaMonManager::user
@ user
Definition: AthenaMonManager.h:49
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonSelectionTool
ToolHandle< CP::IMuonSelectionTool > m_muonSelectionTool
Definition: MuonPhysValMonitoringTool.h:162
run
Definition: run.py:1
ManagedMonitorToolBase::ATTRIB_MANAGED
@ ATTRIB_MANAGED
Definition: ManagedMonitorToolBase.h:130
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.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass_ID
TH1F * m_h_overview_Z_mass_ID
Definition: MuonPhysValMonitoringTool.h:199
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_MSTracks
const xAOD::TrackParticleContainer * m_MSTracks
Definition: MuonPhysValMonitoringTool.h:109
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
ManagedMonitorToolBase::ManagedMonitorToolBase
ManagedMonitorToolBase(const std::string &type, const std::string &name, const IInterface *parent)
Definition: ManagedMonitorToolBase.cxx:339
ManagedMonitorToolBase::medStat
@ medStat
Definition: ManagedMonitorToolBase.h:114
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonWPs
Gaudi::Property< std::vector< int > > m_selectMuonWPs
Definition: MuonPhysValMonitoringTool.h:136
ManagedMonitorToolBase::m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TTree > > > m_templateTrees
Definition: ManagedMonitorToolBase.h:672
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonL1Validation
Gaudi::Property< bool > m_doTrigMuonL1Validation
Definition: MuonPhysValMonitoringTool.h:153
ManagedMonitorToolBase::m_metadataMap
MDMap_t m_metadataMap
Definition: ManagedMonitorToolBase.h:827
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_SelectedAuthor
int m_SelectedAuthor
Definition: MuonPhysValMonitoringTool.h:113
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
ManagedMonitorToolBase::m_endOfEventsBlock
bool m_endOfEventsBlock
Definition: ManagedMonitorToolBase.h:823
MuonParameters::NumberOfMuonAuthors
@ NumberOfMuonAuthors
Definition: MuonParamDefs.h:69
ManagedMonitorToolBase::m_trigLiveFractionDataKey
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey
Definition: ManagedMonitorToolBase.h:891
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonMSTrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:178
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doTrigMuonL2Validation
Gaudi::Property< bool > m_doTrigMuonL2Validation
Definition: MuonPhysValMonitoringTool.h:154
ManagedMonitorToolBase::m_environment
AthenaMonManager::Environment_t m_environment
Definition: ManagedMonitorToolBase.h:839
beamspotman.dir
string dir
Definition: beamspotman.py:623
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
HepMC::UNDEFINED_ID
constexpr int UNDEFINED_ID
Definition: MagicNumbers.h:56
xAOD::IParticle::pt
virtual double pt() const =0
The transverse momentum ( ) of the particle.
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
xAOD::SlowMuon_v1::muonLink
const ElementLink< MuonContainer > & muonLink() const
LikeEnum::Tight
@ Tight
Definition: LikelihoodEnums.h:15
ManagedMonitorToolBase::m_lastRun
unsigned int m_lastRun
Definition: ManagedMonitorToolBase.h:860
ManagedMonitorToolBase::m_newLumiBlock
bool m_newLumiBlock
Definition: ManagedMonitorToolBase.h:821
ManagedMonitorToolBase::m_endOfLowStat
bool m_endOfLowStat
Definition: ManagedMonitorToolBase.h:823
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vMatchedMuonTracks
std::vector< const xAOD::TrackParticle * > m_vMatchedMuonTracks
Definition: MuonPhysValMonitoringTool.h:204
ManagedMonitorToolBase::m_lbDurationDataKey
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey
Definition: ManagedMonitorToolBase.h:889
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategoriesStr
std::vector< std::string > m_selectMuonCategoriesStr
Definition: MuonPhysValMonitoringTool.h:168
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
ManagedMonitorToolBase::bookHistogramsRecurrent
virtual StatusCode bookHistogramsRecurrent()
An inheriting class should either override this function, bookHists() or bookHistograms().
Definition: ManagedMonitorToolBase.cxx:1287
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedTruthMuonPlots
std::unique_ptr< Muon::TruthMuonPlotOrganizer > m_oUnmatchedTruthMuonPlots
Definition: MuonPhysValMonitoringTool.h:186
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
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
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategories
Gaudi::Property< std::vector< unsigned int > > m_selectMuonCategories
Definition: MuonPhysValMonitoringTool.h:146
AthenaMonManager::getLBsHigStat
static unsigned int getLBsHigStat()
Definition: AthenaMonManager.cxx:309
threshold
Definition: chainparser.cxx:74
MuonPhysValMonitoring::MuonPhysValMonitoringTool::printTruthMuonDebug
void printTruthMuonDebug(const xAOD::TruthParticle *truthMu, const xAOD::Muon *mu)
Definition: MuonPhysValMonitoringTool.cxx:1325
MuonPhysValMonitoring::MuonPhysValMonitoringTool::PROMPT
@ PROMPT
Definition: MuonPhysValMonitoringTool.h:80
MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2CBTriggerResolution
void L2CBTriggerResolution()
Definition: MuonPhysValMonitoringTool.cxx:1191
MuonPhysValMonitoring::MuonPhysValMonitoringTool::NONISO
@ NONISO
Definition: MuonPhysValMonitoringTool.h:80
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonSegmentPlots
std::unique_ptr< Muon::MuonSegmentPlots > m_oUnmatchedRecoMuonSegmentPlots
Definition: MuonPhysValMonitoringTool.h:188
ExtractEBRunDetails.endOfRun
endOfRun
Definition: ExtractEBRunDetails.py:245
MuonParameters::MuidSA
@ MuidSA
Definition: MuonParamDefs.h:59
SG::AuxElement::makePrivateStore
void makePrivateStore()
Create a new (empty) private store for this object.
Definition: AuxElement.cxx:192
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonTrack
void handleMuonTrack(const xAOD::TrackParticle *tp, xAOD::Muon::TrackParticleType type, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:1021
MuonPhysValMonitoring::MuonPhysValMonitoringTool::passesAcceptanceCuts
bool passesAcceptanceCuts(const xAOD::IParticle *prt)
Definition: MuonPhysValMonitoringTool.cxx:1690
item
Definition: ItemListSvc.h:43
xAOD::TruthParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition: TruthParticle_v1.cxx:174
xAOD::L2StandAloneMuon_v2::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
ManagedMonitorToolBase::lowStat
@ lowStat
Definition: ManagedMonitorToolBase.h:114
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: MuonPhysValMonitoringTool.h:164
MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2SATriggerResolution
void L2SATriggerResolution()
Definition: MuonPhysValMonitoringTool.cxx:1144
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2SAMuonsSelected
std::vector< const xAOD::L2StandAloneMuon * > m_vL2SAMuonsSelected
Definition: MuonPhysValMonitoringTool.h:212
ManagedMonitorToolBase::m_managerNameProp
std::string m_managerNameProp
Definition: ManagedMonitorToolBase.h:831
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_fwdtracksName
Gaudi::Property< std::string > m_fwdtracksName
Definition: MuonPhysValMonitoringTool.h:120
python.PyAthena.v
v
Definition: PyAthena.py:154
ManagedMonitorToolBase::m_nEventsIgnoreTrigger
unsigned int m_nEventsIgnoreTrigger
Definition: ManagedMonitorToolBase.h:864
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2CBMuons
std::vector< const xAOD::L2CombinedMuon * > m_vL2CBMuons
Definition: MuonPhysValMonitoringTool.h:213
Muon::MuonSegmentPlots
Definition: MuonSegmentPlots.h:18
ManagedMonitorToolBase::run
@ run
Definition: ManagedMonitorToolBase.h:115
ManagedMonitorToolBase::m_endOfRun
bool m_endOfRun
Definition: ManagedMonitorToolBase.h:823
MuonParameters::MuidCo
@ MuidCo
Definition: MuonParamDefs.h:60
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuMETracks
std::vector< const xAOD::TrackParticle * > m_vZmumuMETracks
Definition: MuonPhysValMonitoringTool.h:207
ManagedMonitorToolBase::m_newLowStat
bool m_newLowStat
Definition: ManagedMonitorToolBase.h:821
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doBinnedResolutionPlots
Gaudi::Property< bool > m_doBinnedResolutionPlots
Definition: MuonPhysValMonitoringTool.h:151
AthenaPoolExample_Copy.streamName
string streamName
Definition: AthenaPoolExample_Copy.py:39
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_doMuonTree
Gaudi::Property< bool > m_doMuonTree
Definition: MuonPhysValMonitoringTool.h:156
MC::isStable
bool isStable(const T &p)
Identify if the particle is stable, i.e. has not decayed.
Definition: HepMCHelpers.h:45
lumiFormat.lumi
lumi
Definition: lumiFormat.py:106
a
TList * a
Definition: liststreamerinfos.cxx:10
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_trackSelector
ToolHandle< Trk::ITrackSelectorTool > m_trackSelector
Definition: MuonPhysValMonitoringTool.h:165
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
AthenaMonManager::forkedProcess
bool forkedProcess()
Definition: AthenaMonManager.cxx:322
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
ManagedMonitorToolBase::m_lastHigStatInterval
int m_lastHigStatInterval
Definition: ManagedMonitorToolBase.h:861
MuonPhysValMonitoring::MuonPhysValMonitoringTool::REST
@ REST
Definition: MuonPhysValMonitoringTool.h:80
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
Muons
Definition: Muons.py:1
LikeEnum::Medium
@ Medium
Definition: LikelihoodEnums.h:14
MuonPhysValMonitoring::MuonPhysValMonitoringTool::findRecoSlowMuon
const xAOD::SlowMuon * findRecoSlowMuon(const xAOD::TruthParticle *truthMu)
Definition: MuonPhysValMonitoringTool.cxx:1307
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass_ME
TH1F * m_h_overview_Z_mass_ME
Definition: MuonPhysValMonitoringTool.h:198
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonL2SAName
Gaudi::Property< std::string > m_muonL2SAName
Definition: MuonPhysValMonitoringTool.h:132
ManagedMonitorToolBase::Imp::benchPreBookHistograms
void benchPreBookHistograms()
Definition: ManagedMonitorToolBase.cxx:75
ManagedMonitorToolBase::m_nLumiBlocks
unsigned int m_nLumiBlocks
Definition: ManagedMonitorToolBase.h:865
AthenaMonManager::altprod
@ altprod
Definition: AthenaMonManager.h:49
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuonL1Trigger
void handleMuonL1Trigger(const xAOD::MuonRoI *TrigL1mu)
Definition: MuonPhysValMonitoringTool.cxx:1122
ManagedMonitorToolBase::eventsBlock
@ eventsBlock
Definition: ManagedMonitorToolBase.h:113
python.envutil.filelist
filelist
print ("Checking files %s..." % fullfile)
Definition: envutil.py:133
xAOD::IParticle::eta
virtual double eta() const =0
The pseudorapidity ( ) of the particle.
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vL2CBMuonsSelected
std::vector< const xAOD::L2CombinedMuon * > m_vL2CBMuonsSelected
Definition: MuonPhysValMonitoringTool.h:214
DEBUG
#define DEBUG
Definition: page_access.h:11
CaloCondBlobAlgs_fillNoiseFromASCII.author
string author
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:26
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_tracksName
Gaudi::Property< std::string > m_tracksName
Definition: MuonPhysValMonitoringTool.h:119
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
ManagedMonitorToolBase::all
@ all
Definition: ManagedMonitorToolBase.h:115
MuonPhysValMonitoring::MuonPhysValMonitoringTool::bookValidationPlots
StatusCode bookValidationPlots(PlotBase &valPlots)
Definition: MuonPhysValMonitoringTool.cxx:238
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_oUnmatchedRecoMuonTrackPlots
std::unique_ptr< Muon::RecoMuonTrackPlotOrganizer > m_oUnmatchedRecoMuonTrackPlots
Definition: MuonPhysValMonitoringTool.h:187
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:1634
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonsTruthName
Gaudi::Property< std::string > m_muonsTruthName
Definition: MuonPhysValMonitoringTool.h:123
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
covarianceTool.plots
plots
Definition: covarianceTool.py:698
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...
xAOD::TruthParticle_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition: TruthParticle_v1.cxx:166
xAOD::L2StandAloneMuon_v2::pt
virtual double pt() const
The transverse momentum ( ) of the particle.
ManagedMonitorToolBase::fillHistograms
virtual StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: ManagedMonitorToolBase.cxx:1307
ManagedMonitorToolBase::lbAverageLuminosity
virtual float lbAverageLuminosity(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
Definition: ManagedMonitorToolBase.cxx:1730
str
Definition: BTagTrackIpAccessor.cxx:11
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vRecoMuons_EffDen
std::vector< const xAOD::Muon * > m_vRecoMuons_EffDen
Definition: MuonPhysValMonitoringTool.h:218
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vZmumuMuons
std::vector< const xAOD::Muon * > m_vZmumuMuons
Definition: MuonPhysValMonitoringTool.h:208
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
ManagedMonitorToolBase::m_useTrigger
bool m_useTrigger
Definition: ManagedMonitorToolBase.h:857
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
xAOD::L2StandAloneMuon_v2::roiWord
uint32_t roiWord() const
Get the RoI ID of the seeding LVL1 muon.
ManagedMonitorToolBase::m_haveClearedLastEventBlock
bool m_haveClearedLastEventBlock
Definition: ManagedMonitorToolBase.h:866
AthenaMonManager::lumiBlockNumber
static unsigned int lumiBlockNumber()
Definition: AthenaMonManager.cxx:329
xAOD::TrackParticle_v1
Class describing a TrackParticle.
Definition: TrackParticle_v1.h:43
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonIDSelectedTrackValidationPlots
std::vector< std::unique_ptr< MuonTrackValidationPlots > > m_muonIDSelectedTrackValidationPlots
Definition: MuonPhysValMonitoringTool.h:182
MuonPhysValMonitoring::MuonPhysValMonitoringTool::modifyHistogram
void modifyHistogram(TH1 *hist)
Definition: MuonPhysValMonitoringTool.cxx:1445
ManagedMonitorToolBase::m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TH1 > > > m_templateHistograms
Definition: ManagedMonitorToolBase.h:664
ManagedMonitorToolBase::ATTRIB_X_VS_LB
@ ATTRIB_X_VS_LB
Definition: ManagedMonitorToolBase.h:130
MuonPhysValMonitoring::MuonPhysValMonitoringTool::handleMuon
void handleMuon(const xAOD::Muon *mu, const xAOD::SlowMuon *smu=nullptr, float weight=1.0)
Definition: MuonPhysValMonitoringTool.cxx:890
ManagedMonitorToolBase::Imp::s_svcLocator
static std::atomic< ISvcLocator * > s_svcLocator
Definition: ManagedMonitorToolBase.cxx:38
python.PyAthena.obj
obj
Definition: PyAthena.py:132
ManagedMonitorToolBase::m_trigTranslator
PublicToolHandle< ITriggerTranslatorTool > m_trigTranslator
Definition: ManagedMonitorToolBase.h:847
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
ManagedMonitorToolBase::m_lastMedStatInterval
int m_lastMedStatInterval
Definition: ManagedMonitorToolBase.h:861
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_slowMuonValidationPlots
std::vector< std::unique_ptr< SlowMuonValidationPlots > > m_slowMuonValidationPlots
Definition: MuonPhysValMonitoringTool.h:190
ManagedMonitorToolBase::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Definition: ManagedMonitorToolBase.h:680
MuonPhysValMonitoring::MuonPhysValMonitoringTool::ALL
@ ALL
Definition: MuonPhysValMonitoringTool.h:80
makeComparison.deltaR
float deltaR
Definition: makeComparison.py:36
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonItems
std::vector< std::string > m_muonItems
Definition: MuonPhysValMonitoringTool.h:111
xAOD::EventInfo_v1::beamSpotWeight
float beamSpotWeight() const
Weight for beam spot size reweighting.
Definition: EventInfo_v1.cxx:970
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:1346
merge
Definition: merge.py:1
AthenaMonManager::noOutput
@ noOutput
Definition: AthenaMonManager.h:49
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_h_overview_Z_mass
TH1F * m_h_overview_Z_mass
Definition: MuonPhysValMonitoringTool.h:197
ManagedMonitorToolBase::intervalEnumToString
static std::string intervalEnumToString(Interval_t interval)
Converts a LevelOfDetail_t to a string of the same name.
Definition: ManagedMonitorToolBase.cxx:537
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
MuonPhysValMonitoring::MuonPhysValMonitoringTool::getCorrectedMuon
std::unique_ptr< xAOD::Muon > getCorrectedMuon(const xAOD::Muon &mu)
Definition: MuonPhysValMonitoringTool.cxx:1425
fitman.k
k
Definition: fitman.py:528
xAOD::EventInfo_v1::eventType
bool eventType(EventType type) const
Check for one particular bitmask value.
ManagedMonitorToolBase::m_defaultLBDuration
float m_defaultLBDuration
Definition: ManagedMonitorToolBase.h:895
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_vEFMuonsSelected
std::vector< const xAOD::Muon * > m_vEFMuonsSelected
Definition: MuonPhysValMonitoringTool.h:210
xAOD::MuonRoI_v1::phi
float phi() const
The azimuthal angle ( ) of the muon candidate.
MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_isoTool
ToolHandle< CP::IIsolationSelectionTool > m_isoTool
Definition: MuonPhysValMonitoringTool.h:166