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

	ManagedMonitorToolBase (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters: More...

virtual StreamNameFcn *	streamNameFunction ()
	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 StreamNameFcn *	getNewStreamNameFcn () const

bool	newLowStatIntervalFlag () const
	Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called. 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

AthenaMonManager *	m_manager

std::string	m_managerNameProp

std::string	m_fileKey

std::string	m_dataTypeStr

std::string	m_environmentStr

unsigned int	m_detailLevel

AthenaMonManager::DataType_t	m_dataType

AthenaMonManager::Environment_t	m_environment

StreamNameFcn *	m_streamNameFcn

ServiceHandle< ITHistSvc >	m_THistSvc

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

PublicToolHandle< ITriggerTranslatorTool >	m_trigTranslator {this,"TriggerTranslatorTool",""}

ToolHandleArray< IDQFilterTool >	m_DQFilterTools {this,"FilterTools",{}}

long	m_procNEventsProp

std::string	m_path

long	m_preScaleProp

std::string	m_triggerChainProp

std::string	m_triggerGroupProp

bool	m_useTrigger

unsigned int	m_lastLumiBlock

unsigned int	m_lastRun

int	m_lastLowStatInterval

int	m_lastMedStatInterval

int	m_lastHigStatInterval

unsigned int	m_nEvents

unsigned int	m_nEventsIgnoreTrigger

unsigned int	m_nLumiBlocks

bool	m_haveClearedLastEventBlock

Private Types
enum	MUCATEGORY { ALL = 0, PROMPT, INFLIGHT, NONISO, REST }

using	TrackContKey_t = SG::ReadHandleKey< xAOD::TrackParticleContainer >

using	MuonContKey_t = SG::ReadHandleKey< xAOD::MuonContainer >

using	SegmentContKey_t = SG::ReadHandleKey< xAOD::MuonSegmentContainer >

using	MuonROIContKey_t = SG::ReadHandleKey< xAOD::MuonRoIContainer >

using	L2SAContKey_t = SG::ReadHandleKey< xAOD::L2StandAloneMuonContainer >

using	L2CBContKey_t = SG::ReadHandleKey< xAOD::L2CombinedMuonContainer >

using	SlowContKey_t = SG::ReadHandleKey< xAOD::SlowMuonContainer >

using	TruthPartKey_t = SG::ReadHandleKey< xAOD::TruthParticleContainer >

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	handleMuon (const xAOD::Muon mu, const xAOD::SlowMuon smu=nullptr, float weight=1.0)

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

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

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

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

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

void	handleMuonL1Trigger (const xAOD::MuonRoI *TrigL1mu)

void	handleMuonL2Trigger (const xAOD::L2StandAloneMuon *L2SAMu)

void	handleMuonL2Trigger (const xAOD::L2CombinedMuon *L2CBMu)

void	handleMuonTrigger (const xAOD::Muon *mu)

void	L2SATriggerResolution ()

void	L2CBTriggerResolution ()

void	EFTriggerResolution ()

void	printMuonDebug (const xAOD::Muon *mu)

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

StatusCode	bookValidationPlots (PlotBase &valPlots)

const xAOD::Muon *	findRecoMuon (const xAOD::TruthParticle *truthMu)

const xAOD::SlowMuon *	findRecoSlowMuon (const xAOD::TruthParticle *truthMu)

const xAOD::MuonSegment *	findRecoMuonSegment (const xAOD::MuonSegment *truthMuSeg)

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

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

void	modifyHistogram (TH1 *hist)

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

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

bool	passesAcceptanceCuts (const xAOD::IParticle *prt)

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

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

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &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::TrackParticleContainer *	m_MSTracks {nullptr}

std::map< std::string, int >	m_counterBits

std::vector< std::string >	m_muonItems

std::vector< std::string >	m_L1Seed

int	m_SelectedAuthor {0}

TrackContKey_t	m_tracksName {this, "TrackContainerName", "InDetTrackParticles"}

TrackContKey_t	m_fwdtracksName {this, "FwdTrackContainerName", ""}

MuonContKey_t	m_muonsName {this, "MuonContainerName", "Muons"}

SlowContKey_t	m_slowMuonsName {this, "SlowMuonContainerName", "SlowMuons"}

TruthPartKey_t	m_muonsTruthName {this, "MuonTruthParticleContainerName", "MuonTruthParticles"}

TrackContKey_t	m_muonTracksName {this, "MuonTrackContainerName", "MuonSpectrometerTrackParticles"}

TrackContKey_t	m_muonExtrapolatedTracksName {this, "MuonExtrapolatedTrackContainerName", "ExtrapolatedMuonTrackParticles"}

TrackContKey_t	m_muonMSOnlyExtrapolatedTracksName

SegmentContKey_t	m_muonSegmentsName {this, "MuonSegmentContainerName", "MuonSegments"}

SegmentContKey_t	m_muonSegmentsTruthName {this, "MuonTruthSegmentContainerName", "MuonTruthSegments"}

MuonROIContKey_t	m_muonL1TrigName {this, "L1TrigMuonContainerName", "LVL1MuonRoIs"}

L2SAContKey_t	m_muonL2SAName {this, "L2SAMuonContainerName", "HLT_xAOD__L2StandAloneMuonContainer_MuonL2SAInfo"}

L2CBContKey_t	m_muonL2CBName {this, "L2CBMuonContainerName", "HLT_xAOD__L2CombinedMuonContainer_MuonL2CBInfo"}

MuonContKey_t	m_muonEFCombTrigName {this, "EFCombTrigMuonContainerName", "HLT_xAOD__MuonContainer_MuonEFInfo"}

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

Gaudi::Property< std::vector< int > >	m_selectMuonWPs

Gaudi::Property< std::vector< unsigned int > >	m_selectMuonAuthors

Gaudi::Property< bool >	m_selectComissioning {this, "SelectComissioningMuons", false}
	Flag to tell whether muons with the comissioning author will be selected or not. 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_isData {this, "IsData", false}

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

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

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

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

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

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

std::vector< std::string >	m_selectMuonCategoriesStr

std::vector< std::unique_ptr< MuonValidationPlots > >	m_muonValidationPlots

std::vector< std::unique_ptr< TriggerMuonValidationPlots > >	m_TriggerMuonValidationPlots

std::vector< std::unique_ptr< MuonTrackValidationPlots > >	m_muonMSTrackValidationPlots

std::vector< std::unique_ptr< MuonTrackValidationPlots > >	m_muonMETrackValidationPlots

std::vector< std::unique_ptr< MuonTrackValidationPlots > >	m_muonMSOnlyMETrackValidationPlots

std::vector< std::unique_ptr< MuonTrackValidationPlots > >	m_muonIDTrackValidationPlots

std::vector< std::unique_ptr< MuonTrackValidationPlots > >	m_muonIDSelectedTrackValidationPlots

std::vector< std::unique_ptr< MuonTrackValidationPlots > >	m_muonIDForwardTrackValidationPlots

std::vector< std::unique_ptr< MuonSegmentValidationPlots > >	m_muonSegmentValidationPlots

std::unique_ptr< Muon::RecoMuonPlotOrganizer >	m_oUnmatchedRecoMuonPlots

std::unique_ptr< Muon::TruthMuonPlotOrganizer >	m_oUnmatchedTruthMuonPlots

std::unique_ptr< Muon::RecoMuonTrackPlotOrganizer >	m_oUnmatchedRecoMuonTrackPlots

std::unique_ptr< Muon::MuonSegmentPlots >	m_oUnmatchedRecoMuonSegmentPlots

std::vector< std::unique_ptr< SlowMuonValidationPlots > >	m_slowMuonValidationPlots

std::vector< TH1F * >	m_h_overview_nObjects

TH1F *	m_h_overview_reco_category {nullptr}

std::vector< TH1F * >	m_h_overview_reco_authors

TH1F *	m_h_overview_Z_mass {nullptr}

TH1F *	m_h_overview_Z_mass_ME {nullptr}

TH1F *	m_h_overview_Z_mass_ID {nullptr}

std::vector< const xAOD::TruthParticle * >	m_vMatchedTruthMuons

std::vector< const xAOD::Muon * >	m_vMatchedMuons

std::vector< const xAOD::SlowMuon * >	m_vMatchedSlowMuons

std::vector< const xAOD::TrackParticle * >	m_vMatchedMuonTracks

std::vector< const xAOD::MuonSegment * >	m_vMatchedMuonSegments

std::vector< const xAOD::TrackParticle * >	m_vZmumuIDTracks

std::vector< const xAOD::TrackParticle * >	m_vZmumuMETracks

std::vector< const xAOD::Muon * >	m_vZmumuMuons

std::vector< const xAOD::Muon * >	m_vEFMuons

std::vector< const xAOD::Muon * >	m_vEFMuonsSelected

std::vector< const xAOD::L2StandAloneMuon * >	m_vL2SAMuons

std::vector< const xAOD::L2StandAloneMuon * >	m_vL2SAMuonsSelected

std::vector< const xAOD::L2CombinedMuon * >	m_vL2CBMuons

std::vector< const xAOD::L2CombinedMuon * >	m_vL2CBMuonsSelected

std::vector< const xAOD::Muon * >	m_vRecoMuons

std::vector< const xAOD::Muon * >	m_vRecoMuons_EffDen_CB

std::vector< const xAOD::Muon * >	m_vRecoMuons_EffDen_MS

std::vector< const xAOD::Muon * >	m_vRecoMuons_EffDen

bool	m_newLowStatInterval

bool	m_newMedStatInterval

bool	m_newHigStatInterval

bool	m_newLowStat

bool	m_newLumiBlock

bool	m_newRun

bool	m_newEventsBlock

bool	m_endOfEventsBlock

bool	m_endOfLowStat

bool	m_endOfLumiBlock

bool	m_endOfRun

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

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

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

bool	m_bookHistogramsInitial

bool	m_useLumi

float	m_defaultLBDuration

std::set< Interval_t >	m_supportedIntervalsForRebooking

Imp *	m_d

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) 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

◆ L2CBContKey_t

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

private

Definition at line 120 of file MuonPhysValMonitoringTool.h.

◆ L2SAContKey_t

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

private

Definition at line 119 of file MuonPhysValMonitoringTool.h.

◆ MDMap_t

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

protectedinherited

Definition at line 826 of file ManagedMonitorToolBase.h.

◆ MuonContKey_t

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

private

Definition at line 116 of file MuonPhysValMonitoringTool.h.

◆ MuonROIContKey_t

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

private

Definition at line 118 of file MuonPhysValMonitoringTool.h.

◆ SegmentContKey_t

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

private

Definition at line 117 of file MuonPhysValMonitoringTool.h.

◆ SlowContKey_t

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

private

Definition at line 121 of file MuonPhysValMonitoringTool.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

◆ TrackContKey_t

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

private

Definition at line 115 of file MuonPhysValMonitoringTool.h.

◆ TruthPartKey_t

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

private

Definition at line 122 of file MuonPhysValMonitoringTool.h.

Member Enumeration Documentation

◆ Interval_t

enum ManagedMonitorToolBase::Interval_t

inherited

An enumeration describing how detailed a particular monitoring object is.

summary: used to summarize the state of the system

runstat: same as summary

shift: used to flag potential problems

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

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

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

Enumerator
file
eventsBlock
lumiBlock
lowStat
medStat
higStat
run
fill
all

Definition at line 113 of file ManagedMonitorToolBase.h.

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

◆ MgmtAttr_t

enum ManagedMonitorToolBase::MgmtAttr_t

inherited

An enumeration describing how the class handles the histogram.

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

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

Enumerator
ATTRIB_MANAGED
ATTRIB_UNMANAGED
ATTRIB_X_VS_LB

Definition at line 130 of file ManagedMonitorToolBase.h.

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

◆ MUCATEGORY

enum MuonPhysValMonitoring::MuonPhysValMonitoringTool::MUCATEGORY

private

Enumerator
ALL
PROMPT
INFLIGHT
NONISO
REST

Definition at line 79 of file MuonPhysValMonitoringTool.h.

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

Constructor & Destructor Documentation

◆ ~MuonPhysValMonitoringTool()

virtual MuonPhysValMonitoring::MuonPhysValMonitoringTool::~MuonPhysValMonitoringTool ( )

virtualdefault

Destructor:

Member Function Documentation

◆ bookHistograms()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::bookHistograms ( )

overridevirtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 133 of file MuonPhysValMonitoringTool.cxx.

                                                          {
         ATH_MSG_INFO("Booking hists " << name() << "...");
  
         if (m_selectMuonWPs.size() == 1 && m_selectMuonWPs[0] < 0) m_selectMuonWPs.clear();
  
         if (m_selectMuonAuthors.size() == 1 && m_selectMuonAuthors[0] == 0) m_selectMuonAuthors.clear();
  
         static const std::map<int,std::string> theMuonCategories = {
           {ALL, "All"},
           {PROMPT, "Prompt"},
           {INFLIGHT, "InFlight"},
           {NONISO, "NonIsolated"},
           {REST, "Rest"}
         };
  
         for (const auto& category : m_selectMuonCategories) m_selectMuonCategoriesStr.emplace_back(theMuonCategories.at(category));
  
         // no such muons in case of SlowMuon reco
         bool separateSAFMuons = m_slowMuonsName.empty();
         
         std::string muonContainerName = m_muonsName.key();
         for (const auto& category : m_selectMuonCategoriesStr) {
             std::string categoryPath = muonContainerName + "/" + category + "/";
  
             m_muonValidationPlots.emplace_back(std::make_unique<MuonValidationPlots>(
                 nullptr, categoryPath, m_selectMuonWPs, m_selectMuonAuthors, m_isData,
                 (category == theMuonCategories.at(ALL) ? false : m_doBinnedResolutionPlots.value()), separateSAFMuons, false));
  
             if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots.emplace_back(std::make_unique<SlowMuonValidationPlots>(nullptr, categoryPath, m_isData));
             if (m_doTrigMuonValidation) {
                 if (category == "All") {
                     m_TriggerMuonValidationPlots.emplace_back(std::make_unique<TriggerMuonValidationPlots>(
                         nullptr, categoryPath, m_selectMuonAuthors, m_isData, m_doTrigMuonL1Validation, m_doTrigMuonL2Validation,
                         m_doTrigMuonEFValidation, m_selectHLTMuonItems, m_L1MuonItems));
                 }
             }
             if (!m_muonTracksName.empty()) {
                 m_muonMSTrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "MSTrackParticles", m_isData));
                 if (!m_isData)
                     m_oUnmatchedRecoMuonTrackPlots = std::make_unique<Muon::RecoMuonTrackPlotOrganizer>(nullptr, muonContainerName + "/UnmatchedRecoMuonTracks/");
             }
             if (!m_muonExtrapolatedTracksName.empty())
                 m_muonMETrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "METrackParticles", m_isData));
             if (!m_muonMSOnlyExtrapolatedTracksName.empty())
                 m_muonMSOnlyMETrackValidationPlots.emplace_back(
                     std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "MSOnlyMETrackParticles", m_isData));
  
             if (!m_tracksName.empty()) {
                 m_muonIDTrackValidationPlots.emplace_back(std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDTrackParticles", m_isData));
                 m_muonIDSelectedTrackValidationPlots.emplace_back(
                     std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDSelectedTrackParticles", m_isData));
             }
             if (!m_fwdtracksName.empty())
                 m_muonIDForwardTrackValidationPlots.emplace_back(
                     std::make_unique<MuonTrackValidationPlots>(nullptr, categoryPath, "IDForwardTrackParticles", m_isData));
  
             if (!m_muonSegmentsName.empty()) {
                 if (category != theMuonCategories.at(ALL)) continue;  // cannot identify the truth origin of segments...
                 m_muonSegmentValidationPlots.emplace_back(std::make_unique<MuonSegmentValidationPlots>(nullptr, categoryPath, m_isData));
                 if (!m_isData)
                     m_oUnmatchedRecoMuonSegmentPlots.reset(
                         new Muon::MuonSegmentPlots(nullptr, Form("%s/UnmatchedRecoMuonSegments/", muonContainerName.c_str())));
             }
         }
  
         if (!m_isData) {
             m_oUnmatchedRecoMuonPlots = std::make_unique<Muon::RecoMuonPlotOrganizer>(nullptr, muonContainerName +"/UnmatchedRecoMuons/");
             m_oUnmatchedTruthMuonPlots = std::make_unique<Muon::TruthMuonPlotOrganizer>(nullptr, muonContainerName +"/UnmatchedTruthMuons/");
         }
  
         for (const auto& plots : m_muonValidationPlots) bookValidationPlots(*plots).ignore();
         for (const auto& plots : m_slowMuonValidationPlots) bookValidationPlots(*plots).ignore();
         for (const auto& plots : m_TriggerMuonValidationPlots) bookValidationPlots(*plots).ignore();
         for (const auto& plots : m_muonIDTrackValidationPlots) bookValidationPlots(*plots).ignore();
         for (const auto& plots : m_muonIDSelectedTrackValidationPlots) bookValidationPlots(*plots).ignore();
         for (const auto& plots : m_muonIDForwardTrackValidationPlots) bookValidationPlots(*plots).ignore();
         for (const auto& plots : m_muonMSTrackValidationPlots) bookValidationPlots(*plots).ignore();
         for (const auto& plots : m_muonMETrackValidationPlots) bookValidationPlots(*plots).ignore();
         for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) bookValidationPlots(*plots).ignore();
         if (!m_isData) {
             bookValidationPlots(*m_oUnmatchedRecoMuonPlots).ignore();
             bookValidationPlots(*m_oUnmatchedTruthMuonPlots).ignore();
             if (m_oUnmatchedRecoMuonTrackPlots) bookValidationPlots(*m_oUnmatchedRecoMuonTrackPlots).ignore();
             for (const auto& plots : m_muonSegmentValidationPlots) bookValidationPlots(*plots).ignore();
             if (m_oUnmatchedRecoMuonSegmentPlots) bookValidationPlots(*m_oUnmatchedRecoMuonSegmentPlots).ignore();
         }
         // book overview hists
         m_h_overview_Z_mass = new TH1F(Form("%s_Overview_Z_mass", muonContainerName.c_str()), "", 20, 76, 106);
         ATH_CHECK(regHist(m_h_overview_Z_mass, Form("%s/Overview", muonContainerName.c_str()), all));
         m_h_overview_Z_mass_ME = new TH1F(Form("%s_Overview_Z_mass_ME", muonContainerName.c_str()), "", 20, 76, 106);
         ATH_CHECK(regHist(m_h_overview_Z_mass_ME, Form("%s/Overview", muonContainerName.c_str()), all));
         m_h_overview_Z_mass_ID = new TH1F(Form("%s_Overview_Z_mass_ID", muonContainerName.c_str()), "", 20, 76, 106);
         ATH_CHECK(regHist(m_h_overview_Z_mass_ID, Form("%s/Overview", muonContainerName.c_str()), all));
  
         m_h_overview_nObjects.clear();
         m_h_overview_nObjects.emplace_back(new TH1F(Form("%s_Overview_N_perevent_truth_muons", muonContainerName.c_str()),
                                                  "Number of truth Muons per event", 20, -0.5, 19.5));
         m_h_overview_nObjects.emplace_back(
             new TH1F(Form("%s_Overview_N_perevent_muons", muonContainerName.c_str()), "Number of Muons per event", 20, -0.5, 19.5));
         m_h_overview_nObjects.emplace_back(
             new TH1F(Form("%s_Overview_N_perevent_tracks", muonContainerName.c_str()), "Number of Tracks per event", 50, -0.5, 49.5));
         m_h_overview_nObjects.emplace_back(new TH1F(Form("%s_Overview_N_perevent_truth_segments", muonContainerName.c_str()),
                                                  "Number of truth Segments per event", 200, -0.5, 199.5));
         m_h_overview_nObjects.emplace_back(
             new TH1F(Form("%s_Overview_N_perevent_segments", muonContainerName.c_str()), "Number of Segments per event", 200, -0.5, 199.5));
         for (const auto& hist : m_h_overview_nObjects) {
             if (hist) ATH_CHECK(regHist(hist, Form("%s/Overview", muonContainerName.c_str()), all));
         }
  
         m_h_overview_reco_category =
             new TH1F(Form("%s_Overview_reco_category", muonContainerName.c_str()), "", 4, 0, 4);  // prompt/in-flight/non-isolated/other
         for (int i = 1; i < 4; i++) {                                                             // skip 'All'
             m_h_overview_reco_category->GetXaxis()->SetBinLabel(i, theMuonCategories.at(i).c_str());
         }
         m_h_overview_reco_category->GetXaxis()->SetBinLabel(4, "Other");  // of some other origin or fakes
         ATH_CHECK(regHist(m_h_overview_reco_category, Form("%s/Overview", muonContainerName.c_str()), all));
  
         int nAuth = xAOD::Muon::NumberOfMuonAuthors;
         for (int i = 1; i < 4; i++) {
             m_h_overview_reco_authors.emplace_back(new TH1F((muonContainerName + "_" + theMuonCategories.at(i) + "_reco_authors").c_str(),
                                                          (muonContainerName + "_" + theMuonCategories.at(i) + "_reco_authors").c_str(),
                                                          nAuth + 1, -0.5, nAuth + 0.5));
         }
         m_h_overview_reco_authors.emplace_back(new TH1F((muonContainerName + "_Overview_Other_reco_authors").c_str(),
                                                      (muonContainerName + "_Other_reco_authors").c_str(), nAuth + 1, -0.5, nAuth + 0.5));
  
         for (const auto& hist : m_h_overview_reco_authors) {
             if (hist) ATH_CHECK(regHist(hist, Form("%s/Overview", muonContainerName.c_str()), all));
         }
  
         return StatusCode::SUCCESS;
     }//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.

 {
    if( m_newEventsBlock ) { }
    if( m_newLumiBlock ) { }
    if( m_newRun ) { }
  
    return StatusCode::SUCCESS;
 }

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

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

◆ bookValidationPlots()

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

private

Definition at line 266 of file MuonPhysValMonitoringTool.cxx.

                                                                                 {
         valPlots.initialize();
         std::vector<HistData> hists = valPlots.retrieveBookedHistograms();
  
         for (auto& hist : hists) {
             TString sHistName = hist.first->GetName();
             ATH_MSG_VERBOSE("Initializing " << hist.first << " " << sHistName << " " << hist.second << "...");
  
             // check for histograms that are useless and skip regHist:
             if (sHistName.Contains("momentumPulls")) {
                 if (sHistName.Contains(Muon::EnumDefs::toString(xAOD::Muon::MuidSA))) continue;  // empty for standalone muons
                 if (!(sHistName.Contains("Prompt") && (sHistName.Contains("AllMuons") || sHistName.Contains("SiAssocForward"))))
                     continue;  // don't need binned eloss plots for separate muon types, keep only for Prompt AllMuons
             }
             if ((sHistName.Contains("resolution") || sHistName.Contains("pulls")) && !sHistName.Contains("Prompt"))
                 continue;  // don't need resolution plots except for prompt muons
             if (sHistName.Contains("trigger") && sHistName.Contains("wrt") && sHistName.Contains("Features")) continue;
             modifyHistogram(hist.first);
             ATH_CHECK(regHist(hist.first, hist.second, all));
         }
  
         // register trees
         std::vector<TreeData> trees = valPlots.retrieveBookedTrees();
         for (auto& tree : trees) {
             std::string sTreeName = tree.first->GetName();
             ATH_MSG_VERBOSE("Initializing " << tree.first << " " << sTreeName << " " << tree.second << "...");
             ATH_CHECK(regTree(tree.first, tree.second, all));
         }
  
         return StatusCode::SUCCESS;
     }

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

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

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
  
   }

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

   {
     return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                        hndl.value(), 
                                                        hndl.documentation());
   }

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

   {
     return PBASE::declareProperty(t);
   }

◆ 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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl.vhKey());
     hndl.vhKey().setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

◆ 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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

   {
     this->declare(hndl);
     hndl.setOwner(this);
  
     return PBASE::declareProperty(name,hndl,doc);
   }

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

   {
  
     // std::ostringstream ost;
     // ost << Algorithm::name() << " VHKA declareProp: " << name 
     //     << " size: " << hndArr.keys().size() 
     //     << " mode: " << hndArr.mode() 
     //     << "  vhka size: " << m_vhka.size()
     //     << "\n";
     // debug() << ost.str() << endmsg;
  
     hndArr.setOwner(this);
     m_vhka.push_back(&hndArr);
  
     Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
     if (p != 0) {
       p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
     } else {
       ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                     << name);
     }
  
     return p;
  
   }

◆ 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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

◆ 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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                  {
     typedef typename SG::HandleClassifier<T>::type htype;
     return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
   }

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

 {
    return m_THistSvc->deReg( g );
 }

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

 {
    return m_THistSvc->deReg( h );
 }

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

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

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

 {
    MonGroup group( this, system, interval );
    return deregObject( objName, group );
 }

◆ detStore()

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

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ EFTriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::EFTriggerResolution ( )

private

Definition at line 1232 of file MuonPhysValMonitoringTool.cxx.

                                                         {
         int k_EFMu_MinDeltaR = -1;
         float MinDeltaR = 0.;
         std::vector<int> vAvailableAuthors;
         vAvailableAuthors.clear();
         vAvailableAuthors.emplace_back(m_vEFMuons[0]->author());
         unsigned int iter = 0;
         for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
             iter = 0;
             for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
                 if (m_vEFMuons[k]->author() != vAvailableAuthors[l]) iter++;
             }
             if (iter == vAvailableAuthors.size()) vAvailableAuthors.emplace_back(m_vEFMuons[k]->author());
         }
         ATH_MSG_DEBUG(" m_vEFMuons.size()" << m_vEFMuons.size());
         for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
             ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << "  eta=" << m_vRecoMuons.at(i)->eta() << "  phi="
                                                             << m_vRecoMuons.at(i)->phi() << "    auth=" << m_vRecoMuons.at(i)->author());
         }
         for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
             if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
             ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << "  eta=" << m_vRecoMuons.at(i)->eta()
                                                   << "  phi=" << m_vRecoMuons.at(i)->phi() << "    auth=" << m_vRecoMuons.at(i)->author());
             for (unsigned int l = 0; l < vAvailableAuthors.size(); l++) {
                 k_EFMu_MinDeltaR = -1;
                 MinDeltaR = 1000;
                 for (unsigned int k = 0; k < m_vEFMuons.size(); k++) {
                     ATH_MSG_DEBUG("  :::::::: TEST: EF pt=" << m_vEFMuons.at(k)->pt() << "  eta=" << m_vEFMuons.at(k)->eta()
                                                             << "  phi=" << m_vEFMuons.at(k)->phi()
                                                             << "  DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k))
                                                             << "  author=" << m_vEFMuons.at(k)->author());
                     if (m_vEFMuons.at(k)->author() == vAvailableAuthors.at(l) &&
                         (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < 0.1 &&
                          (deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k)) < MinDeltaR))) {
                         k_EFMu_MinDeltaR = k;
                         MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vEFMuons.at(k));
                     }
                 }
                 if (k_EFMu_MinDeltaR == -1) continue;
                 for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
                     if (m_selectMuonCategories[c] == ALL) {
                         m_TriggerMuonValidationPlots[c]->fill(*m_vEFMuons.at(k_EFMu_MinDeltaR), *m_vRecoMuons.at(i));
                     }
                 }
             }
         }
     }

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

                                                          {
         ATH_MSG_DEBUG("Filling hists " << name() << "...");
         m_vMatchedTruthMuons.clear();
         m_vMatchedMuons.clear();
         m_vMatchedSlowMuons.clear();
         m_vMatchedMuonTracks.clear();
         m_vMatchedMuonSegments.clear();
         m_vZmumuIDTracks.clear();
         m_vZmumuMETracks.clear();
         m_vZmumuMuons.clear();
         m_vEFMuons.clear();
         m_vEFMuonsSelected.clear();
         m_vL2SAMuons.clear();
         m_vL2SAMuonsSelected.clear();
         m_vL2CBMuons.clear();
         m_vL2CBMuonsSelected.clear();
         m_vRecoMuons.clear();
         m_vRecoMuons_EffDen.clear();
         m_vRecoMuons_EffDen_CB.clear();
         m_vRecoMuons_EffDen_MS.clear();
  
         const EventContext& ctx{Gaudi::Hive::currentContext()};
         const xAOD::EventInfo* eventInfo{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_eventInfo, eventInfo));
  
         float beamSpotWeight = eventInfo->beamSpotWeight();
  
         const xAOD::TruthParticleContainer* TruthMuons{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_muonsTruthName, TruthMuons));
         
         if (!m_isData) {
             m_h_overview_nObjects[0]->Fill(TruthMuons->size(), beamSpotWeight);
         }
  
         const xAOD::MuonContainer* Muons = nullptr;
         const xAOD::SlowMuonContainer* SlowMuons{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_slowMuonsName, SlowMuons));
         ATH_CHECK(retrieveContainer(ctx, m_muonsName, Muons));
         if (SlowMuons) {           
             ATH_MSG_DEBUG("Retrieved slow muons " << SlowMuons->size());
             m_h_overview_nObjects[1]->Fill(SlowMuons->size(), beamSpotWeight);
         } 
         if (Muons) {
             ATH_MSG_DEBUG("Retrieved muons " << Muons->size());
             m_h_overview_nObjects[1]->Fill(Muons->size(), beamSpotWeight);
         }
  
         // @@@ Temp hack to get the MuonSpectrometerTrackParticle (@MS Entry, not extrapolated), needed for eloss plots
         // Remove when the link to the real MuonSpectrometerTrackParticle appears in the xAOD muon
         ATH_CHECK(retrieveContainer(ctx, m_muonTracksName, m_MSTracks));
  
         // Do resonance selection
         std::vector<std::pair<const xAOD::Muon*, const xAOD::Muon*> > pairs;
         if (Muons) {
             // Use iterator loop to avoid double counting
             for (xAOD::MuonContainer::const_iterator mu1_itr = Muons->begin(); mu1_itr != Muons->end(); ++mu1_itr) {
                 const xAOD::Muon* mu1 = (*mu1_itr);
                 if (!m_selectComissioning && mu1->allAuthors() & comm_bit) continue;
                 for (xAOD::MuonContainer::const_iterator mu2_itr = Muons->begin(); mu2_itr != mu1_itr; ++mu2_itr) {
                     const xAOD::Muon* mu2 = (*mu2_itr);
                     if (!m_selectComissioning && mu2->allAuthors() & comm_bit) continue;                
                     if (mu1->charge() * mu2->charge() >= 0) continue;
                     pairs.emplace_back(std::make_pair(mu1, mu2));
                 }
             }
         }
  
         float dMmin {1e10}, mZ{0.};
         for (std::pair<const xAOD::Muon*, const xAOD::Muon*>& x : pairs) {
             // select best Z
             const TLorentzVector mu1{x.first->p4()}, mu2{x.second->p4()};
             const float M = (mu1 + mu2).M();
             if (M < 66000. || M > 116000.) continue;
  
             // choose the Z candidate closest to the Z pole - if multiple exist
             float dM = std::abs(M - 91187.);
             if (dM > dMmin) continue;
             dMmin = dM;
             mZ = M;
  
             m_vZmumuMuons.clear();
             m_vZmumuMuons.emplace_back(x.first);
             m_vZmumuMuons.emplace_back(x.second);
         }
  
         if (m_vZmumuMuons.size() == 2) {
             m_h_overview_Z_mass->Fill(mZ / 1000., beamSpotWeight);
  
             const xAOD::TrackParticle* metr1 = m_vZmumuMuons[0]->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
             const xAOD::TrackParticle* metr2 = m_vZmumuMuons[1]->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle);
             if (metr1 && metr2) {
                 const TLorentzVector mu1ME{metr1->p4()}, mu2ME{metr2->p4()};
                 m_h_overview_Z_mass_ME->Fill((mu1ME + mu2ME).M() / 1000., beamSpotWeight);
                 if (m_isData) {
                     m_vZmumuMETracks.clear();
                     m_vZmumuMETracks.emplace_back(metr1);
                     m_vZmumuMETracks.emplace_back(metr2);
                 }
             }
  
             const xAOD::TrackParticle* tr1 = m_vZmumuMuons[0]->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
             const xAOD::TrackParticle* tr2 = m_vZmumuMuons[1]->trackParticle(xAOD::Muon::InnerDetectorTrackParticle);
             if (tr1 && tr2) {
                 const TLorentzVector mu1ID{tr1->p4()}, mu2ID{tr2->p4()};
                 m_h_overview_Z_mass_ID->Fill((mu1ID + mu2ID).M() / 1000., beamSpotWeight);
                 if (m_isData) {
                     m_vZmumuIDTracks.clear();
                     m_vZmumuIDTracks.emplace_back(tr1);
                     m_vZmumuIDTracks.emplace_back(tr2);
                 }
             }
         }
  
         if (!m_isData) {
             for (const auto truthMu : *TruthMuons) handleTruthMuon(truthMu, beamSpotWeight);
         }
  
         if (SlowMuons) {
             for (const auto smu : *SlowMuons) {
                 if (!smu) continue;
                 const MuonLink link = smu->muonLink();
                 if (!link.isValid()) continue;
                 handleMuon(*link, smu, beamSpotWeight);
             }
         }  
         if (Muons) {
             for (const xAOD::Muon* mu : *Muons) {
                 handleMuon(mu, nullptr, beamSpotWeight);
             }
         }
  
         const xAOD::TrackParticleContainer* IDTracks{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_tracksName, IDTracks));
         if (IDTracks) {
             ATH_MSG_DEBUG("handling " << IDTracks->size() << " " << m_tracksName);
             for (const auto tp : *IDTracks) handleMuonTrack(tp, xAOD::Muon::InnerDetectorTrackParticle, beamSpotWeight);
         }
         const xAOD::TrackParticleContainer* FwdIDTracks{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_fwdtracksName, IDTracks));
         if (FwdIDTracks) {            
             ATH_MSG_DEBUG("handling " << FwdIDTracks->size() << " " << m_fwdtracksName);
             for (const auto tp : *FwdIDTracks) handleMuonTrack(tp, xAOD::Muon::InnerDetectorTrackParticle, beamSpotWeight);
         }
         const xAOD::TrackParticleContainer*  MuonTracks{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_muonTracksName, MuonTracks));
         if (MuonTracks) {           
             ATH_MSG_DEBUG("handling " << MuonTracks->size() << " " << m_muonTracksName);
             m_h_overview_nObjects[2]->Fill(MuonTracks->size(), beamSpotWeight);
             for (const auto tp : *MuonTracks) handleMuonTrack(tp, xAOD::Muon::MuonSpectrometerTrackParticle, beamSpotWeight);
         }
         const xAOD::TrackParticleContainer* MuonExtrapolatedTracks{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_muonExtrapolatedTracksName, MuonExtrapolatedTracks));
         if (MuonExtrapolatedTracks) {
             ATH_MSG_DEBUG("handling " << MuonExtrapolatedTracks->size() << " " << m_muonExtrapolatedTracksName);
             for (const auto tp : *MuonExtrapolatedTracks)
                 handleMuonTrack(tp, xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle, beamSpotWeight);
         }
         const xAOD::TrackParticleContainer* MSOnlyMuonExtrapolatedTracks{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_muonMSOnlyExtrapolatedTracksName, MSOnlyMuonExtrapolatedTracks));
  
         if (MSOnlyMuonExtrapolatedTracks) {
             ATH_MSG_DEBUG("handling " << MSOnlyMuonExtrapolatedTracks->size() << " " << m_muonMSOnlyExtrapolatedTracksName);
             for (const auto tp : *MSOnlyMuonExtrapolatedTracks)
                 handleMuonTrack(tp, xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle, beamSpotWeight);
         }
  
         const xAOD::MuonSegmentContainer* TruthMuonSegments{nullptr}; 
         ATH_CHECK(retrieveContainer(ctx, m_muonSegmentsTruthName, TruthMuonSegments));
         if (TruthMuonSegments) {
             m_h_overview_nObjects[3]->Fill(TruthMuonSegments->size(), beamSpotWeight);
             ATH_MSG_DEBUG("handling " << TruthMuonSegments->size() << " " << m_muonSegmentsTruthName);
             for (const auto truthMuSeg : *TruthMuonSegments) handleTruthMuonSegment(truthMuSeg, TruthMuons, beamSpotWeight);
         }
  
         const xAOD::MuonSegmentContainer* MuonSegments{nullptr};
         ATH_CHECK(retrieveContainer(ctx, m_muonSegmentsName, MuonSegments));
         if (MuonSegments) {
             m_h_overview_nObjects[4]->Fill(MuonSegments->size(), beamSpotWeight);
             ATH_MSG_DEBUG("handling " << MuonSegments->size() << " " << m_muonSegmentsName);
             for (const auto muSeg : *MuonSegments) handleMuonSegment(muSeg, beamSpotWeight);
         }
  
         //@@@@@@@@@@@@@@@@ TRIGGER MONITORING IMPLEMENTATION @@@@@@@@@@@@@@@@@
         if (m_doTrigMuonValidation) {            
             auto chainGroups = m_trigDec->getChainGroup("HLT_.*mu.*");
             for (auto& trig : chainGroups->getListOfTriggers()) {
                 if (m_trigDec->isPassed(trig, TrigDefs::EF_passedRaw)) {
                     ATH_MSG_DEBUG("Chain " << trig << " is passed: YES");
                 } else
                     ATH_MSG_DEBUG("Chain " << trig << " is passed: NO");
             }
             auto L1chainGroups = m_trigDec->getChainGroup("L1_MU.*");
             for (auto& L1trig : L1chainGroups->getListOfTriggers()) {
                 if (m_trigDec->isPassed(L1trig, TrigDefs::EF_passedRaw))
                     ATH_MSG_DEBUG("Chain " << L1trig << " is passed: YES");
                 else
                     ATH_MSG_DEBUG("Chain " << L1trig << " is passed: NO");
             }
             for (auto mu : m_vRecoMuons) {
                 if (passesAcceptanceCuts(mu) && std::abs(mu->eta()) < 2.4) {
                     if (mu->author() == 1) {
                         m_vRecoMuons_EffDen_CB.emplace_back(mu);
                         ATH_MSG_DEBUG("##### m_vRecoMuons_EffDen_CB  pt:" << mu->pt() << "   phi:" << mu->phi() << "   eta:" << mu->eta());
                     } else if (mu->author() == 5) {
                         m_vRecoMuons_EffDen_MS.emplace_back(mu);
                         ATH_MSG_DEBUG("##### m_vRecoMuons_EffDen_MS  pt:" << mu->pt() << "   phi:" << mu->phi() << "   eta:" << mu->eta());
                     }
                 }
             }
  
             //@@@@@ L1 @@@@@
             if (m_doTrigMuonL1Validation) {
                 const xAOD::MuonRoIContainer* L1TrigMuons{nullptr};
                 ATH_CHECK(retrieveContainer(ctx, m_muonL1TrigName, L1TrigMuons));
                 ATH_MSG_DEBUG("Retrieved L1 triggered muons " << L1TrigMuons->size());
                 for (const auto TrigL1mu : *L1TrigMuons) handleMuonL1Trigger(TrigL1mu);
             }
  
             //@@@@@ L2 @@@@@
             if (m_doTrigMuonL2Validation) {
                 //@@@@@ L2SA @@@@@
                 const xAOD::L2StandAloneMuonContainer* L2SAMuons{nullptr};
                 ATH_CHECK(retrieveContainer(ctx, m_muonL2SAName, L2SAMuons));
                 ATH_MSG_DEBUG("Retrieved L2 StandAlone triggered muons " << L2SAMuons->size());
                 if (L2SAMuons->size() != 0) {
                     for (const auto L2SAmu : *L2SAMuons) {
                         ATH_MSG_DEBUG("Muon L2SA Trigger: pt " << L2SAmu->pt() << " phi " << L2SAmu->phi() << " eta " << L2SAmu->eta()
                                                                << " roiWord " << L2SAmu->roiWord() << " sAddress " << L2SAmu->sAddress());
                         m_vL2SAMuons.emplace_back(L2SAmu);
                     }
                     for (const auto& mu : m_vL2SAMuons) {
                         if (mu->pt() != 0.) {
                             m_vL2SAMuonsSelected.emplace_back(mu);
                             break;
                         }
                     }
                     for (unsigned int i = 0; i < m_vL2SAMuons.size(); i++) {
                         unsigned int cont = 0;
                         for (unsigned int j = 0; j < m_vL2SAMuonsSelected.size(); j++) {
                             if (((m_vL2SAMuons.at(i)->pt()) != 0.) && ((deltaR(m_vL2SAMuonsSelected.at(j), m_vL2SAMuons.at(i))) > 0.1))
                                 cont++;
                             if (cont == m_vL2SAMuonsSelected.size()) {
                                 m_vL2SAMuonsSelected.emplace_back(m_vL2SAMuons.at(i));
                                 break;
                             }
                         }
                     }
                     for (unsigned int i = 0; i < m_vL2SAMuonsSelected.size(); i++) { handleMuonL2Trigger(m_vL2SAMuonsSelected.at(i)); }
                     L2SATriggerResolution();
                 }
                 for (const auto& muonItem : m_muonItems) {
                     std::vector<Trig::Feature<xAOD::L2StandAloneMuonContainer> > vec_muons;
                     TString muonItem_str = (TString)muonItem;
                     if (muonItem_str.Contains("_OR_")) {
                         muonItem_str.ReplaceAll("_OR_", " ");
                         TString delim = " ";
                         std::vector<TString> v_subchains;
                         SplitString(muonItem_str, delim, v_subchains);
                         for (int i = 0; i < (int)v_subchains.size(); i++) {
                             Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
                             std::vector<Trig::Feature<xAOD::L2StandAloneMuonContainer> > vec_muons_1 =
                                 fc1.get<xAOD::L2StandAloneMuonContainer>();
                             for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
                         }
                     } else {
                         Trig::FeatureContainer fc = m_trigDec->features(muonItem);
                         vec_muons = fc.get<xAOD::L2StandAloneMuonContainer>();
                     }
                     ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::L2StandAloneMuonContainer> for chain " << muonItem << " = "
                                                                                                              << vec_muons.size());
                     for (const auto& mufeat : vec_muons) {
                         ATH_MSG_DEBUG(muonItem << "  vec_muons.size() = " << vec_muons.size()
                                                << "  mufeat.cptr()->size() = " << mufeat.cptr()->size());
                         for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
                             ATH_MSG_DEBUG("#####" << muonItem << "  L2SA feature pt: " << (*mufeat.cptr())[i]->pt()
                                                   << "   eta: " << (*mufeat.cptr())[i]->eta() << "   phi: " << (*mufeat.cptr())[i]->phi());
                         }
                     }
                 }
  
                 //@@@@@ L2CB @@@@@
                 
                 const xAOD::L2CombinedMuonContainer* L2CBMuons{nullptr};
                 ATH_CHECK(retrieveContainer(ctx, m_muonL2CBName, L2CBMuons));
                 ATH_MSG_DEBUG("Retrieved L2 Combined triggered muons " << L2CBMuons->size());
                 if (L2CBMuons->size() != 0) {
                     for (const auto L2CBmu : *L2CBMuons) {
                         ATH_MSG_DEBUG("Muon L2CB Trigger: pt " << L2CBmu->pt() << " phi " << L2CBmu->phi() << " eta " << L2CBmu->eta());
                         m_vL2CBMuons.emplace_back(L2CBmu);
                     }
                     for (unsigned int i = 0; i < m_vL2CBMuons.size(); i++) {
                         if ((m_vL2CBMuons.at(i)->pt()) != 0.) {
                             m_vL2CBMuonsSelected.emplace_back(m_vL2CBMuons.at(i));
                             break;
                         }
                     }
                     for (unsigned int i = 0; i < m_vL2CBMuons.size(); i++) {
                         unsigned int cont = 0;
                         for (unsigned int j = 0; j < m_vL2CBMuonsSelected.size(); j++) {
                             if (((m_vL2CBMuons.at(i)->pt()) != 0.) && ((deltaR(m_vL2CBMuonsSelected.at(j), m_vL2CBMuons.at(i))) > 0.1))
                                 cont++;
                             if (cont == m_vL2CBMuonsSelected.size()) {
                                 m_vL2CBMuonsSelected.emplace_back(m_vL2CBMuons.at(i));
                                 break;
                             }
                         }
                     }
                     for (unsigned int i = 0; i < m_vL2CBMuonsSelected.size(); i++) { handleMuonL2Trigger(m_vL2CBMuonsSelected.at(i)); }
                     L2CBTriggerResolution();
                 }
                 for (const auto& muonItem : m_muonItems) {
                     std::vector<Trig::Feature<xAOD::L2CombinedMuonContainer> > vec_muons;
                     TString muonItem_str = (TString)muonItem;
                     if (muonItem_str.Contains("_OR_")) {
                         muonItem_str.ReplaceAll("_OR_", " ");
                         TString delim = " ";
                         std::vector<TString> v_subchains;
                         SplitString(muonItem_str, delim, v_subchains);
                         for (int i = 0; i < (int)v_subchains.size(); i++) {
                             Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
                             std::vector<Trig::Feature<xAOD::L2CombinedMuonContainer> > vec_muons_1 =
                                 fc1.get<xAOD::L2CombinedMuonContainer>();
                             for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
                         }
                     } else {
                         Trig::FeatureContainer fc = m_trigDec->features(muonItem);
                         vec_muons = fc.get<xAOD::L2CombinedMuonContainer>();
                     }
                     ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::L2CombinedMuonContainer> for chain " << muonItem << " = "
                                                                                                            << vec_muons.size());
                     for (const auto& mufeat : vec_muons) {
                         ATH_MSG_DEBUG(muonItem << "  vec_muons.size() = " << vec_muons.size()
                                                << "  mufeat.cptr()->size() = " << mufeat.cptr()->size());
                         for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
                             ATH_MSG_DEBUG("#####" << muonItem << "  L2CB feature pt: " << (*mufeat.cptr())[i]->pt()
                                                   << "   eta: " << (*mufeat.cptr())[i]->eta() << "   phi: " << (*mufeat.cptr())[i]->phi());
                         }
                     }
                 }
             }  // close if(m_doTrigMuonL2Validation)
  
             //@@@@@ EF @@@@@
             if (m_doTrigMuonEFValidation) {
                 const xAOD::MuonContainer* EFCombTrigMuons{nullptr};
                 const xAOD::MuonRoIContainer* L1TrigMuons{nullptr};
                 ATH_CHECK(retrieveContainer(ctx, m_muonEFCombTrigName, EFCombTrigMuons));
                 ATH_CHECK(retrieveContainer(ctx, m_muonL1TrigName, L1TrigMuons));
                 ATH_MSG_DEBUG("Retrieved EF triggered muons " << EFCombTrigMuons->size());
                 if (EFCombTrigMuons->size() != 0) {
                     for (const auto Trigmu : *EFCombTrigMuons) {
                         ATH_MSG_DEBUG("Muon EF Trigger: pt " << Trigmu->pt() << " phi " << Trigmu->phi() << " eta " << Trigmu->eta()
                                                              << "   author" << Trigmu->author());
                         m_vEFMuons.emplace_back(Trigmu);
                     }
                     m_vEFMuonsSelected.emplace_back(m_vEFMuons.at(0));
                     for (unsigned int i = 0; i < m_vEFMuons.size(); i++) {
                         unsigned int cont = 0;
                         for (unsigned int j = 0; j < m_vEFMuonsSelected.size(); j++) {
                             if (((deltaR(m_vEFMuonsSelected.at(j), m_vEFMuons.at(i))) > 0.1) ||
                                 ((m_vEFMuons.at(i)->author() - m_vEFMuonsSelected.at(j)->author()) != 0))
                                 cont++;
                             if (cont == m_vEFMuonsSelected.size()) {
                                 m_vEFMuonsSelected.emplace_back(m_vEFMuons.at(i));
                                 break;
                             }
                         }
                     }
                     for (unsigned int i = 0; i < m_vEFMuonsSelected.size(); i++) { handleMuonTrigger(m_vEFMuonsSelected.at(i)); }
                     EFTriggerResolution();
                 }
                 if (!m_isData) {
                     for (const auto truthMu : *TruthMuons) {
                         ATH_MSG_DEBUG("TRUTH:: pt=" << truthMu->pt() << "  eta=" << truthMu->eta() << "  phi=" << truthMu->phi());
                     }
                 }
                 // handleMuonTrigger_ResoWRTTruth(m_vEFMuonsSelected,)
                 //@@@@@ chains efficiency @@@@@
                 for (const auto& muonItem : m_muonItems) {
                     m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
                     m_SelectedAuthor = 1;
                     if ((muonItem.find("msonly") != std::string::npos)) {
                         m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_MS;
                         m_SelectedAuthor = 5;
                     }
                     std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons;
                     TString muonItem_str = (TString)muonItem;
                     if (muonItem_str.Contains("_OR_")) {
                         muonItem_str.ReplaceAll("_OR_", " ");
                         TString delim = " ";
                         std::vector<TString> v_subchains;
                         SplitString(muonItem_str, delim, v_subchains);
                         for (int i = 0; i < (int)v_subchains.size(); i++) {
                             Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
                             std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons_1 = fc1.get<xAOD::MuonContainer>();
                             for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
                         }
                     } else {
                         Trig::FeatureContainer fc = m_trigDec->features(muonItem);
                         vec_muons = fc.get<xAOD::MuonContainer>();
                     }
                     ATH_MSG_DEBUG("Size of vector Trig::Feature<xAOD::MuonContainer> for chain " << muonItem << " = " << vec_muons.size());
                     for (const auto& mufeat : vec_muons) {
                         ATH_MSG_DEBUG(muonItem << "  vec_muons.size() = " << vec_muons.size()
                                                << "  mufeat.cptr()->size() = " << mufeat.cptr()->size());
                         for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
                             ATH_MSG_DEBUG("#####" << muonItem << "  EF feature pt: " << (*mufeat.cptr())[i]->pt()
                                                   << "   eta: " << (*mufeat.cptr())[i]->eta() << "   phi: " << (*mufeat.cptr())[i]->phi()
                                                   << "   author: " << (*mufeat.cptr())[i]->author());
                             for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
                                 if (m_selectMuonCategories[j] == ALL) {
                                     if (((*mufeat.cptr())[i]->author()) == m_SelectedAuthor)
                                         m_TriggerMuonValidationPlots[j]->fillFeatPlots(*(*mufeat.cptr())[i], muonItem);
                                 }  // if categ=ALL
                             }      // categories
                         }          // mufeat.cptr
                     }              // mufeat
                     for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
                         bool break_flag = false;
                         for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
                             if (m_selectMuonCategories[j] == ALL) {
                                 m_TriggerMuonValidationPlots[j]->fillDenEff(*m_vRecoMuons_EffDen.at(k), muonItem);
                             }
                         }
                         for (const auto& mufeat : vec_muons) {
                             for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
                                 if ((((*mufeat.cptr())[i]->author()) == m_SelectedAuthor) &&
                                     (deltaR((*mufeat.cptr())[i], m_vRecoMuons_EffDen.at(k)) < 0.1)) {
                                     break_flag = true;
                                     ATH_MSG_DEBUG("   $$$ match Reco_EffDen "
                                                   << muonItem << "         pt: " << m_vRecoMuons_EffDen.at(k)->pt() << "   eta: "
                                                   << m_vRecoMuons_EffDen.at(k)->eta() << "   phi: " << m_vRecoMuons_EffDen.at(k)->phi()
                                                   << "   author: " << m_vRecoMuons_EffDen.at(k)->author());
                                     ATH_MSG_DEBUG("   $$$ match EF MuidCo feature "
                                                   << muonItem << "   pt: " << (*mufeat.cptr())[i]->pt()
                                                   << "   eta: " << (*mufeat.cptr())[i]->eta() << "   phi: " << (*mufeat.cptr())[i]->phi()
                                                   << "   author: " << (*mufeat.cptr())[i]->author() << "    rel_p "
                                                   << (std::abs(((*mufeat.cptr())[i]->pt() - m_vRecoMuons_EffDen.at(k)->pt()) /
                                                                (m_vRecoMuons_EffDen.at(k)->pt()))));
                                     for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
                                         if (m_selectMuonCategories[j] == ALL) {
                                             m_TriggerMuonValidationPlots[j]->fillNumEff(*m_vRecoMuons_EffDen.at(k), muonItem);
                                             // if (muonItem=="HLT_2mu10") m_TriggerMuonValidationPlots[j]->fill(
                                             // *(*mufeat.cptr())[i],*m_vRecoMuons_EffDen.at(k));
  
                                         }  // if categ=ALL
                                     }      // categories
                                     break;
                                 }  // if(Delta_R)
                             }      // mufeat
                             if (break_flag) break;
                         }  // vec_muons
                     }      // m_vRecoMuons_EffDen
                 }          // m_muonItems
                 //@@@@@ L1 items efficiency @@@@@
                 for (const auto& L1MuonItem : m_L1MuonItems) {
                     m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
                     m_SelectedAuthor = 1;
                     float threshold = 0.;
                     if (L1MuonItem == "L1_MU4") threshold = 4000;
                     else if (L1MuonItem == "L1_MU6") threshold = 6000;
                     else if (L1MuonItem == "L1_MU10") threshold = 10000;
                     else if (L1MuonItem == "L1_MU11") threshold = 11000;
                     else if (L1MuonItem == "L1_MU15") threshold = 15000;
                     else if (L1MuonItem == "L1_MU20") threshold = 20000;
                     for (const auto TrigL1mu : *L1TrigMuons) {
                         for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
                             if (m_selectMuonCategories[j] == ALL) {
                                 if ((TrigL1mu->thrValue()) >= threshold)
                                     m_TriggerMuonValidationPlots[j]->fillFeatPlots(*TrigL1mu, L1MuonItem);
                             }  // if categ=ALL
                         }      // categories
                     }          // L1TrigMuons
                     for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
                         for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
                             if (m_selectMuonCategories[j] == ALL) {
                                 m_TriggerMuonValidationPlots[j]->fillDenL1Eff(*m_vRecoMuons_EffDen.at(k), L1MuonItem);
                             }
                         }
                         for (const auto TrigL1mu : *L1TrigMuons) {
                             if (((TrigL1mu->thrValue()) >= threshold) &&
                                 (sqrt(pow(m_vRecoMuons_EffDen.at(k)->eta() - TrigL1mu->eta(), 2.) +
                                       pow(m_vRecoMuons_EffDen.at(k)->phi() - TrigL1mu->phi(), 2.)) < 0.2)) {
                                 ATH_MSG_DEBUG("   $$$ match Reco_EffDen "
                                               << L1MuonItem << "         pt: " << m_vRecoMuons_EffDen.at(k)->pt() << "   eta: "
                                               << m_vRecoMuons_EffDen.at(k)->eta() << "   phi: " << m_vRecoMuons_EffDen.at(k)->phi()
                                               << "   author: " << m_vRecoMuons_EffDen.at(k)->author());
                                 ATH_MSG_DEBUG("   $$$ L1 feature " << L1MuonItem << "   pt: " << TrigL1mu->thrValue()
                                                                    << "   eta: " << TrigL1mu->eta() << "   phi: " << TrigL1mu->phi());
                                 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
                                     if (m_selectMuonCategories[j] == ALL) {
                                         m_TriggerMuonValidationPlots[j]->fillNumL1Eff(*m_vRecoMuons_EffDen.at(k), L1MuonItem);
                                     }  // if categ=ALL
                                 }      // categories
                                 break;
                             }  // if(Delta_R)
                         }      // L1TrigMuons
                     }          // m_vRecoMuons_EffDen
                 }
                 //@@@@@ chains efficiency w.r.t. L1 @@@@@
                 for (unsigned int m = 0; m < m_muonItems.size(); m++) {
                     std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons;
                     TString muonItem_str = (TString)m_muonItems[m];
                     if (muonItem_str.Contains("_OR_")) {
                         muonItem_str.ReplaceAll("_OR_", " ");
                         TString delim = " ";
                         std::vector<TString> v_subchains;
                         SplitString(muonItem_str, delim, v_subchains);
                         for (int i = 0; i < (int)v_subchains.size(); i++) {
                             Trig::FeatureContainer fc1 = m_trigDec->features((std::string)v_subchains.at(i));
                             std::vector<Trig::Feature<xAOD::MuonContainer> > vec_muons_1 = fc1.get<xAOD::MuonContainer>();
                             for (const auto& mufeat : vec_muons_1) { vec_muons.emplace_back(mufeat); }
                         }
                     } else {
                         Trig::FeatureContainer fc = m_trigDec->features(m_muonItems[m]);
                         vec_muons = fc.get<xAOD::MuonContainer>();
                     }
                     m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_CB;
                     m_SelectedAuthor = 1;
                     if ((m_muonItems[m].find("msonly") != std::string::npos)) {
                         m_vRecoMuons_EffDen = m_vRecoMuons_EffDen_MS;
                         m_SelectedAuthor = 5;
                     }
                     float threshold = 0.;
                     if (m_L1Seed[m] == "L1_MU4") threshold = 4000;
                     if (m_L1Seed[m] == "L1_MU6") threshold = 6000;
                     if (m_L1Seed[m] == "L1_MU10") threshold = 10000;
                     if (m_L1Seed[m] == "L1_MU11") threshold = 11000;
                     if (m_L1Seed[m] == "L1_MU15") threshold = 15000;
                     if (m_L1Seed[m] == "L1_MU20") threshold = 20000;
                     for (unsigned int k = 0; k < m_vRecoMuons_EffDen.size(); k++) {
                         bool break_flag = false;
                         for (const auto TrigL1mu : *L1TrigMuons) {
                             if (((TrigL1mu->thrValue()) >= threshold) &&
                                 (sqrt(pow(m_vRecoMuons_EffDen.at(k)->eta() - TrigL1mu->eta(), 2.) +
                                       pow(m_vRecoMuons_EffDen.at(k)->phi() - TrigL1mu->phi(), 2.)) < 0.2)) {
                                 for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
                                     if (m_selectMuonCategories[j] == ALL) {
                                         m_TriggerMuonValidationPlots[j]->fillDenRELEff(*m_vRecoMuons_EffDen.at(k), m_muonItems[m]);
                                     }  // if categ=ALL
                                 }      // categories
                                 for (const auto& mufeat : vec_muons) {
                                     for (unsigned int i = 0; i < mufeat.cptr()->size(); i++) {
                                         if ((((*mufeat.cptr())[i]->author()) == m_SelectedAuthor) &&
                                             (deltaR((*mufeat.cptr())[i], m_vRecoMuons_EffDen.at(k)) < 0.1)) {
                                             break_flag = true;
                                             for (unsigned int j = 0; j < m_selectMuonCategories.size(); j++) {
                                                 if (m_selectMuonCategories[j] == ALL) {
                                                     m_TriggerMuonValidationPlots[j]->fillNumRELEff(*m_vRecoMuons_EffDen.at(k),
                                                                                                    m_muonItems[m]);
                                                 }  // if categ=ALL
                                             }      // categories
                                             break;
                                         }  // if(Delta_R)
                                     }      // mufeat
                                     if (break_flag) break;
                                 }  // vec_muons
                                 break;
                             }  // if(Delta_R)
                         }      // L1TrigMuons
                     }          // m_vRecoMuons_EffDen
                 }              // m_muonItems.size()
             }                  // m_doTrigMuonEFValidation
         }
         return StatusCode::SUCCESS;
     }//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.

 {
  
    if (m_d->m_warnAboutMissingInitialize) {
        m_d->m_warnAboutMissingInitialize = false;
        msg(MSG::WARNING) << "ManagedMonitorToolBase::initialize() never called from reimplementation!" << endmsg;
    }
  
  
    bool isNewEventsBlock = ( m_procNEventsProp > 0  && ((m_nEvents % m_procNEventsProp) == 1) && m_haveClearedLastEventBlock );
    if (isNewEventsBlock) m_haveClearedLastEventBlock = false;
  
    m_newLowStat = false;
    m_newLumiBlock = false;
    m_newRun = false;
    newLowStat = false;
    newLumiBlock = false;
    newRun = false;
  
    m_newLowStatInterval = false;
    m_newMedStatInterval = false;
    m_newHigStatInterval = false;
    newLowStatInterval = false;
    newMedStatInterval = false;
    newHigStatInterval = false;
    
    m_useTrigger = ( (m_triggerChainProp != "" || m_triggerGroupProp != "")  && (!m_trigDecTool.empty()) );
  
    if( m_manager != 0 ) {
      m_newLumiBlock = ( (m_lastLumiBlock != m_manager->lumiBlockNumber()) || m_manager->forkedProcess());
       m_newRun = ( m_lastRun != m_manager->runNumber() );
       newLumiBlock = m_newLumiBlock;
       newRun = m_newRun;
  
       if(m_newRun) {
          m_newLumiBlock = true;
          newLumiBlock = m_newLumiBlock;
          isNewEventsBlock = true;
       }
  
       m_newEventsBlock = isNewEventsBlock;
       newEventsBlock = m_newEventsBlock;
  
       if( m_newLumiBlock ) {
          // check if a new LB interval has started
          // lowest lumiBlockNumber() is 1
          // m_lastLowStatInterval is -1 initially
          int currentLB = m_manager->lumiBlockNumber();
          int LBsLowStat = m_manager->getLBsLowStat();
          int LBsMedStat = m_manager->getLBsMedStat();
          int LBsHigStat = m_manager->getLBsHigStat();
  
          if( LBsLowStat*LBsMedStat*LBsHigStat == 0) {
             msg(MSG::WARNING) << "zero LBs requested for interval" << endmsg;
          }
          else {
             if( ((currentLB-1)/LBsLowStat) != m_lastLowStatInterval ) m_newLowStatInterval = true;
             if( ((currentLB-1)/LBsMedStat) != m_lastMedStatInterval ) m_newMedStatInterval = true;
             if( ((currentLB-1)/LBsHigStat) != m_lastHigStatInterval ) m_newHigStatInterval = true;
             newLowStatInterval = m_newLowStatInterval;
             newMedStatInterval = m_newHigStatInterval;
             newHigStatInterval = m_newHigStatInterval;
          }
       }
  
       // Allow inheriting classes the option of using the lastLumiBloc/lastRun values
       // before updating them
    }
  
  
    StatusCode sc0( StatusCode::SUCCESS );
    StatusCode sc1( StatusCode::SUCCESS );
    StatusCode sc2( StatusCode::SUCCESS );
    StatusCode sc3( StatusCode::SUCCESS );
  
    // Set end of LowStat, LumiBlock and Run variables
    // These are needed to be used in procHistograms().
    m_endOfEventsBlock = m_newEventsBlock;
    m_endOfLowStat = m_newLowStatInterval;
    m_endOfLumiBlock = m_newLumiBlock;
    m_endOfRun = m_newRun;
    endOfEventsBlock = m_newEventsBlock;
    endOfLowStat = m_newLowStatInterval;
    endOfLumiBlock = m_newLumiBlock;
    endOfRun = m_newRun;
  
    // just duplicates m_newLowStatInterval
    m_newLowStat = m_newLowStatInterval; 
    newLowStat = m_newLowStatInterval; 
  
    if( m_newEventsBlock || m_newLumiBlock || m_newRun ) {
      ATH_MSG_DEBUG("Interval transition processing");
       // Process histograms from the previous lumiBlock/run
       if( m_nEvents != 1 ) {
          m_d->benchPreProcHistograms();
          sc0 = procHistograms();
          m_d->benchPostProcHistograms();
       }
       // Re-book new histograms
       m_d->benchPreBookHistograms();
  
       if (!m_bookHistogramsInitial) {
           sc1 = bookHistograms();
           m_bookHistogramsInitial = true;
       } else {
           std::vector<Interval_t> intervals_to_process;
           if (m_newEventsBlock) intervals_to_process.push_back(eventsBlock);
           if (m_newLumiBlock) intervals_to_process.push_back(lumiBlock);
           if (m_newLowStatInterval) intervals_to_process.push_back(lowStat);
           if (m_newRun) intervals_to_process.push_back(run);
           for (const auto interval: intervals_to_process) {
             sc1 = regManagedHistograms(m_templateHistograms[interval]);     
             sc1 = regManagedGraphs(m_templateGraphs[interval]);
             sc1 = regManagedTrees(m_templateTrees[interval]);
           }
       }
       for (const auto& interval: std::vector<Interval_t>{ eventsBlock, lumiBlock, lowStat, run }) {
     for (const auto& it: m_templateHistograms[interval]) {
       // is histogram too small in x axis for LB range?
       if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
         //ATH_MSG_WARNING("We are rebinning for " << it.m_templateHist->GetName());
         while ( it.m_templateHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
           it.m_templateHist->LabelsInflate("X");
         }
       }
     }
         for (auto& it: m_templateEfficiencies[interval]) {
       if (it.m_group.histo_mgmt() == ATTRIB_X_VS_LB) {
         // get the underlying passed and total TH1's from the TEfficiency
         TH1* passedHist = it.m_templateHist->GetCopyPassedHisto();
         TH1* totalHist = it.m_templateHist->GetCopyTotalHisto();
         // inflate them until they exceed the lumi-block number
         while (passedHist->GetXaxis()->GetXmax() <= AthenaMonManager::lumiBlockNumber() ) {
           passedHist->LabelsInflate("X");
           totalHist->LabelsInflate("X");
               }
         // Replace them in the TEfficiency. First one has force ("f") option, since the 
         // histograms will not be consistent. This is corrected in the next line, so we
         // do check for consistency then.
         it.m_templateHist->SetPassedHistogram(*passedHist, "f");
         it.m_templateHist->SetTotalHistogram(*totalHist, " ");
         delete passedHist; // not owned by THistSvc, so need to be deleted.
         delete totalHist;
       }
         }
       }
  
       if (auto streamname = dynamic_cast<OfflineStream*>(streamNameFunction())) {
     streamname->updateRunLB();
       }
       
       sc3 = bookHistogramsRecurrent( );
       
       m_d->benchPostBookHistograms();
  
    }//end if new RUN/LB/Block
  
    // check filters
    bool filterresult(true);
    if (! m_DQFilterTools.empty()) {
      ToolHandleArray<IDQFilterTool>::const_iterator ifilter(m_DQFilterTools.begin()), filterend(m_DQFilterTools.end());
      for (; filterresult && (ifilter != filterend);
       ++ifilter) {
        filterresult = (filterresult && (*ifilter)->accept());
      }
    }
    
  
    // ...and fill as normal
    if(filterresult &&
       (!m_useTrigger
        || (m_vTrigChainNames.size()>0 && trigChainsArePassed(m_vTrigChainNames))
        || (m_vTrigGroupNames.size()>0 && trigChainsArePassed(m_vTrigGroupNames))) ) {
      ATH_MSG_DEBUG("Passed trigger, presumably");
       m_d->benchPreFillHistograms();
       fillHistograms().ignore();
       m_haveClearedLastEventBlock = true;
       m_d->benchPostFillHistograms();
       ++m_nEvents;
    } else { ATH_MSG_DEBUG("Failed trigger, presumably"); }
  
    ++m_nEventsIgnoreTrigger;
    if( m_newLumiBlock && (m_nEventsIgnoreTrigger != 1) ) {
       ++m_nLumiBlocks;
    }
    if( m_manager != 0 ) {
       m_lastRun = m_manager->runNumber();
       if( m_newLumiBlock ) {
          m_lastLumiBlock = m_manager->lumiBlockNumber();
  
          int LBsLowStat = m_manager->getLBsLowStat();
          int LBsMedStat = m_manager->getLBsMedStat();
          int LBsHigStat = m_manager->getLBsHigStat();
          if( LBsLowStat*LBsMedStat*LBsHigStat > 0) {
             if( m_newLowStatInterval ) m_lastLowStatInterval = (m_lastLumiBlock-1)/LBsLowStat;
             if( m_newMedStatInterval ) m_lastMedStatInterval = (m_lastLumiBlock-1)/LBsMedStat;
             if( m_newHigStatInterval ) m_lastHigStatInterval = (m_lastLumiBlock-1)/LBsHigStat;
          }
       }
    }
  
    return StatusCode::SUCCESS;
 }

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

 {
  
    // This assumes that the end of a file will naturally end a run, which is not always true.
    // A merging application run afterwards should be able to put parts of a run together.
    if( m_nEvents != 1 ) {
      m_d->benchPreProcHistograms();
  
      // Set end flags for the LowStat, LumiBlock and Run variables.
      // This is needed to be used in the procHistograms method below.
      m_endOfEventsBlock = true;
      m_endOfLowStat = true;
      m_endOfLumiBlock = true;
      m_endOfRun = true;
      endOfEventsBlock = true;
      endOfLowStat = true;
      endOfLumiBlock = true;
      endOfRun = true;
  
      StatusCode sc = procHistograms();
  
      m_d->benchPostProcHistograms();
      return sc;
    }
    return StatusCode::SUCCESS;
 }

◆ findHistogram()

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

private

Definition at line 1364 of file MuonPhysValMonitoringTool.cxx.

                                                                                                         {
         TH1F* h = nullptr;
         for (const auto& hist : hists) {
             if (hist.second.find(hdirTag) != std::string::npos || hdirTag.empty()) {
                 std::string histname = hist.first->GetName();
                 if (histname.find(hnameTag) != std::string::npos) {
                     h = (TH1F*)hist.first->Clone(hNewName.c_str());
                     return h;
                 }
             }
         }
         return h;
     }

◆ findRecoMuon()

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

private

Definition at line 1290 of file MuonPhysValMonitoringTool.cxx.

                                                                                             {
         static const SG::ConstAccessor<MuonLink> acc_muon("recoMuonLink");
         if (!acc_muon.isAvailable(*truthMu)) return nullptr;
         MuonLink link = acc_muon(*truthMu);
         if (!link.isValid()) return nullptr;
         const xAOD::Muon* reco_mu = (*link);
         if (!m_selectComissioning && reco_mu->allAuthors() & comm_bit) return nullptr;
         m_vMatchedMuons.emplace_back(reco_mu);
         return reco_mu;
     }

◆ findRecoMuonSegment()

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

private

Definition at line 1349 of file MuonPhysValMonitoringTool.cxx.

                                                                                                            {
         static const SG::ConstAccessor<MuonSegmentLink> recoSegmentLinkAcc("recoSegmentLink");
         if (!recoSegmentLinkAcc.isAvailable(*truthMuSeg)) {
             ATH_MSG_DEBUG("recoSegmentLink not found");
             return nullptr;
         }
         MuonSegmentLink link = recoSegmentLinkAcc(*truthMuSeg);
         if (!link.isValid()) {
             ATH_MSG_DEBUG("recoSegmentLink not valid");
             return nullptr;
         }
         m_vMatchedMuonSegments.emplace_back(*link);
         return (*link);
     }

◆ findRecoSlowMuon()

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

private

Definition at line 1301 of file MuonPhysValMonitoringTool.cxx.

                                                                                                     {
         const xAOD::SlowMuonContainer* SlowMuons = nullptr;
         retrieveContainer(Gaudi::Hive::currentContext() , m_slowMuonsName, SlowMuons).ignore();
         if (!SlowMuons) return nullptr;
         for (const auto smu : *SlowMuons) {
             const MuonLink muLink = smu->muonLink();
             if (!muLink.isValid()) continue;
             float DR = deltaR(*muLink , truthMu);
             if (DR < 0.005) {
                 m_vMatchedSlowMuons.emplace_back(smu);
                 return smu;
             }
         }
  
         return nullptr;
     }

◆ get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const

inlineprotectedinherited

Definition at line 692 of file ManagedMonitorToolBase.h.

                                               {
           return m_nEvents; 
       }

◆ get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const

inlineprotectedinherited

Definition at line 696 of file ManagedMonitorToolBase.h.

                                               {
           return m_procNEventsProp;
       }

◆ getCorrectedMuon()

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

private

Definition at line 1412 of file MuonPhysValMonitoringTool.cxx.

                                                                                           {
         std::unique_ptr<xAOD::Muon> mu_c;
         if (mu.m() <= 0) return mu_c;
         mu_c = std::make_unique<xAOD::Muon>();
         mu_c->makePrivateStore(mu);
  
         // add decorations too fool the muon selector tool
         const xAOD::TrackParticle* idtrk{mu_c->trackParticle(xAOD::Muon::InnerDetectorTrackParticle)};
         const xAOD::TrackParticle* metrk{mu_c->trackParticle(xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)};
         if (idtrk && metrk) {
             const static SG::Decorator<float> InnerDetectorPtDec("InnerDetectorPt");
             const static SG::Decorator<float> MuonSpectrometerPtDec("MuonSpectrometerPt");
             InnerDetectorPtDec(*mu_c) = idtrk->pt();
             MuonSpectrometerPtDec(*mu_c) = metrk->pt();
         }
         m_muonSelectionTool->setQuality(*mu_c);
         m_muonSelectionTool->setPassesIDCuts(*mu_c);
         return mu_c;
     }

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

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

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

 {
    MonGroup group( this, system, interval );
    return getHist( h, hName, group );
 }

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

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

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

 {
    MonGroup group( this, system, interval );
    return getHist( h, hName, group );
 }

◆ getMuonSegmentTruthCategory()

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

private

Definition at line 1379 of file MuonPhysValMonitoringTool.cxx.

                                                                                                  {
         static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
         TruthLink truthLink;
         if (truthParticleLinkAcc.isAvailable(*truthMuSeg)) {
             truthLink = truthParticleLinkAcc(*truthMuSeg);
             if (truthLink.isValid()) {
               const int theUniqueID = HepMC::uniqueID(*truthLink);
               if (std::abs((*truthLink)->pdgId()) != 13) return REST;
  
               for (const auto muTruthPart : *muonTruthContainer) {
                 if ( HepMC::uniqueID(muTruthPart) == theUniqueID ) { return getMuonTruthCategory(muTruthPart); }
               }
             }
         } else
             ATH_MSG_WARNING("No truth link available for muon truth segment");
  
         return REST;
     }

◆ getMuonTruthCategory()

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

private

Definition at line 1399 of file MuonPhysValMonitoringTool.cxx.

                                                                                                                {
         static const SG::ConstAccessor<int> truthTypeAcc("truthType");
         static const SG::ConstAccessor<int> truthOriginAcc("truthOrigin");
         int truthType = truthTypeAcc(*mu);
         if (truthType == 6)
             return PROMPT;
         else if (truthType == 8 && (truthOriginAcc(*mu) == 34 || truthOriginAcc(*mu) == 35))
             return INFLIGHT;
         else if (truthType == 7)
             return NONISO;
         return REST;
     }

◆ getNewStreamNameFcn()

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

protectedvirtualinherited

Definition at line 2157 of file ManagedMonitorToolBase.cxx.

 {
    StreamNameFcn* fcn(0);
  
    switch( m_environment ) {
       case AthenaMonManager::noOutput:
          fcn = new NoOutputStream();
          break;
       case AthenaMonManager::online:
          fcn = new OnlineStream();
          break;
       case AthenaMonManager::user:
          fcn = new DefaultStream( m_fileKey );
          break;
       case AthenaMonManager::tier0:
       case AthenaMonManager::tier0Raw:
       case AthenaMonManager::tier0ESD:
       case AthenaMonManager::AOD:
       case AthenaMonManager::altprod:
       default:
          fcn = new OfflineStream( m_fileKey, m_dataType, m_environment );
    }
  
    return fcn;
 }

◆ handleMuon()

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

private

Definition at line 898 of file MuonPhysValMonitoringTool.cxx.

                                                                                                         {
         if (!mu) return;
         if (!m_selectComissioning && mu->allAuthors() & comm_bit) return;
  
         if (msgLvl(MSG::DEBUG)) printMuonDebug(mu);
  
         // make deep copy of muon and decorate with quality
         std::unique_ptr<xAOD::Muon> mu_c;
         try {
             mu_c = getCorrectedMuon(*mu);
         } catch (const SG::ExcBadAuxVar&) {
             ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
             return;
         }
  
         if (m_isData) {
             MUCATEGORY thisMuonCategory = ALL;
             // for events with a Zmumu candidate, separate Z muons from the rest:
             if (m_vZmumuMuons.size() > 0) {
                 thisMuonCategory = REST;
                 if (std::find(m_vZmumuMuons.begin(), m_vZmumuMuons.end(), mu) != m_vZmumuMuons.end()) { thisMuonCategory = PROMPT; }
             }
             // fill plots
             for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
                 if (m_selectMuonCategories[i] == ALL or m_selectMuonCategories[i] == thisMuonCategory) {
                   if (mu_c){
                     // histos
                     m_muonValidationPlots[i]->fill(*mu_c, weight);
                     if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
                     // tree branches
                     m_muonValidationPlots[i]->fillTreeBranches(*mu_c);
                   }
                 }
             }
         }
  
         // SELECT MUON MEDIUM QUALITY FOR TRIGGER VALIDATION
         xAOD::Muon::Quality my_quality = m_muonSelectionTool->getQuality(*mu_c);
         if (my_quality <= xAOD::Muon::Medium && m_isoTool->accept(*mu_c)) m_vRecoMuons.emplace_back(mu);
  
         if (smu) {
             if (std::find(std::begin(m_vMatchedSlowMuons), std::end(m_vMatchedSlowMuons), smu) != std::end(m_vMatchedSlowMuons)) { return; }
         } else {
             if (std::find(std::begin(m_vMatchedMuons), std::end(m_vMatchedMuons), mu) != std::end(m_vMatchedMuons)) { return; }
         }
  
         // unmatched reco muons (not matched with any kind of truth particle, fakes)
         if (!m_isData) m_oUnmatchedRecoMuonPlots->fill(*mu_c, weight);
  
         m_h_overview_reco_category->Fill("Other", weight);
         m_h_overview_reco_authors[3]->Fill(mu->author(), weight);
  
         for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
             if (m_selectMuonCategories[i] == ALL) {
                 if (mu_c){// histos
                   m_muonValidationPlots[i]->fill(*mu_c);
                   if (smu) m_slowMuonValidationPlots[i]->fill(*smu, *mu_c, weight);
                   // tree branches
                   m_muonValidationPlots[i]->fillTreeBranches(*mu_c);
                   break;
                 }
             }
         }
     }

◆ handleMuonL1Trigger()

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

private

Definition at line 1116 of file MuonPhysValMonitoringTool.cxx.

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

◆ handleMuonL2Trigger() [1/2]

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

private

Definition at line 1174 of file MuonPhysValMonitoringTool.cxx.

                                                                                         {
         for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
             if (m_selectMuonCategories[i] == ALL) {
                 m_TriggerMuonValidationPlots[i]->fill(*L2CBMu);
                 break;
             }
         }
         ATH_MSG_DEBUG("   ==> Geometrical selection of Muon L2CB Trigger :  pt " << L2CBMu->pt() << " phi " << L2CBMu->phi() << " eta "
                                                                                  << L2CBMu->eta());
     }

◆ handleMuonL2Trigger() [2/2]

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

private

Definition at line 1126 of file MuonPhysValMonitoringTool.cxx.

                                                                                           {
         for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
             if (m_selectMuonCategories[i] == ALL) {
                 m_TriggerMuonValidationPlots[i]->fill(*L2SAMu);
                 break;
             }
         }
         ATH_MSG_DEBUG("   ==> Geometrical selection of Muon L2SA Trigger :  pt " << L2SAMu->pt() << " phi " << L2SAMu->phi() << " eta "
                                                                                  << L2SAMu->eta() << " roiWord " << L2SAMu->roiWord()
                                                                                  << " sAddress " << L2SAMu->sAddress());
     }

◆ handleMuonSegment()

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

private

Definition at line 882 of file MuonPhysValMonitoringTool.cxx.

                                                                                                 {
         if (!muSeg) {
             ATH_MSG_WARNING("No muon segment found");
             return;
         }
         if (std::find(std::begin(m_vMatchedMuonSegments), std::end(m_vMatchedMuonSegments), muSeg) != std::end(m_vMatchedMuonSegments))
             return;
         if (!m_isData) m_oUnmatchedRecoMuonSegmentPlots->fill(*muSeg, weight);
         for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
             if (m_selectMuonCategories[i] == ALL) {
                 m_muonSegmentValidationPlots[i]->fill(muSeg, weight);
                 break;
             }
         }
     }

◆ handleMuonTrack()

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

private

Definition at line 1015 of file MuonPhysValMonitoringTool.cxx.

                                                                                                                              {
         if (!tp) {
             ATH_MSG_WARNING("No track particle found");
             return;
         }
  
         // if ID track, check that it passes standard combined mu reco selections
         bool passesMuonTrackSel = false;
         if (type == xAOD::Muon::InnerDetectorTrackParticle) { passesMuonTrackSel = m_trackSelector->decision(*tp); }
  
         if (m_isData) {
             if (type == xAOD::Muon::InnerDetectorTrackParticle) {
                 MUCATEGORY thisTrkCategory = ALL;
                 // for events with a Zmumu candidate, separate Z muon tracks from the rest:
                 if (m_vZmumuIDTracks.size() > 0) {
                     thisTrkCategory = REST;
                     for (const auto& zmu : m_vZmumuIDTracks) {
                         if (deltaR(zmu,  tp) < 0.01) {
                             thisTrkCategory = PROMPT;
                             break;
                         }
                     }
                 }
  
                 for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
                     if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisTrkCategory) {
                         m_muonIDTrackValidationPlots[i]->fill(*tp, weight);
                         if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*tp, weight);
                     }
                 }
             } else if (type == xAOD::Muon::MuonSpectrometerTrackParticle)
                 m_muonMSTrackValidationPlots[ALL]->fill(*tp, weight);
             else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle)
                 m_muonMETrackValidationPlots[ALL]->fill(*tp, weight);
             else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle)
                 m_muonMSOnlyMETrackValidationPlots[ALL]->fill(*tp, weight);
  
             return;
         }
  
         static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
         TruthLink truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
  
         if (!truthLink.isValid()) {
             ATH_MSG_DEBUG("No truth link available");
             if (type == xAOD::Muon::InnerDetectorTrackParticle) return;
             if (!passesAcceptanceCuts(tp)) return;
  
             for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
                 if (m_selectMuonCategories[i] == ALL) {
                     // ID track plots for any track
                     // if (type==xAOD::Muon::InnerDetectorTrackParticle) {
                     //   m_muonIDTrackValidationPlots[i]->fill(*tp);
                     //   if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*tp);
                     // } else
                     if (type == xAOD::Muon::MuonSpectrometerTrackParticle) {
                         if (!m_isData) m_oUnmatchedRecoMuonTrackPlots->fill(*tp, weight);
                         m_muonMSTrackValidationPlots[i]->fill(*tp, weight);
                     } else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) {
                         m_muonMETrackValidationPlots[i]->fill(*tp, weight);
                     } else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle) {
                         m_muonMSOnlyMETrackValidationPlots[i]->fill(*tp, weight);
                     }
                     break;
                 }
             }
         }       // end if no valid truth link
         else {  // here: valid truth link and truthType
  
             if (type ==
                 xAOD::Muon::InnerDetectorTrackParticle) {  // don't fill histograms for any ID track, only for muons; buys a lot of time
                 if ((*truthLink)->absPdgId() != 13 || !MC::isStable(*truthLink)) return;     // not a muon
                 if (HepMC::uniqueID(*truthLink) == HepMC::UNDEFINED_ID || HepMC::is_simulation_particle((*truthLink))) return;  // must have valid barcode
             }
  
             if (!passesAcceptanceCuts(*truthLink)) return;
             unsigned int thisMuonCategory = getMuonTruthCategory(tp);
  
             for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
                 if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
                     if (type == xAOD::Muon::InnerDetectorTrackParticle) {
                         if (!m_fwdtracksName.empty() && std::abs((*truthLink)->eta()) > 2.5)
                             m_muonIDForwardTrackValidationPlots[i]->fill(*truthLink, tp, weight);
                         else if (!m_tracksName.empty()) {
                             m_muonIDTrackValidationPlots[i]->fill(*truthLink, tp, weight);
                             if (passesMuonTrackSel) m_muonIDSelectedTrackValidationPlots[i]->fill(*truthLink, tp, weight);
                         }
                     } else if (type == xAOD::Muon::MuonSpectrometerTrackParticle) {
                         m_muonMSTrackValidationPlots[i]->fill(*truthLink, tp, weight);
                     } else if (type == xAOD::Muon::ExtrapolatedMuonSpectrometerTrackParticle) {
                         m_muonMETrackValidationPlots[i]->fill(*truthLink, tp, weight);
                     } else if (type == xAOD::Muon::MSOnlyExtrapolatedMuonSpectrometerTrackParticle) {
                         m_muonMSOnlyMETrackValidationPlots[i]->fill(*truthLink, tp, weight);
                     }
                 }
             }
         }
  
         return;
     }

◆ handleMuonTrigger()

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

private

Definition at line 1221 of file MuonPhysValMonitoringTool.cxx.

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

◆ handleSlowMuon()

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

private

◆ handleTruthMuon()

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

private

Definition at line 965 of file MuonPhysValMonitoringTool.cxx.

                                                                                                   {
         const xAOD::SlowMuon* smu = nullptr;
         const xAOD::Muon* mu = nullptr;
         if (!m_slowMuonsName.empty()) {
             smu = findRecoSlowMuon(truthMu);
             if (smu) {
                 const MuonLink muLink = smu->muonLink();
                 if (muLink.isValid()) mu = *muLink;
  
                 if (!mu) {
                     ATH_MSG_WARNING("Found SlowMuon without valid muon link");
                     smu = nullptr;
                 }
             }
         } else {
             mu = findRecoMuon(truthMu);
         }
  
         if (msgLvl(MSG::DEBUG)) printTruthMuonDebug(truthMu, mu);
         if (!passesAcceptanceCuts(truthMu)) return;
  
         std::unique_ptr<xAOD::Muon> mu_c;
         if (mu) {
             try {
                 mu_c = getCorrectedMuon(*mu);
             } catch (const SG::ExcBadAuxVar&) {
                 ATH_MSG_ERROR("Cannot retrieve aux-item - rejecting muon");
                 return;
             }
         }
  
         unsigned int thisMuonCategory = getMuonTruthCategory(truthMu);
         for (unsigned int i = 0; i < m_selectMuonCategories.size(); i++) {
             if (m_selectMuonCategories[i] == ALL || m_selectMuonCategories[i] == thisMuonCategory) {
                 // histos
                 m_muonValidationPlots[i]->fill(
                     truthMu, mu_c.get(), m_MSTracks,
                     weight);  // if no muon is found a protection inside MuonValidationPlots will ensure, its plots won't be filled
                 if (!m_slowMuonsName.empty()) m_slowMuonValidationPlots[i]->fill(truthMu, smu, mu_c.get(), weight);
                 // tree branches
                 m_muonValidationPlots[i]->fillTreeBranches(truthMu, mu_c.get(), m_MSTracks);
             }
         }
         if (mu_c) {
             m_h_overview_reco_category->Fill(thisMuonCategory - 1, weight);
             m_h_overview_reco_authors[thisMuonCategory - 1]->Fill(mu_c->author(), weight);
         } else if (!m_isData)
             m_oUnmatchedTruthMuonPlots->fill(*truthMu, weight);
     }

◆ handleTruthMuonSegment()

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

private

Definition at line 866 of file MuonPhysValMonitoringTool.cxx.

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

◆ initialize()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::initialize ( )

overridevirtual

Reimplemented from ManagedMonitorToolBase.

Definition at line 65 of file MuonPhysValMonitoringTool.cxx.

                                                      {
         ATH_MSG_INFO("Initializing " << name() << "...");
         ATH_CHECK(ManagedMonitorToolBase::initialize());
  
         for (unsigned int i = 0; i < m_selectHLTMuonItems.size(); i++) {
             if (m_selectHLTMuonItems[i][0] == "" || m_selectHLTMuonItems[i][1] == "") continue;
             m_muonItems.emplace_back(m_selectHLTMuonItems[i][0]);
             m_L1Seed.emplace_back(m_selectHLTMuonItems[i][1]);
         }
  
         // setup flags
         if (m_doTrigMuonValidation == false) {
             m_doTrigMuonL1Validation = false;
             m_doTrigMuonL2Validation = false;
             m_doTrigMuonEFValidation = false;
         }
         ATH_CHECK(m_trigDec.retrieve(DisableTool{!m_doTrigMuonValidation}));
  
         ATH_CHECK(m_eventInfo.initialize());
         ATH_CHECK(m_muonSelectionTool.retrieve());
         ATH_CHECK(m_trackSelector.retrieve());
         ATH_CHECK(m_isoTool.retrieve());
  
         ATH_CHECK(m_tracksName.initialize());
         ATH_CHECK(m_fwdtracksName.initialize(!m_fwdtracksName.empty()));
         ATH_CHECK(m_muonsName.initialize());
         ATH_CHECK(m_slowMuonsName.initialize(!m_slowMuonsName.empty()));
         
         ATH_CHECK(m_muonTracksName.initialize());
         ATH_CHECK(m_muonExtrapolatedTracksName.initialize());
         ATH_CHECK(m_muonMSOnlyExtrapolatedTracksName.initialize());
         
         ATH_CHECK(m_muonSegmentsName.initialize());
         ATH_CHECK(m_muonsTruthName.initialize(!m_isData));
         ATH_CHECK(m_muonSegmentsTruthName.initialize(!m_isData));
         ATH_CHECK(m_muonL1TrigName.initialize(m_doTrigMuonL1Validation));
         ATH_CHECK(m_muonL2SAName.initialize(m_doTrigMuonL2Validation));
         ATH_CHECK(m_muonL2CBName.initialize(m_doTrigMuonL2Validation));
         ATH_CHECK(m_muonEFCombTrigName.initialize(m_doTrigMuonEFValidation));
         
         if (!m_isData) {
             const std::vector<std::string> truthDecors{"truthOrigin", "truthType", "truthParticleLink"};
             const std::vector<std::string> keys{m_tracksName.key(), m_fwdtracksName.key(), m_muonsName.key(), 
                                                 m_slowMuonsName.key(), m_muonTracksName.key(), m_muonExtrapolatedTracksName.key(),
                                                 m_muonMSOnlyExtrapolatedTracksName.key()};
             for (const std::string& key : keys) {
                 if (key.empty()) continue;
                 for (const std::string& decor : truthDecors){
                     m_decorDep.emplace_back(std::format("{:}.{:}", key , decor)); 
                 }
             }
             const std::vector<std::string> truthPartDecors{"MuonEntryLayer_px", "nprecLayers",
                                                             "truthOrigin", "truthType"};
  
             for (const std::string& decor: truthPartDecors) {
                 m_decorDep.emplace_back(m_muonsTruthName, decor);
             }
             
  
  
         }
         
         ATH_CHECK(m_decorDep.initialize());
         return StatusCode::SUCCESS;
     }

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

 {
    std::string str("file");
  
    switch( interval ) {
       case all:
          str = "all";
          break;
       case fill:
          str = "fill";
          break;
       case run:
          str = "run";
          break;
       case lowStat:
          str = "lowStat";
          break;
       case medStat:
          str = "medStat";
          break;
       case higStat:
          str = "higStat";
          break;
       case lumiBlock:
          str = "lumiBlock";
          break;
       case eventsBlock:
          str = "eventsBlock";
          break;
       case file:
      str = "file";
      break;
       default:
          str = "unknown";
    }
  
    return str;
 }

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

 {
    std::string lcstr( strToLower(str) );
  
    if( lcstr == "all" )
       return all;
    else if( lcstr == "fill" )
       return fill;
    else if( lcstr == "run" )
       return run;
    else if( lcstr == "lowStat" )
       return lowStat;
    else if( lcstr == "medStat" )
       return medStat;
    else if( lcstr == "higStat" )
       return higStat;
    else if( lcstr == "lumiBlock" )
       return lumiBlock;
    else if( lcstr == "eventsBlock" )
       return eventsBlock;
    else if( lcstr == "file" )
       return file;
  
    if( Imp::s_svcLocator ) {
       SmartIF<IMessageSvc> ms{Imp::s_svcLocator.load()->service( "MessageSvc" )};
       if( ms.isValid() ) {
          MsgStream log( ms, "ManagedMonitorToolBase::intervalStringToEnum()" );
          log << MSG::WARNING << "Unknown ManagedMonitorToolBase::Interval_t \""
             << str << "\", returning \"file\"" << endmsg;
       }
    }
  
    return file;
 }

◆ L2CBTriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2CBTriggerResolution ( )

private

Definition at line 1185 of file MuonPhysValMonitoringTool.cxx.

                                                           {
         int k_L2CBMu_MinDeltaR = -1;
         float MinDeltaR = 0.;
         ATH_MSG_DEBUG(" m_vL2CBMuons.size()" << m_vL2CBMuons.size());
         for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
             ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << "  eta=" << m_vRecoMuons.at(i)->eta() << "  phi="
                                                             << m_vRecoMuons.at(i)->phi() << "    auth=" << m_vRecoMuons.at(i)->author());
         }
         for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
             if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
             ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << "  eta=" << m_vRecoMuons.at(i)->eta()
                                                   << "  phi=" << m_vRecoMuons.at(i)->phi() << "    auth=" << m_vRecoMuons.at(i)->author());
             k_L2CBMu_MinDeltaR = -1;
             MinDeltaR = 1000;
             ATH_MSG_DEBUG("==============>>>>      k_L2CBMu_MinDeltaR=" << k_L2CBMu_MinDeltaR << "    MinDeltaR" << MinDeltaR);
             for (unsigned int k = 0; k < m_vL2CBMuons.size(); k++) {
                 ATH_MSG_DEBUG("  :::::::: TEST: L2CB pt=" << m_vL2CBMuons.at(k)->pt() << "  eta=" << m_vL2CBMuons.at(k)->eta()
                                                           << "  phi=" << m_vL2CBMuons.at(k)->phi()
                                                           << "  DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)));
                 if ((deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)) < 0.1 &&
                      (deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k)) < MinDeltaR))) {
                     k_L2CBMu_MinDeltaR = k;
                     MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2CBMuons.at(k));
                     ATH_MSG_DEBUG("==============>>>>   taken!!!!     k_L2CBMu_MinDeltaR=" << k_L2CBMu_MinDeltaR << "    MinDeltaR"
                                                                                            << MinDeltaR);
                 }
             }
             if (k_L2CBMu_MinDeltaR == -1) continue;
             for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
                 if (m_selectMuonCategories[c] == ALL) {
                     m_TriggerMuonValidationPlots[c]->fill(*m_vL2CBMuons.at(k_L2CBMu_MinDeltaR), *m_vRecoMuons.at(i));  
                 }
             }
         }
     }

◆ L2SATriggerResolution()

void MuonPhysValMonitoring::MuonPhysValMonitoringTool::L2SATriggerResolution ( )

private

Definition at line 1138 of file MuonPhysValMonitoringTool.cxx.

                                                           {
         int k_L2SAMu_MinDeltaR = -1;
         float MinDeltaR = 0.;
         ATH_MSG_DEBUG(" m_vL2SAMuons.size()" << m_vL2SAMuons.size());
         for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
             ATH_MSG_DEBUG(":: TEST: listing all Recomu pt=" << m_vRecoMuons.at(i)->pt() << "  eta=" << m_vRecoMuons.at(i)->eta() << "  phi="
                                                             << m_vRecoMuons.at(i)->phi() << "    auth=" << m_vRecoMuons.at(i)->author());
         }
         for (unsigned int i = 0; i < m_vRecoMuons.size(); i++) {
             if ((m_vRecoMuons.at(i)->author() != 1) || (std::abs(m_vRecoMuons.at(i)->eta()) > 2.4)) continue;
             ATH_MSG_DEBUG(":::: TEST: Recomu pt=" << m_vRecoMuons.at(i)->pt() << "  eta=" << m_vRecoMuons.at(i)->eta()
                                                   << "  phi=" << m_vRecoMuons.at(i)->phi() << "    auth=" << m_vRecoMuons.at(i)->author());
             k_L2SAMu_MinDeltaR = -1;
             MinDeltaR = 1000;
             ATH_MSG_DEBUG("==============>>>>      k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << "    MinDeltaR" << MinDeltaR);
             for (unsigned int k = 0; k < m_vL2SAMuons.size(); k++) {
                 ATH_MSG_DEBUG("  :::::::: TEST: L2SA pt=" << m_vL2SAMuons.at(k)->pt() << "  eta=" << m_vL2SAMuons.at(k)->eta()
                                                           << "  phi=" << m_vL2SAMuons.at(k)->phi()
                                                           << "  DeltaR=" << deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)));
                 if ((deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < 0.1 &&
                      (deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k)) < MinDeltaR))) {
                     k_L2SAMu_MinDeltaR = k;
                     MinDeltaR = deltaR(m_vRecoMuons.at(i), m_vL2SAMuons.at(k));
                     ATH_MSG_DEBUG("==============>>>>   taken!!!!     k_L2SAMu_MinDeltaR=" << k_L2SAMu_MinDeltaR << "    MinDeltaR"
                                                                                            << MinDeltaR);
                 }
             }
             if (k_L2SAMu_MinDeltaR == -1) continue;
             for (unsigned int c = 0; c < m_selectMuonCategories.size(); c++) {
                 if (m_selectMuonCategories[c] == ALL) {
                     m_TriggerMuonValidationPlots[c]->fill(*m_vL2SAMuons.at(k_L2SAMu_MinDeltaR), *m_vRecoMuons.at(i));  
                 }
             }
         }
     }

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

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

◆ lbAverageLivefraction()

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

virtualinherited

Average luminosity livefraction.

Definition at line 1762 of file ManagedMonitorToolBase.cxx.

 {
     if (m_environment == AthenaMonManager::online)
         return 1.0;
  
     if (!m_trigLiveFractionDataKey.empty()) {
         SG::ReadCondHandle<TrigLiveFractionCondData> live (m_trigLiveFractionDataKey, ctx);
         return live->lbAverageLiveFraction();
     } else {
         //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbAverageLivefraction() can't work properly! ");
         ATH_MSG_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
         return -1.0;
     }
     // not reached
 }

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

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

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

 {
     if ( m_environment == AthenaMonManager::online ) {
         return m_defaultLBDuration;
     }
     if (!m_lbDurationDataKey.empty()) {
         SG::ReadCondHandle<LBDurationCondData> dur (m_lbDurationDataKey, ctx);
         return dur->lbDuration();
     } else {
         //ATH_MSG_FATAL("! Luminosity tool has been disabled ! lbDuration() can't work properly! ");
         ATH_MSG_DEBUG("Warning: lbDuration() - luminosity tools are not retrieved or turned on (i.e. EnableLumi = False)");
         return m_defaultLBDuration;
     }
     // not reached
 }

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

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

◆ lbLuminosityPerBCID()

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

virtualinherited

Instantaneous luminosity.

Definition at line 1745 of file ManagedMonitorToolBase.cxx.

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

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

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

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

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

◆ ManagedMonitorToolBase()

ManagedMonitorToolBase::ManagedMonitorToolBase

Constructor with parameters:

Definition at line 388 of file ManagedMonitorToolBase.cxx.

    : AthAlgTool( type, name, parent )
    , m_manager(0)
    , m_managerNameProp("AthenaMonManager")
    , m_fileKey("")
    , m_dataTypeStr("userDefined")
    , m_environmentStr("noOutput")
    , m_detailLevel(1)
    , m_dataType(AthenaMonManager::userDefined)
    , m_environment(AthenaMonManager::user)
    , m_streamNameFcn(0)
    , m_THistSvc("THistSvc",name)
    , m_procNEventsProp(0)
    , m_path("")
    , m_preScaleProp(0)
    , m_triggerChainProp("")
    , m_triggerGroupProp("")
    , m_useTrigger(false)
    , m_lastLumiBlock(0)
    , m_lastRun(0)
    , m_lastLowStatInterval(-1)
    , m_lastMedStatInterval(-1)
    , m_lastHigStatInterval(-1)
    , m_nEvents(1)
    , m_nEventsIgnoreTrigger(1)
    , m_nLumiBlocks(1)
    , m_haveClearedLastEventBlock(true)
    , m_bookHistogramsInitial(false)
    , m_useLumi(false)
    , m_defaultLBDuration(60.)
    , m_d(new Imp(this))
 {
 //   ManagedMonitorToolBase_resetHistStatistics(this);
    declareInterface<IMonitorToolBase>(this);
    declareProperty( "ProcessNEvents", m_procNEventsProp );
    declareProperty( "histoPathBase", m_path );
    declareProperty( "PreScale", m_preScaleProp );
    declareProperty( "TriggerChain", m_triggerChainProp );
    declareProperty( "TriggerGroup", m_triggerGroupProp );
  
    // If a class would like to associate itself to a manager but cannot actually
    // be referenced by it, the manager name can be set explicitly.  Otherwise,
    // it is set automatically.
    declareProperty( "ManagerName", m_managerNameProp );
  
    // Enable luminosity tool?
    declareProperty( "EnableLumi", m_useLumi );
  
    // How detailed should the monitoring be?
    declareProperty( "DetailLevel", m_detailLevel );
  
    // If we don't know how long an LB is, here's the default
    declareProperty( "DefaultLBDuration", m_defaultLBDuration );
  
    // Properties that are overridden in initialize()---settings via jobOptions are ignored!
    declareProperty( "FileKey", m_fileKey );
    declareProperty( "DataType", m_dataTypeStr );
    declareProperty( "Environment", m_environmentStr );
  
    if( !Imp::s_svcLocator )
       Imp::s_svcLocator = svcLoc();
  
    for (auto interval: { eventsBlock, lumiBlock, lowStat, run, all }) {
      m_templateHistograms[interval] = std::vector< MgmtParams<TH1> >();
      m_templateGraphs[interval] = std::vector< MgmtParams<TGraph> >();
      m_templateTrees[interval] = std::vector< MgmtParams<TTree> >();
      m_supportedIntervalsForRebooking.insert(interval);
    }
  
    newLowStatInterval = false;
    newMedStatInterval = false;
    newHigStatInterval = false;
    newLowStat = false;
    newLumiBlock = false;
    newRun = false;
    newEventsBlock = false;
    endOfEventsBlock = false;
    endOfLowStat = false;
    endOfLumiBlock = false;
    endOfRun = false;
  
    m_newLowStatInterval = false;
    m_newMedStatInterval = false;
    m_newHigStatInterval = false;
    m_newLowStat = false;
    m_newLumiBlock = false;
    m_newRun = false;
    m_newEventsBlock = false;
    m_endOfEventsBlock = false;
    m_endOfLowStat = false;
    m_endOfLumiBlock = false;
    m_endOfRun = false;
 }

◆ MMTB_DEPRECATED() [1/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfEventsBlock )

inherited

◆ MMTB_DEPRECATED() [2/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLowStat )

inherited

◆ MMTB_DEPRECATED() [3/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLumiBlock )

inherited

◆ MMTB_DEPRECATED() [4/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfRun )

inherited

◆ MMTB_DEPRECATED() [5/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newEventsBlock )

inherited

◆ MMTB_DEPRECATED() [6/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newHigStatInterval )

inherited

◆ MMTB_DEPRECATED() [7/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStat )

inherited

◆ MMTB_DEPRECATED() [8/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStatInterval )

inherited

◆ MMTB_DEPRECATED() [9/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLumiBlock )

inherited

◆ MMTB_DEPRECATED() [10/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newMedStatInterval )

inherited

◆ MMTB_DEPRECATED() [11/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newRun )

inherited

◆ modifyHistogram()

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

private

Definition at line 1432 of file MuonPhysValMonitoringTool.cxx.

                                                              {
         std::string histname = hist->GetName();
          
         if(m_muonsName.key() == "Muons"){
             if (histname.find("parameters_z0") != std::string::npos) { 
                 hist->GetXaxis()->Set(80, -200., 200.);
             }
             if (histname.find("parameters_d0") != std::string::npos && histname.find("parameters_d0_small") == std::string::npos) {
                 hist->GetXaxis()->Set(80, -1., 1.);
                 hist->GetYaxis()->SetTitle("Entries / 0.025 mm");                
             }
        } else if(m_muonsName.key() == "MuonsLRT"){
             if (histname.find("parameters_d0") != std::string::npos && histname.find("parameters_d0_small") == std::string::npos) {
                 hist->Rebin(100);
                 hist->GetYaxis()->SetTitle("Entries / 2.5 mm");                
             }
        }
  
  
         if (histname.find("trigger_L1_pt") != std::string::npos) {  // if (histname=="Muons_All_trigger_L1_pt"){
             hist->SetTitle("L1Trigger Muons pt threshold");
             hist->GetXaxis()->SetTitle("L1Trigger Muons pt threshold [GeV]");
             hist->GetXaxis()->Set(30, -0.5, 29.5);
         }
         if (histname.find("trigger_L1_eta_pt") != std::string::npos) {  // if (histname=="Muons_All_trigger_L1_eta_pt") {
             hist->SetTitle("L1Trigger Muons pt threshold vs eta");
             hist->GetYaxis()->Set(90, -0.5, 29.5);
             hist->GetYaxis()->SetTitle("L1Trigger Muons pt threshold [GeV]");
         }
  
         if (histname.find("trigger") != std::string::npos &&
             ((histname.find("Denom_pt") != std::string::npos) || (histname.find("Numer_pt") != std::string::npos) ||
              (histname.find("Features_pt") != std::string::npos)))
             hist->GetXaxis()->Set(200, 0., 200.);
  
         if (histname.find("hits") != std::string::npos) {
             if (histname.find("etaLayer2") != std::string::npos)
                 hist->GetXaxis()->Set(15, -0.5, 14.5);
             else if (histname.find("etaLayer") != std::string::npos)
                 hist->GetXaxis()->Set(11, -0.5, 10.5);
         }
  
         bool is2D = !(histname.find("_vs_") == std::string::npos);
  
         if (histname.find("METrackParticles") != std::string::npos) {
             if (histname.find("Res_eta") != std::string::npos) {
                 if (is2D)
                     hist->GetYaxis()->Set(50, -0.025, 0.025);
                 else
                     hist->GetXaxis()->Set(50, -0.025, 0.025);
             } else if (histname.find("Res_phi") != std::string::npos) {
                 if (is2D)
                     hist->GetYaxis()->Set(50, -0.02, 0.02);
                 else
                     hist->GetXaxis()->Set(50, -0.02, 0.02);
             }
         } else if (histname.find("MSTrackParticles") != std::string::npos) {
             if (histname.find("Res_eta") != std::string::npos) {
                 if (is2D)
                     hist->GetYaxis()->Set(50, -0.025, 0.025);
                 else
                     hist->GetXaxis()->Set(50, -0.025, 0.025);
             } else if (histname.find("Res_phi") != std::string::npos) {
                 if (is2D)
                     hist->GetYaxis()->Set(50, -0.05, 0.05);
                 else
                     hist->GetXaxis()->Set(50, -0.05, 0.05);
             }
         } else {
             if (histname.find("Res_eta") != std::string::npos) {
                 if (is2D)
                     hist->GetYaxis()->Set(50, -0.005, 0.005);
                 else
                     hist->GetXaxis()->Set(50, -0.005, 0.005);
             } else if (histname.find("Res_phi") != std::string::npos) {
                 if (is2D)
                     hist->GetYaxis()->Set(50, -0.002, 0.002);
                 else
                     hist->GetXaxis()->Set(50, -0.002, 0.002);
             }
         }
  
         if (histname.find("trigger") != std::string::npos) {
             // RESO EF - MC
             if ((!m_isData) && histname.find("MuidCo") != std::string::npos &&
                 (histname.find("BARREL") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.04, 0.04);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.04, 0.04); }
                 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.0005, 0.0005);
                 }
                 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
  
                 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.0002, 0.0002);
                 }
                 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0002, 0.0002); }
             }
             if ((!m_isData) && histname.find("MuidCo") != std::string::npos && (histname.find("ENDCAPS") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.05, 0.05);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.05, 0.05); }
                 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.001, 0.001);
                 }
                 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
  
                 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.0003, 0.0003);
                 }
                 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0003, 0.0003); }
             }
             if ((!m_isData) && histname.find("MuidSA") != std::string::npos) {
                 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.03, 0.03);
                 }
                 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
  
                 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.03, 0.03);
                 }
                 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
             }
             if ((!m_isData) && histname.find("MuidSA") != std::string::npos && (histname.find("BARREL") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.15, 0.15);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.15, 0.15); }
             }
             if ((!m_isData) && histname.find("MuidSA") != std::string::npos &&
                 (histname.find("ENDCAPS") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.2, 0.2);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.2, 0.2); }
             }
  
             // RESO EF - DATA
             if ((m_isData) && histname.find("MuidCo") != std::string::npos &&
                 (histname.find("BARREL") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.06, 0.06);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.06, 0.06); }
                 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.001, 0.001);
                 }
                 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
  
                 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.0005, 0.0005);
                 }
                 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
             }
             if ((m_isData) && histname.find("MuidCo") != std::string::npos && (histname.find("ENDCAPS") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.1, 0.1);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.1, 0.1); }
                 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.0015, 0.0015);
                 }
                 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0015, 0.0015); }
  
                 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.0005, 0.0005);
                 }
                 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.0005, 0.0005); }
             }
             if ((m_isData) && histname.find("MuidSA") != std::string::npos) {
                 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.03, 0.03);
                 }
                 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
  
                 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.03, 0.03);
                 }
                 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
             }
             if ((m_isData) && histname.find("MuidSA") != std::string::npos && (histname.find("BARREL") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.3, 0.3);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.3, 0.3); }
             }
             if ((m_isData) && histname.find("MuidSA") != std::string::npos &&
                 (histname.find("ENDCAPS") != std::string::npos || histname.find("WHOLE_DETECT") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.5, 0.5);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.5, 0.5); }
             }
  
             // LEVEL2
             if ((histname.find("L2_StandAlone") != std::string::npos)) {
                 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.03, 0.03);
                 }
                 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
  
                 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.03, 0.03);
                 }
                 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.03, 0.03); }
             }
             if ((histname.find("L2_StandAlone") != std::string::npos) && (histname.find("BARREL") != std::string::npos)) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.3, 0.3);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.3, 0.3); }
             }
             if ((histname.find("L2_StandAlone") != std::string::npos) &&
                 ((histname.find("ENDCAPS") != std::string::npos) || (histname.find("WHOLE_DETECT") != std::string::npos))) {
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.5, 0.5);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.5, 0.5); }
             }
  
             if ((histname.find("L2_Combined") != std::string::npos)) {
                 if (histname.find("Res_eta") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.002, 0.002);
                 }
                 if (histname.find("Res_eta_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.002, 0.002); }
  
                 if (histname.find("Res_phi") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.001, 0.001);
                 }
                 if (histname.find("Res_phi_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.001, 0.001); }
                 if (histname.find("Res_pT") != std::string::npos && histname.find("_vs_") == std::string::npos) {
                     hist->GetXaxis()->Set(100, -0.2, 0.2);
                 }
                 if (histname.find("Res_pT_vs_") != std::string::npos) { hist->GetYaxis()->Set(100, -0.2, 0.2); }
             }
         }
     }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

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

                                                                {
    std::string item;
    std::stringstream ss(line);
  
    if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "ManagedMonitorToolBase::parseList:";
  
    while ( std::getline(ss, item, ',') ) {
       std::stringstream iss(item); // remove 
       iss >> item;                 // whitespace 
       if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << " " << item;
       result.push_back(item);
    }
  
    msg(MSG::DEBUG) << endmsg;
    return StatusCode::SUCCESS;
 }

◆ passesAcceptanceCuts()

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

private

Definition at line 1675 of file MuonPhysValMonitoringTool.cxx.

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

◆ preSelector()

bool ManagedMonitorToolBase::preSelector ( )

virtualinherited

Implements IMonitorToolBase.

Definition at line 1681 of file ManagedMonitorToolBase.cxx.

 {
    if( m_preScaleProp > 1 ) {
       return ( (m_nEvents % m_preScaleProp) == 1 );
    }
    return true;
 }

◆ printMuonDebug()

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

private

Definition at line 1280 of file MuonPhysValMonitoringTool.cxx.

                                                                      {
         const xAOD::TrackParticle* tp = mu->primaryTrackParticle();
         static const SG::ConstAccessor<TruthLink> truthParticleLinkAcc("truthParticleLink");
         TruthLink truthLink;
         if (tp) {
             truthLink = truthParticleLinkAcc.withDefault(*tp, TruthLink());
         }
         ATH_MSG_DEBUG("Muon: pt " << mu->pt() << " eta " << mu->eta() << " link " << truthLink.isValid());
     }

◆ printTruthMuonDebug()

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

private

Definition at line 1318 of file MuonPhysValMonitoringTool.cxx.

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

◆ procHistograms()

StatusCode MuonPhysValMonitoring::MuonPhysValMonitoringTool::procHistograms ( )

overridevirtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 1324 of file MuonPhysValMonitoringTool.cxx.

                                                          {
         ATH_MSG_INFO("Finalising hists " << name() << "...");
         for (const auto& plots : m_muonValidationPlots) plots->finalize();
         for (const auto& plots : m_TriggerMuonValidationPlots) plots->finalize();
         if (!m_isData) {
             m_oUnmatchedRecoMuonPlots->finalize();
             m_oUnmatchedTruthMuonPlots->finalize();
         }
  
         for (const auto& plots : m_muonMSTrackValidationPlots) plots->finalize();
         for (const auto& plots : m_muonMETrackValidationPlots) plots->finalize();
         for (const auto& plots : m_muonMSOnlyMETrackValidationPlots) plots->finalize();
         for (const auto& plots : m_muonIDTrackValidationPlots) plots->finalize();
         for (const auto& plots : m_muonIDSelectedTrackValidationPlots) plots->finalize();
         for (const auto& plots : m_muonIDForwardTrackValidationPlots) plots->finalize();
         if (!m_isData)
             if (m_oUnmatchedRecoMuonTrackPlots) m_oUnmatchedRecoMuonTrackPlots->finalize();
  
         for (const auto& plots : m_muonSegmentValidationPlots) plots->finalize();
         if (!m_isData)
             if (m_oUnmatchedRecoMuonSegmentPlots) m_oUnmatchedRecoMuonSegmentPlots->finalize();
  
         return StatusCode::SUCCESS;
     }//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.

                                                                                         {
     if (!e)
         return StatusCode::FAILURE;
  
     TGraph* g = reinterpret_cast<TGraph*>(e);
     std::string name = e->GetName();
  
     // MANAGED
     if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
         // warn about not using merge algorithms
         if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
             ATH_MSG_WARNING("HEY! Attempting to register "<<name<<" as a per-LB histogram, but not setting the merge algorithm! Use \"merge\", at least.");
         }
         // add the efficiency to rebooking vector
         if (m_supportedIntervalsForRebooking.count(group.interval())) {
             m_templateEfficiencies[group.interval()].push_back( MgmtParams<TEfficiency>(e, group) );
         } else {
             ATH_MSG_ERROR("Attempt to book managed graph " << name << " with invalid interval type " << intervalEnumToString(group.interval()));
             return StatusCode::FAILURE;
         }
  
         MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
         std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
         registerMetadata(streamName, name, group).ignore();
         return m_THistSvc->regGraph( streamName, g );
     } else {
     // UNMANAGED
         if( m_manager != 0 ) {
             std::string genericName = NoOutputStream().getStreamName( this, group, name );
             m_manager->writeAndDelete( genericName );
             m_manager->passOwnership( e, genericName );
         }
  
         std::string streamName = streamNameFunction()->getStreamName( this, group, name, false );
         StatusCode smd = registerMetadata(streamName, name, group);
         if (smd != StatusCode::SUCCESS) 
             return StatusCode::FAILURE;
  
         return m_THistSvc->regGraph( streamName, g );
     }
 }

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

 {
    if (!g)
       return StatusCode::FAILURE;
  
    // This part of the code deals with MANAGED type
    if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
        // Create an unmanaged group based on the original MonGroup instance passed
        // This is needed because managed graph is presented as a number of unmanaged
        // graphs (one per each interval)
        MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
  
        if (m_supportedIntervalsForRebooking.count(group.interval())) {
            m_templateGraphs[group.interval()].push_back( MgmtParams<TGraph>(g, group_unmanaged) );
        } else {
            ATH_MSG_ERROR("Attempt to book managed graph " << g->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
            return StatusCode::FAILURE;
        }
  
        std::string name = g->GetName();
        std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
        registerMetadata(streamName, name, group).ignore();
        return m_THistSvc->regGraph( streamName, g );
        //return m_THistSvc->regGraph( streamName );
    } 
  
    // This part of the code deals with UNMANAGED type
    std::string gName = g->GetName();
  
    if( m_manager != 0 ) {
       std::string genericName = NoOutputStream().getStreamName( this, group, gName );
       m_manager->writeAndDelete( genericName );
       m_manager->passOwnership( g, genericName );
    }
  
    std::string streamName = streamNameFunction()->getStreamName( this, group, gName, false );
  
    StatusCode smd = registerMetadata(streamName, gName, group);
    if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
  
    return m_THistSvc->regGraph( streamName, g );
 }

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

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

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

 {
 //   ManagedMonitorToolBase_addHistStatistics(this,h);
  
   if (!h)
     return StatusCode::FAILURE;
   
   // This part of the code deals with MANAGED type
   if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
     /* 
        Create an unmanaged group based on the original MonGroup instance passed
        It is needed because managed histogram is presented as a number of unmanaged
        histograms (one per each interval)
        Update (PUEO) - I don't think it actually matters, and need to keep 
        track of "proper" attribute for X_VS_LB
     */
     
     if (group.histo_mgmt() == ATTRIB_X_VS_LB && group.merge().empty()) {
       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.");
     }
     
     if (m_supportedIntervalsForRebooking.count(group.interval())) {
       m_templateHistograms[group.interval()].push_back( MgmtParams<TH1>(h, group) );
     } else {
       ATH_MSG_ERROR("Attempt to book managed histogram " << h->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
            return StatusCode::FAILURE;
     }
     
     std::string hName = h->GetName();
     MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
     std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, hName, false );
     registerMetadata(streamName, hName, group).ignore();
     return m_THistSvc->regHist( streamName, h );
   }
   
   // This part of the code deals with UNMANAGED type
   std::string hName = h->GetName();
   
   if( m_manager != 0 ) {
     std::string genericName = NoOutputStream().getStreamName( this, group, hName );
     m_manager->writeAndDelete( genericName );
     m_manager->passOwnership( h, genericName );
   }
   
   std::string streamName = streamNameFunction()->getStreamName( this, group, hName, false );
   
   StatusCode smd = registerMetadata(streamName, hName, group);
   if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
   
   return m_THistSvc->regHist( streamName, h );
 }

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

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

◆ registerMetadata()

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

protectedinherited

Definition at line 946 of file ManagedMonitorToolBase.cxx.

                                 {
   if( m_environment != AthenaMonManager::online ) {
     TTree* metadata(0);
     std::string mdStreamName( streamName );
     size_t found=mdStreamName.rfind('/');
     
     if ( found != std::string::npos )
       mdStreamName.replace( found, mdStreamName.length(), "/metadata" );
     
     MDMap_t::iterator i = m_metadataMap.find( mdStreamName );
     if( i == m_metadataMap.end() ) {
       metadata = new TTree( "metadata", "Monitoring Metadata" );
       if (! metadata) return StatusCode::FAILURE;
       StatusCode scmd = m_THistSvc->regTree( mdStreamName, metadata );
       if (scmd == StatusCode::FAILURE) return StatusCode::FAILURE;
       MDMap_t::value_type valToInsert( mdStreamName, new OutputMetadata(metadata) );
       i = m_metadataMap.insert( valToInsert ).first;
     }
     
     i->second->fill( hName,  group.interval(), group.chain(), group.merge() );
   }
   return StatusCode::SUCCESS;
 }

◆ regManagedEfficiencies()

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

protectedinherited

Definition at line 1141 of file ManagedMonitorToolBase.cxx.

                                                                                                                     {
     bool allIsOk = true;
     for( auto& it : templateEfficiencies ) {
         // get components of MgmtParams and copy efficiency
         MonGroup group = it.m_group;
         TEfficiency* theEfficiency = it.m_templateHist;
         TEfficiency* e = static_cast<TEfficiency*>(theEfficiency->Clone());
         int nbins = theEfficiency->GetTotalHistogram()->GetNbinsX();
         int xlow = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmin();
         int xhigh = theEfficiency->GetTotalHistogram()->GetXaxis()->GetXmax();
         e->SetBins(nbins,xlow,xhigh); // reset histogram
         std::string name = e->GetName();
  
         // make TGraph casts of TEfficiencies
         TGraph* theGraph = reinterpret_cast<TGraph*>(theEfficiency);
         TGraph* g = reinterpret_cast<TGraph*>(e);
  
         // Get the streamName for the previous interval
         std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
  
         // RE-REGISTER 
         // 1) De-register the original graph with the THistSvc
         StatusCode sc1 = m_THistSvc->deReg( theGraph );
         if (sc1 == StatusCode::FAILURE) allIsOk = false;
         // 2) Fix THistSvc->deReg for TGraphs
         bool doneCleaning = false;
         std::string directoryName = streamNameFunction()->getDirectoryName( this, group, name, true );
         TSeqCollection *filelist=gROOT->GetListOfFiles();
         for (int i=0; i<filelist->GetEntries(); i++) {
             ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
             TFile* file = static_cast<TFile*>(filelist->At(i));
             StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
             if (sc2 == StatusCode::SUCCESS) doneCleaning = true;
         }
         // 3) Check if TGraph fix has been applied successfully
         if (!doneCleaning) { 
             ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
             allIsOk = false;
         }
         // 4) Register cloned histogram under previous interval streamName
         StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
         if (sc3 == StatusCode::FAILURE) 
             allIsOk = false;
  
         // get streamname for interval
         streamName = streamNameFunction()->getStreamName( this, group, name, false );
         // store metadata
         StatusCode smd = registerMetadata(streamName, name, group);
         if (smd != StatusCode::SUCCESS) allIsOk = false;
         // Re-register the original graph
         StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
         if (sc4 == StatusCode::FAILURE) allIsOk = false;
     }
  
     if (!allIsOk) return StatusCode::FAILURE;
     return StatusCode::SUCCESS;
 }

◆ regManagedGraphs()

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

protectedinherited

Definition at line 1070 of file ManagedMonitorToolBase.cxx.

 {
       // See the description for the regManagedHistograms method
       bool allIsOk = true;  
    
       for( std::vector< MgmtParams<TGraph> >::iterator it = templateGraphs.begin(); it != templateGraphs.end(); ++it ) {
           MonGroup group = (*it).m_group;
  
           // Get a handle to the graph
           TGraph* theGraph = (*it).m_templateHist;
  
           // Clone the graph
           TGraph* g = static_cast<TGraph*>(theGraph->Clone());
           theGraph->Set(0); // equivalent to Reset() for TH1
  
           // Get name
           std::string gName = g->GetName();
  
           // Get the streamName for the previous interval
           std::string streamName = streamNameFunction()->getStreamName( this, group, gName, true );
  
           // De-register the original graph with the THistSvc
           StatusCode sc1 = m_THistSvc->deReg( theGraph );
           if (sc1 == StatusCode::FAILURE)
               allIsOk = false;
  
           // *** begin ***
           // Fix THistSvc->deReg for TGraphs
           bool doneCleaning = false;
           std::string directoryName = streamNameFunction()->getDirectoryName( this, group, gName, true );
           TSeqCollection *filelist=gROOT->GetListOfFiles();
           for (int i=0; i<filelist->GetEntries(); i++) {
               ATH_MSG_DEBUG( "List of files: " << filelist->At(i)->GetName());
               TFile* file = static_cast<TFile*>(filelist->At(i));
               StatusCode sc2 = THistSvc_deReg_fixTGraph(file, theGraph, directoryName);
               if (sc2 == StatusCode::SUCCESS)
                   doneCleaning = true;
           }
          
           // Check if TGraph fix has been applied successfully 
           if (!doneCleaning) { 
               ATH_MSG_ERROR("THistSvc_deReg_fixTGraph: failed to apply TGraph fix for the THist Svc!");
               allIsOk = false;
           }
           // *** end ***
  
           // Register clonned histogram under previous interval streamName
           StatusCode sc3 = m_THistSvc->regGraph( streamName, g );
           if (sc3 == StatusCode::FAILURE) 
               allIsOk = false;
  
           // Get streamName for the current interval
           streamName = streamNameFunction()->getStreamName( this, group, gName, false );
           // Register metadata information with the current interval streamname
           StatusCode smd = registerMetadata(streamName, gName, group);
           if (smd != StatusCode::SUCCESS) 
               allIsOk = false;
  
           // Re-register the original graph with the current interval streamName
           StatusCode sc4 = m_THistSvc->regGraph( streamName, theGraph );
           if (sc4 == StatusCode::FAILURE) 
               allIsOk = false;
  
       }
  
       if (!allIsOk) return StatusCode::FAILURE;
       
       return StatusCode::SUCCESS;
 }

◆ regManagedHistograms()

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

protectedinherited

Definition at line 973 of file ManagedMonitorToolBase.cxx.

 {
       // The method registers histograms with the THistSvc and saves them to file.
  
       // The funky business with registering and deregistering the histogram is needed
       // to get the correct directory when saving histograms. THistSvc deals with ROOT 
       // to set up proper TDirectory, so we rely on it.
       // E.g. 
       //     m_THistSvc->regHist( streamName, h ): sets the correct TDirectory with streamName
       //     m_THistSvc->deReg( h ) - deregister from THistSvc otherwise THistSvc will try to save it
       //                          at the end of execution
       //  use passownership of the histogram and save it to file 
       //     m_manager->passOwnership( h, genericName );
       //     m_manager->writeAndDelete( genericName );
       bool allIsOk = true;  
    
       for( std::vector< MgmtParams<TH1> >::iterator it = templateHistograms.begin(); it != templateHistograms.end(); ++it ) {
           MonGroup& group = (*it).m_group;
  
           // Get a handle to the histogram
           TH1* theHist = (*it).m_templateHist;
  
           // Clone the histogram
           TH1* h = static_cast<TH1*>(theHist->Clone());
           theHist->Reset();
  
           // Get name
           std::string hName = h->GetName();
  
           // Get the streamName for the previous interval
           std::string streamName = streamNameFunction()->getStreamName( this, group, hName, true );
  
           // Register the histogram with the THistSvc
           StatusCode sc1 = m_THistSvc->deReg( theHist );
           if (sc1 == StatusCode::FAILURE) allIsOk = false;
  
           // Register clonned histogram under previous interval streamName
           StatusCode sc2 = m_THistSvc->regHist( streamName, h );
           if (sc2 == StatusCode::FAILURE) allIsOk = false;
  
           if( m_manager != 0 ) {
              std::string genericName = NoOutputStream().getStreamName( this, group, hName );
              m_manager->passOwnership( h, genericName );
              m_manager->writeAndDelete( genericName );
           }
         
           // Get streamName for the current interval 
           streamName = streamNameFunction()->getStreamName( this, group, hName, false );
           // Register metadata information with the current interval streamname
           StatusCode smd = registerMetadata(streamName, hName, group);
           if (smd != StatusCode::SUCCESS) allIsOk = false;
  
           // Re-register the original histogram with the current interval streamName
           StatusCode sc3 = m_THistSvc->regHist( streamName, theHist );
           if (sc3 == StatusCode::FAILURE) allIsOk = false;
  
       }
  
       if (!allIsOk) return StatusCode::FAILURE;
       
       return StatusCode::SUCCESS;
 }

◆ regManagedTrees()

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

protectedinherited

Definition at line 1201 of file ManagedMonitorToolBase.cxx.

 {
       // See the description for the regManagedHistograms method
       bool allIsOk = true;  
    
       for( std::vector< MgmtParams<TTree> >::iterator it = templateTrees.begin(); it != templateTrees.end(); ++it ) {
           MonGroup group = (*it).m_group;
  
           // Get a handle to the original tree
           TTree* theTree = (*it).m_templateHist;
  
           // Clone the tree
           TTree* t = static_cast<TTree*>(theTree->Clone());
           theTree->Reset();
  
           // Dumping the tree
           std::string name = t->GetName();
  
           // Get the streamName for the previous interval
           std::string streamName = streamNameFunction()->getStreamName( this, group, name, true );
  
           // De-register original tree with the THistSvc
           StatusCode sc1 = m_THistSvc->deReg( theTree );
           if (sc1 == StatusCode::FAILURE) allIsOk = false;
  
           // Register clonned tree under previous interval streamName
           StatusCode sc2 = m_THistSvc->regTree( streamName, t );
           if (sc2 == StatusCode::FAILURE) allIsOk = false;
  
           if( m_manager != 0 ) {
              std::string genericName = NoOutputStream().getStreamName( this, group, name );
              m_manager->passOwnership( t, genericName );
              m_manager->writeAndDelete( genericName );
           }
  
           // Get streamName for the current interval
           streamName = streamNameFunction()->getStreamName( this, group, name, false );
           // Register metadata information with the current interval streamname
           StatusCode smd = registerMetadata(streamName, name, group);
           if (smd != StatusCode::SUCCESS) allIsOk = false;
  
           // Re-register the original graph with the current interval streamName
           StatusCode sc3 = m_THistSvc->regTree( streamName, theTree );
           if (sc3 == StatusCode::FAILURE) allIsOk = false;
  
       }
  
       if (!allIsOk) return StatusCode::FAILURE;
       
       return StatusCode::SUCCESS;
 }

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

 {
  
    // This part of the code deals with MANAGED type
    if ( group.histo_mgmt() != ATTRIB_UNMANAGED ) {
        // Create an unmanaged group based on the original MonGroup instance passed
        // This is needed because managed tree is presented as a number of unmanaged
        // trees (one per each interval)
        MonGroup group_unmanaged( this, group.system(), group.interval(), ATTRIB_UNMANAGED, group.chain(), group.merge());
  
        if (m_supportedIntervalsForRebooking.count(group.interval())) {
            m_templateTrees[group.interval()].push_back( MgmtParams<TTree>(t, group_unmanaged) );
        } else {
            ATH_MSG_ERROR("Attempt to book managed tree " << t->GetName() << " with invalid interval type " << intervalEnumToString(group.interval()));
            return StatusCode::FAILURE;
        }
  
        std::string name = t->GetName();
        std::string genericName = NoOutputStream().getStreamName( this, group_unmanaged, name );
        std::string streamName = streamNameFunction()->getStreamName( this, group_unmanaged, name, false );
        registerMetadata(streamName, name, group).ignore();
        return m_THistSvc->regTree( streamName, t );
    }
  
  
    // This part of the code deals with UNMANAGED type
    std::string tName = t->GetName();
  
    if( m_manager != 0 ) {
       std::string genericName = NoOutputStream().getStreamName( this, group, tName );
       m_manager->writeAndDelete( genericName );
       m_manager->passOwnership( t, genericName );
    }
  
    std::string streamName = streamNameFunction()->getStreamName( this, group, tName, false );
  
    StatusCode smd = registerMetadata(streamName, tName, group);
    if (smd != StatusCode::SUCCESS) return StatusCode::FAILURE;
  
    return m_THistSvc->regTree( streamName, t );
 }

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

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

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

   {
     h.renounce();
     PBASE::renounce (h);
   }

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

                                                           {
     handlesArray.renounce();
   }

◆ retrieveContainer()

template<class ContType >

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

private

Definition at line 46 of file MuonPhysValMonitoringTool.cxx.

                                                                                                                         {
         container = nullptr;
         if (key.empty()) {
             ATH_MSG_DEBUG("No key of type "<<typeid(ContType).name()<<" has been parsed");
             return StatusCode::SUCCESS;
         }
         SG::ReadHandle readHandle{key,ctx};
         if (!readHandle.isPresent()) {
             ATH_MSG_ERROR("Failed to retrieve "<<key.fullKey()<<". Please check.");
             return StatusCode::FAILURE;
         }
         container = readHandle.cptr();
         return StatusCode::SUCCESS;
     }

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

 {
    return StatusCode::SUCCESS;
 }

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

 {
   ATH_MSG_DEBUG( "ManagedMonitorToolBase::setMonManager():");
   m_manager = manager;
   if( m_manager != 0 ) {
       ATH_MSG_DEBUG( "  --> Setting manager");
       m_managerNameProp = m_manager->name();
       m_fileKey = m_manager->fileKey();
       m_dataType = m_manager->dataType();
       m_environment = m_manager->environment();
       delete m_streamNameFcn;
       m_streamNameFcn = getNewStreamNameFcn();
    }
     ATH_MSG_DEBUG( "  --> Exiting successfully");
 }

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

 {
    // All instances should write to the stream(s) defined by the
    // AthenaMonManager.
  
    return StatusCode::SUCCESS;
 }

◆ SplitString()

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

private

Definition at line 1681 of file MuonPhysValMonitoringTool.cxx.

                                                                                                       {
         v.clear();
         int stringLength = x.Length();
         int delimLength = delim.Length();
  
         int stop = 1;
         TString temp = "---";
         while (stop != -1) {
             stop = x.First(delim);
  
             if (stop != -1) {
                 temp = x(0, stop);
                 TSubString newString = x(stop + delimLength, stringLength);
                 x = newString;
                 stringLength = x.Length();
             } else {
                 stringLength = x.Length();
                 temp = x(0, stringLength);
             }
  
             v.emplace_back(temp);
         }
     }

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

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

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

 {
     // THistSvc employs TDirectory Append method when registering TGraph.
     // When deReg is used to de-register TGraph object, THistSvc only removes the object
     // from its internal management but forgets to delete from TDirectory.
     // The current method fixes this problem by removing the TGraph object manually
     // after THistSvc->deReg(TGraph* obj) is called.
  
     // Saves and restores gFile and gDirectory
     GlobalDirectoryRestore restore;
  
     // This check is true when TGraph object is removed successfully
     bool graphRemoved = false;
  
     file->cd("/");
     TDirectory* dir = file->GetDirectory(directoryName.c_str());
     if (dir != 0) {
         dir->cd();
         TObject* obj = dir->Remove(theGraph);
         if (obj != 0) 
             graphRemoved = true;
     } 
  
     if (!graphRemoved) {
         return StatusCode::FAILURE;
     }
  
     return StatusCode::SUCCESS;
 }

◆ trigChainsArePassed()

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

protectedvirtualinherited

Definition at line 2094 of file ManagedMonitorToolBase.cxx.

 {
   ATH_MSG_DEBUG( "ManagedMonitorToolBase::trigChainsArePassed:");
  
    for(unsigned int i=0; i<vTrigNames.size(); i++) {
       if( m_trigDecTool->isPassed(vTrigNames[i]) ) {
     ATH_MSG_DEBUG( "  + \"" << vTrigNames[i] << "\" passed, returning \'true\'");
     return true;
       }
       else {
     ATH_MSG_DEBUG( "  - \"" << vTrigNames[i] << "\" did not pass");
       }
    }
  
    return false;
 }

◆ updateTriggersForGroups()

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

protectedinherited

Definition at line 2132 of file ManagedMonitorToolBase.cxx.

                                                                {
   for (size_t i = 0; i < vTrigChainNames.size(); ++i) {
     std::string& thisName = vTrigChainNames[i];
     if (thisName.compare(0, 9, "CATEGORY_") ==0) {
       ATH_MSG_DEBUG("Found a trigger category: " << thisName << ". We will unpack it.");
       std::vector<std::string> triggers = m_trigTranslator->translate(thisName.substr(9,std::string::npos));
       std::ostringstream oss;
       oss << "(";
       for (size_t itrig = 0; itrig < triggers.size(); ++itrig) {
     if (itrig != 0) { 
       oss << "|";
     }
     oss << triggers[itrig];
       }
       oss << ")";
       // replace with new value
       std::string newval = oss.str();
       ATH_MSG_DEBUG("Replaced with " << newval);
       vTrigChainNames[i] = newval;
     }
   }
 }

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                                {
     // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
     //         << "  size: " << m_vhka.size() << endmsg;
     for (auto &a : m_vhka) {
       std::vector<SG::VarHandleKey*> keys = a->keys();
       for (auto k : keys) {
         k->setOwner(this);
       }
     }
   }

◆ writeAndDelete()

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

virtualinherited

Write out histogram and delete it.

Definition at line 1601 of file ManagedMonitorToolBase.cxx.

                                                 {
   if (!h)
     return StatusCode::FAILURE;
   
   std::string hName = h->GetName();
   
   if( m_manager != 0 ) {
     std::string genericName = NoOutputStream().getStreamName( this, group, hName );
     m_manager->writeAndDelete( genericName );
   }
   return StatusCode::SUCCESS;
 }

Member Data Documentation

◆ m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial

privateinherited

Definition at line 893 of file ManagedMonitorToolBase.h.

◆ m_counterBits

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

private

Definition at line 107 of file MuonPhysValMonitoringTool.h.

◆ m_d

Imp* ManagedMonitorToolBase::m_d

privateinherited

Definition at line 900 of file ManagedMonitorToolBase.h.

◆ m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType

protectedinherited

Definition at line 838 of file ManagedMonitorToolBase.h.

◆ m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr

protectedinherited

Definition at line 834 of file ManagedMonitorToolBase.h.

◆ m_decorDep

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

private

Definition at line 141 of file MuonPhysValMonitoringTool.h.

◆ m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration

privateinherited

Definition at line 895 of file ManagedMonitorToolBase.h.

◆ m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel

protectedinherited

Definition at line 836 of file ManagedMonitorToolBase.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doBinnedResolutionPlots

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

private

Definition at line 158 of file MuonPhysValMonitoringTool.h.

◆ m_doTrigMuonEFValidation

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

private

Definition at line 162 of file MuonPhysValMonitoringTool.h.

◆ m_doTrigMuonL1Validation

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

private

Definition at line 160 of file MuonPhysValMonitoringTool.h.

◆ m_doTrigMuonL2Validation

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

private

Definition at line 161 of file MuonPhysValMonitoringTool.h.

◆ m_doTrigMuonValidation

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

private

Definition at line 159 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 165 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

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

private

Definition at line 125 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_nObjects

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

private

Definition at line 199 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_authors

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

private

Definition at line 201 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_reco_category

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

private

Definition at line 200 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_Z_mass

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

private

Definition at line 203 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_Z_mass_ID

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

private

Definition at line 205 of file MuonPhysValMonitoringTool.h.

◆ m_h_overview_Z_mass_ME

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

private

Definition at line 204 of file MuonPhysValMonitoringTool.h.

◆ m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock

protectedinherited

Definition at line 866 of file ManagedMonitorToolBase.h.

◆ m_isData

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

private

Definition at line 163 of file MuonPhysValMonitoringTool.h.

◆ m_isoTool

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

private

Definition at line 172 of file MuonPhysValMonitoringTool.h.

◆ m_L1MuonItems

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

private

Definition at line 152 of file MuonPhysValMonitoringTool.h.

◆ m_L1Seed

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

private

Definition at line 109 of file MuonPhysValMonitoringTool.h.

◆ m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval

protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval

protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock

protectedinherited

Definition at line 859 of file ManagedMonitorToolBase.h.

◆ m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval

protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

◆ m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun

protectedinherited

Definition at line 860 of file ManagedMonitorToolBase.h.

◆ m_lbDurationDataKey

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

privateinherited

Definition at line 888 of file ManagedMonitorToolBase.h.

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

◆ m_muonEFCombTrigName

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

private

Definition at line 139 of file MuonPhysValMonitoringTool.h.

◆ m_muonExtrapolatedTracksName

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

private

Definition at line 130 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDForwardTrackValidationPlots

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

private

Definition at line 189 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDSelectedTrackValidationPlots

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

private

Definition at line 188 of file MuonPhysValMonitoringTool.h.

◆ m_muonIDTrackValidationPlots

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

private

Definition at line 187 of file MuonPhysValMonitoringTool.h.

◆ m_muonItems

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

private

Definition at line 108 of file MuonPhysValMonitoringTool.h.

◆ m_muonL1TrigName

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

private

Definition at line 136 of file MuonPhysValMonitoringTool.h.

◆ m_muonL2CBName

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

private

Definition at line 138 of file MuonPhysValMonitoringTool.h.

◆ m_muonL2SAName

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

private

Definition at line 137 of file MuonPhysValMonitoringTool.h.

◆ m_muonMETrackValidationPlots

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

private

Definition at line 185 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSOnlyExtrapolatedTracksName

TrackContKey_t MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_muonMSOnlyExtrapolatedTracksName

private

Initial value:

{this, "MuonOnlyExtrapolatedTrackContainerName",

"MSOnlyExtrapolatedMuonTrackParticles"}

Definition at line 131 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSOnlyMETrackValidationPlots

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

private

Definition at line 186 of file MuonPhysValMonitoringTool.h.

◆ m_muonMSTrackValidationPlots

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

private

Definition at line 184 of file MuonPhysValMonitoringTool.h.

◆ m_muonPrinter

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

private

Definition at line 169 of file MuonPhysValMonitoringTool.h.

◆ m_muonSegmentsName

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

private

Definition at line 134 of file MuonPhysValMonitoringTool.h.

◆ m_muonSegmentsTruthName

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

private

Definition at line 135 of file MuonPhysValMonitoringTool.h.

◆ m_muonSegmentValidationPlots

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

private

Definition at line 190 of file MuonPhysValMonitoringTool.h.

◆ m_muonSelectionTool

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

private

Definition at line 168 of file MuonPhysValMonitoringTool.h.

◆ m_muonsName

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

private

Definition at line 126 of file MuonPhysValMonitoringTool.h.

◆ m_muonsTruthName

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

private

Definition at line 128 of file MuonPhysValMonitoringTool.h.

◆ m_muonTracksName

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

private

Definition at line 129 of file MuonPhysValMonitoringTool.h.

◆ m_muonValidationPlots

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

private

Definition at line 182 of file MuonPhysValMonitoringTool.h.

◆ m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents

protectedinherited

Definition at line 863 of file ManagedMonitorToolBase.h.

◆ m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger

protectedinherited

Definition at line 864 of file ManagedMonitorToolBase.h.

◆ m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock

privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

◆ m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval

privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval

privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval

privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

◆ m_newRun

bool ManagedMonitorToolBase::m_newRun

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

◆ m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks

protectedinherited

Definition at line 865 of file ManagedMonitorToolBase.h.

◆ m_oUnmatchedRecoMuonPlots

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

private

Definition at line 191 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonSegmentPlots

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

private

Definition at line 194 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedRecoMuonTrackPlots

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

private

Definition at line 193 of file MuonPhysValMonitoringTool.h.

◆ m_oUnmatchedTruthMuonPlots

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

private

Definition at line 192 of file MuonPhysValMonitoringTool.h.

◆ m_path

std::string ManagedMonitorToolBase::m_path

protectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

◆ m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp

protectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

◆ m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp

protectedinherited

Definition at line 851 of file ManagedMonitorToolBase.h.

◆ m_selectComissioning

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

private

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

Definition at line 150 of file MuonPhysValMonitoringTool.h.

◆ m_SelectedAuthor

int MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_SelectedAuthor {0}

private

Definition at line 110 of file MuonPhysValMonitoringTool.h.

◆ m_selectHLTMuonItems

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

private

Definition at line 151 of file MuonPhysValMonitoringTool.h.

◆ m_selectMuonAuthors

Gaudi::Property<std::vector<unsigned int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonAuthors

private

Initial value:

{
            this,
            "SelectMuonAuthors",
            {xAOD::Muon::MuidCo, xAOD::Muon::MuTagIMO, xAOD::Muon::MuidSA, xAOD::Muon::MuGirl, xAOD::Muon::CaloTag, xAOD::Muon::CaloScore}}

Definition at line 145 of file MuonPhysValMonitoringTool.h.

◆ m_selectMuonCategories

Gaudi::Property<std::vector<unsigned int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonCategories

private

Initial value:

{
            this,
            "SelectMuonCategories",
            {MUCATEGORY::ALL, MUCATEGORY::PROMPT, MUCATEGORY::INFLIGHT, MUCATEGORY::NONISO, MUCATEGORY::REST}}

Definition at line 153 of file MuonPhysValMonitoringTool.h.

◆ m_selectMuonCategoriesStr

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

private

Definition at line 174 of file MuonPhysValMonitoringTool.h.

◆ m_selectMuonWPs

Gaudi::Property<std::vector<int> > MuonPhysValMonitoring::MuonPhysValMonitoringTool::m_selectMuonWPs

private

Initial value:

{

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

Definition at line 143 of file MuonPhysValMonitoringTool.h.

◆ m_slowMuonsName

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

private

Definition at line 127 of file MuonPhysValMonitoringTool.h.

◆ m_slowMuonValidationPlots

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

private

Definition at line 196 of file MuonPhysValMonitoringTool.h.

◆ m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn

protectedinherited

Definition at line 841 of file ManagedMonitorToolBase.h.

◆ m_supportedIntervalsForRebooking

std::set<Interval_t> ManagedMonitorToolBase::m_supportedIntervalsForRebooking

privateinherited

Definition at line 896 of file ManagedMonitorToolBase.h.

◆ m_templateEfficiencies

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

protectedinherited

Definition at line 676 of file ManagedMonitorToolBase.h.

◆ m_templateGraphs

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

protectedinherited

Definition at line 668 of file ManagedMonitorToolBase.h.

◆ m_templateHistograms

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

protectedinherited

Definition at line 664 of file ManagedMonitorToolBase.h.

◆ m_templateTrees

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

protectedinherited

Definition at line 672 of file ManagedMonitorToolBase.h.

◆ m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc

protectedinherited

Definition at line 843 of file ManagedMonitorToolBase.h.

◆ m_trackSelector

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

private

Definition at line 171 of file MuonPhysValMonitoringTool.h.

◆ m_tracksName

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

private

Definition at line 124 of file MuonPhysValMonitoringTool.h.

◆ m_trigDec

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

private

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

◆ m_trigLiveFractionDataKey

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

privateinherited

Definition at line 890 of file ManagedMonitorToolBase.h.

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

◆ m_vEFMuonsSelected

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

private

Definition at line 216 of file MuonPhysValMonitoringTool.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vL2CBMuons

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

private

Definition at line 219 of file MuonPhysValMonitoringTool.h.

◆ m_vL2CBMuonsSelected

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

private

Definition at line 220 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuons

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

private

Definition at line 217 of file MuonPhysValMonitoringTool.h.

◆ m_vL2SAMuonsSelected

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

private

Definition at line 218 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuons

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

private

Definition at line 208 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonSegments

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

private

Definition at line 211 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedMuonTracks

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

private

Definition at line 210 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedSlowMuons

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

private

Definition at line 209 of file MuonPhysValMonitoringTool.h.

◆ m_vMatchedTruthMuons

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

private

Definition at line 207 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons

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

private

Definition at line 221 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen

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

private

Definition at line 224 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_CB

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

private

Definition at line 222 of file MuonPhysValMonitoringTool.h.

◆ m_vRecoMuons_EffDen_MS

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

private

Definition at line 223 of file MuonPhysValMonitoringTool.h.

◆ m_vTrigChainNames

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

protectedinherited

Definition at line 680 of file ManagedMonitorToolBase.h.

◆ m_vTrigGroupNames

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

protectedinherited

Definition at line 680 of file ManagedMonitorToolBase.h.

◆ m_vZmumuIDTracks

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

private

Definition at line 212 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMETracks

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

private

Definition at line 213 of file MuonPhysValMonitoringTool.h.

◆ m_vZmumuMuons

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

private

Definition at line 214 of file MuonPhysValMonitoringTool.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ L2CBContKey_t

◆ L2SAContKey_t

◆ MDMap_t

◆ MuonContKey_t

◆ MuonROIContKey_t

◆ SegmentContKey_t

◆ SlowContKey_t

◆ StoreGateSvc_t

◆ TrackContKey_t

◆ TruthPartKey_t

Member Enumeration Documentation

◆ Interval_t

◆ MgmtAttr_t

◆ MUCATEGORY

Constructor & Destructor Documentation

◆ ~MuonPhysValMonitoringTool()

Member Function Documentation

◆ bookHistograms()

◆ bookHistogramsRecurrent()

◆ bookHists()

◆ bookValidationPlots()

◆ checkHists()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ deregGraph()

◆ deregHist()

◆ deregObject() [1/2]

◆ deregObject() [2/2]

◆ detStore()

◆ EFTriggerResolution()

◆ endOfEventsBlockFlag()

◆ endOfLowStatFlag()

◆ endOfLumiBlockFlag()

◆ endOfRunFlag()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ fillHistograms()

◆ fillHists()

◆ finalHists()

◆ findHistogram()

◆ findRecoMuon()

◆ findRecoMuonSegment()

◆ findRecoSlowMuon()

◆ get_nEvents()

◆ get_procNEventsProp()

◆ getCorrectedMuon()

◆ getHist() [1/4]

◆ getHist() [2/4]

◆ getHist() [3/4]

◆ getHist() [4/4]

◆ getMuonSegmentTruthCategory()

◆ getMuonTruthCategory()

◆ getNewStreamNameFcn()

◆ handleMuon()

◆ handleMuonL1Trigger()

◆ handleMuonL2Trigger() [1/2]

◆ handleMuonL2Trigger() [2/2]

◆ handleMuonSegment()

◆ handleMuonTrack()

◆ handleMuonTrigger()