InDetPhysValMonitoringTool Class Reference

Tool to book and fill inner detector histograms for physics validation. More...

#include <InDetPhysValMonitoringTool.h>

Inheritance diagram for InDetPhysValMonitoringTool:

Public Types
enum	Interval_t {   file = 0 , eventsBlock , lumiBlock , lowStat ,   medStat , higStat , run , fill ,   all }
	An enumeration describing the interval over which a particular monitoring object is filled (i.e., interval over which the method Fill(...) is called). More...
enum	MgmtAttr_t { ATTRIB_MANAGED = 0 , ATTRIB_UNMANAGED = 1 , ATTRIB_X_VS_LB = 2 }
	An enumeration describing how the class handles the histogram. More...

Public Member Functions
	InDetPhysValMonitoringTool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters.
virtual	~InDetPhysValMonitoringTool ()
	Destructor.
virtual StreamNameFcn *	streamNameFunction ()
	Returns the function object that converts logical paramters into a physical stream name.
virtual StatusCode	bookHists ()
	Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.
virtual StatusCode	fillHists (const EventContext &ctx)
	Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over, calls procHists( bool, bool, bool ) and bookHists( bool, bool, bool ).
virtual StatusCode	finalHists ()
	Calls procHists( true, true, true ).
virtual StatusCode	bookHistogramsRecurrent ()
	An inheriting class should either override this function, bookHists() or bookHistograms().
virtual void	setMonManager (AthenaMonManager *manager)
	Takes a pointer to a managing object to get information from it when needed.
virtual StatusCode	regHist (TH1 *h, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
	Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.
virtual StatusCode	regHist (TH1 *h, const MonGroup &group)
	Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.
virtual StatusCode	getHist (TH1 *&h, const std::string &hName, const std::string &system, Interval_t interval)
	Returns a TH1 via the pointer passed as the first argument.
virtual StatusCode	getHist (TH1 *&h, const std::string &hName, const MonGroup &group)
	Returns a TH1 via the pointer passed as the first argument.
virtual StatusCode	getHist (TH2 *&h, const std::string &hName, const std::string &system, Interval_t interval)
	Returns a TH2 via the pointer passed as the first argument.
virtual StatusCode	getHist (TH2 *&h, const std::string &hName, const MonGroup &group)
	Returns a TH2 via the pointer passed as the first argument.
virtual StatusCode	regEfficiency (TEfficiency *e, const MonGroup &group)
	Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot.
virtual StatusCode	regGraph (TGraph *g, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
	Registers a TGraph to be included in the output stream using logical parameters that describe the graph.
virtual StatusCode	regGraph (TGraph *g, const MonGroup &group)
	Registers a TGraph to be included in the output stream using logical parameters that describe the graph.
virtual StatusCode	regTree (TTree *t, const std::string &system, Interval_t interval, MgmtAttr_t histo_mgmt=ATTRIB_MANAGED, const std::string &chain="", const std::string &merge="")
	Registers a TTree to be included in the output stream using logical parameters that describe it.
virtual StatusCode	regTree (TTree *t, const MonGroup &group)
	Registers a TTree to be included in the output stream using logical parameters that describe it.
virtual StatusCode	writeAndDelete (TH1 *h, const MonGroup &group)
	Write out histogram and delete it.
virtual StatusCode	deregHist (TH1 *h)
	De-registers a TH1 from the THistSvc, but does NOT delete the object.
virtual StatusCode	deregGraph (TGraph *g)
	De-registers a TGraph from the THistSvc, but does NOT delete the object.
virtual StatusCode	deregObject (const std::string &objName, const std::string &system, Interval_t interval)
	De-registers a TObject from the THistSvc, but does NOT delete the object.
virtual StatusCode	deregObject (const std::string &objName, const MonGroup &group)
	De-registers a TObject from the THistSvc, but does NOT delete the object.
virtual StatusCode	setupOutputStreams (std::vector< std::string > Mapping=std::vector< std::string >())
	This implementation does nothing—streams in this class should be managed by the AthenaMonManager.
virtual StatusCode	runStat ()
	This implementation does nothing; equivalent functionality may be provided by procHists( true, true, true ).
virtual StatusCode	checkHists (bool calledFromFinalize)
	This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.
virtual bool	preSelector ()
virtual float	lbAverageInteractionsPerCrossing (const EventContext &ctx) const
	Average mu, i.e.
virtual float	lbInteractionsPerCrossing (const EventContext &ctx) const
	Instantaneous number of interactions, i.e.
virtual float	lbAverageLuminosity (const EventContext &ctx) const
	Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
virtual float	lbLuminosityPerBCID (const EventContext &ctx) const
	Instantaneous luminosity.
virtual double	lbDuration (const EventContext &ctx) const
	Luminosity block time (in seconds).
virtual float	lbAverageLivefraction (const EventContext &ctx) const
	Average luminosity livefraction.
virtual float	livefractionPerBCID (const EventContext &ctx) const
	Livefraction per bunch crossing ID.
virtual double	lbLumiWeight (const EventContext &ctx) const
	Average Integrated Luminosity Live Fraction.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static std::string	intervalEnumToString (Interval_t interval)
	Converts a Interval_t to a string of the same name.
static Interval_t	intervalStringToEnum (const std::string &str)
	Converts a string to the corresponding Interval_t.
static const InterfaceID &	interfaceID ()

Protected Types
typedef std::map< std::string, OutputMetadata * >	MDMap_t

Protected Member Functions
StatusCode	regManagedHistograms (std::vector< MgmtParams< TH1 > > &templateHistograms)
StatusCode	regManagedGraphs (std::vector< MgmtParams< TGraph > > &templateGraphs)
StatusCode	regManagedTrees (std::vector< MgmtParams< TTree > > &templateTrees)
StatusCode	regManagedEfficiencies (std::vector< MgmtParams< TEfficiency > > &templateEfficiencies)
StatusCode	parseList (const std::string &, std::vector< std::string > &)
void	updateTriggersForGroups (std::vector< std::string > &)
StatusCode	registerMetadata (const std::string &streamName, const std::string &hName, const MonGroup &group)
StatusCode	THistSvc_deReg_fixTGraph (TFile *file, TGraph *theGraph, std::string &directoryName)
	Fixes THistSvc->deReg(obj) when obj is TGraph instance.
unsigned int	get_nEvents () const
long	get_procNEventsProp () const
virtual bool	trigChainsArePassed (std::vector< std::string > &)
virtual StreamNameFcn *	getNewStreamNameFcn () const
bool	newLowStatIntervalFlag () const
	Flag functions allowing clients to determine when to book new and process old histograms; values are updated by fillHists() based on counting lumiBlocks, and are correctly set when fillHistograms(), bookHistograms() and procHistograms() are called.
bool	newMedStatIntervalFlag () const
bool	newHigStatIntervalFlag () const
bool	newLowStatFlag () const
bool	newLumiBlockFlag () const
bool	newRunFlag () const
bool	newEventsBlockFlag () const
bool	endOfEventsBlockFlag () const
bool	endOfLowStatFlag () const
bool	endOfLumiBlockFlag () const
bool	endOfRunFlag () const
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
std::map< Interval_t, std::vector< MgmtParams< TH1 > > >	m_templateHistograms
std::map< Interval_t, std::vector< MgmtParams< TGraph > > >	m_templateGraphs
std::map< Interval_t, std::vector< MgmtParams< TTree > > >	m_templateTrees
std::map< Interval_t, std::vector< MgmtParams< TEfficiency > > >	m_templateEfficiencies
std::vector< std::string >	m_vTrigChainNames
std::vector< std::string >	m_vTrigGroupNames
MDMap_t	m_metadataMap
AthenaMonManager *	m_manager
std::string	m_managerNameProp
std::string	m_fileKey
std::string	m_dataTypeStr
std::string	m_environmentStr
unsigned int	m_detailLevel
AthenaMonManager::DataType_t	m_dataType
AthenaMonManager::Environment_t	m_environment
StreamNameFcn *	m_streamNameFcn
ServiceHandle< ITHistSvc >	m_THistSvc
PublicToolHandle< Trig::ITrigDecisionTool >	m_trigDecTool {this, "TrigDecisionTool",""}
PublicToolHandle< ITriggerTranslatorTool >	m_trigTranslator {this,"TriggerTranslatorTool",""}
ToolHandleArray< IDQFilterTool >	m_DQFilterTools {this,"FilterTools",{}}
long	m_procNEventsProp
std::string	m_path
long	m_preScaleProp
std::string	m_triggerChainProp
std::string	m_triggerGroupProp
bool	m_useTrigger
unsigned int	m_lastLumiBlock
unsigned int	m_lastRun
int	m_lastLowStatInterval
int	m_lastMedStatInterval
int	m_lastHigStatInterval
unsigned int	m_nEvents
unsigned int	m_nEventsIgnoreTrigger
unsigned int	m_nLumiBlocks
bool	m_haveClearedLastEventBlock

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_newLowStatInterval
bool	m_newMedStatInterval
bool	m_newHigStatInterval
bool	m_newLowStat
bool	m_newLumiBlock
bool	m_newRun
bool	m_newEventsBlock
bool	m_endOfEventsBlock
bool	m_endOfLowStat
bool	m_endOfLumiBlock
bool	m_endOfRun
SG::ReadCondHandleKey< LuminosityCondData >	m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
SG::ReadCondHandleKey< LBDurationCondData >	m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
SG::ReadCondHandleKey< TrigLiveFractionCondData >	m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
bool	m_bookHistogramsInitial
bool	m_useLumi
float	m_defaultLBDuration
std::set< Interval_t >	m_supportedIntervalsForRebooking
Imp *	m_d
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

BaseclassMethods Baseclass methods reimplemented
}
SG::AuxElement::Accessor< bool >	m_acc_hasTruthFilled {"hasTruthFilled"}
SG::AuxElement::Decorator< bool >	m_dec_hasTruthFilled {"hasTruthFilled"}
SG::AuxElement::Decorator< bool >	m_dec_passedTruthSelection {"passedTruthSelection"}
SG::AuxElement::Decorator< bool >	m_dec_passedTrackSelection {"passedTrackSelection"}
SG::AuxElement::Accessor< bool >	m_acc_selectedByPileupSwitch {"selectedByPileupSwitch"}
SG::AuxElement::Decorator< bool >	m_dec_selectedByPileupSwitch {"selectedByPileupSwitch"}
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_trkParticleName {this,"TrackParticleContainerName", "InDetTrackParticles"}
	TrackParticle container's name.
SG::ReadHandleKey< xAOD::TruthParticleContainer >	m_truthParticleName {this, "TruthParticleContainerName", "TruthParticles", ""}
	TruthParticle container's name.
SG::ReadHandleKey< xAOD::VertexContainer >	m_vertexContainerName {this,"VertexContainerName", "PrimaryVertices", ""}
	Primary vertex container's name.
SG::ReadHandleKey< xAOD::TruthVertexContainer >	m_truthVertexContainerName {this,"TruthVertexContainerName", "TruthVertices",""}
	Truth vertex container's name.
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoContainerName {this,"EventInfoContainerName", "EventInfo", ""}
	EventInfo container name.
SG::ReadHandleKey< xAOD::TruthEventContainer >	m_truthEventName {this, "TruthEvents", "TruthEvents","Name of the truth events container probably either TruthEvent or TruthEvents"}
SG::ReadHandleKey< xAOD::TruthPileupEventContainer >	m_truthPileUpEventName {this, "TruthPileupEvents", "TruthPileupEvents","Name of the truth pileup events container probably TruthPileupEvent(s)"}
SG::ReadHandleKey< xAOD::JetContainer >	m_jetContainerName {this, "JetContainerName", "AntiKt4LCTopoJets" , ""}
std::vector< SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > >	m_floatTrkDecor
std::vector< SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > >	m_intTrkDecor
std::vector< SG::ReadDecorHandleKey< xAOD::TruthParticleContainer > >	m_floatTruthDecor
std::vector< SG::ReadDecorHandleKey< xAOD::TruthParticleContainer > >	m_intTruthDecor
std::vector< SG::ReadDecorHandleKey< xAOD::JetContainer > >	m_intJetDecor
std::vector< SG::ReadDecorHandleKey< xAOD::TrackParticleContainer > >	m_linkTrkDecor
std::unique_ptr< InDetRttPlots >	m_monPlots
	histograms
BooleanProperty	m_useTrackSelection {this, "useTrackSelection", false, "plot only tracks accepted by selection tool"}
	Properties to fine-tune the tool behaviour.
BooleanProperty	m_doTruthOriginPlots {this, "doTruthOriginPlots", false, "do plots split by track truth origin"}
BooleanProperty	m_doDuplicatePlots {this, "doDuplicatePlots", false, "Fill duplicate=multi-track per particle plots"}
BooleanProperty	m_doPerAuthorPlots {this, "doPerAuthorPlots", false, "do plots split by track author"}
BooleanProperty	m_doTrackInJetPlots {this, "FillTrackInJetPlots", true, "Fill plots for tracks in jets"}
BooleanProperty	m_doHitLevelPlots {this, "doHitLevelPlots", false, "Fill hit efficiency and residual plots"}
BooleanProperty	m_doBjetPlots {this, "FillTrackInBJetPlots", false, "Fill plots for tracks in truth-b-tagged jets"}
BooleanProperty	m_fillTruthToRecoNtuple {this, "FillTruthToRecoNtuple", false, "Fill an ntuple with truth and matching reco info for more detailed stuidies"}
BooleanProperty	m_useVertexTruthMatchTool {this, "useVertexTruthMatchTool", false, "Use the vertex truth matching tool"}
BooleanProperty	m_onlyFillMatched {this, "onlyFillTruthMatched", false, "Only fill truth-to-reco (eff, reso, matched hit) plots"}
BooleanProperty	m_doTRTExtensionPlots {this, "doTRTExtensionPlots", true, "do TRT extension plots"}
BooleanProperty	m_useGRL {this, "useGRL", false, "Apply GRL selection or not when running on data"}
BooleanProperty	m_doIDTIDEPlots {this, "doIDTIDEPlots", false, "do ID TIDE derivation plots"}
BooleanProperty	m_fillTechnicalEfficiency {this, "fillTechnicalEfficiency", false, "Fill the technical efficiency plot. Requires additional sihit information in input file"}
BooleanProperty	m_doPRW {this,"doPRW",false,"apply pileup reweight"}
FloatProperty	m_maxTrkJetDR {this,"maxTrkJetDR",0.4,"the maximum dR to jets to allow for track-in-jet plots"}
StringProperty	m_dirName {this, "DirName", "SquirrelPlots/", "Top level directory to write histograms into"}
StringProperty	m_folder {this, "SubFolder", "", "Subfolder to add for plots if desired. Used when working with multiple IDPVM tool instances."}
StringProperty	m_pileupSwitch {this, "PileupSwitch", "HardScatter", "Pileup truth strategy to use. May be \"All\", \"HardScatter\", or \"PileUp\""}
StringProperty	m_setCSVName {this, "setCSVName", "", "convert AOD to a scv file"}
FloatProperty	m_lowProb {this,"LowProb",0.5,"Truth match prob. cutoff for efficiency (lower bound) and fake (upper bound) classification."}
FloatProperty	m_highProb {this,"HighProb",0.8,"Truth match prob. cutoff - currently unused"}
DoubleArrayProperty	m_etaBins {this, "EtaBins", {}}
IntegerArrayProperty	m_minHits {this, "MinNumberClusters", {}}
FloatProperty	m_jetAbsEtaMin {this, "JetAbsEtaMin", 0.f, "Minimum Eta value for jet selection"}
FloatProperty	m_jetAbsEtaMax {this, "JetAbsEtaMax", 2.5f, "Maximum Eta value for jet selection"}
FloatProperty	m_jetPtMin {this, "JetPtMin", 100.0f, "Minimum Jet pT for jet selection in GeV"}
FloatProperty	m_jetPtMax {this, "JetPtMax", 5000.0f, "Maximum Jet pT for jet selection in GeV"}
BooleanProperty	m_isITk {this, "isITk", false, "Whether config is set for ITk, to enable/disable some plots"}
BooleanProperty	m_hasHGTDReco {this, "hasHGTDReco", false, "Whether config is set for HGTD reco, to enable/disable some plots"}
ToolHandle< InDet::IInDetTrackSelectionTool >	m_trackSelectionTool {this, "TrackSelectionTool", "InDet::InDetTrackSelectionTool/TrackSelectionTool", "Track selection tool to use"}
ToolHandle< IInDetVertexTruthMatchTool >	m_vtxValidTool {this, "VertexTruthMatchTool", "InDetVertexTruthMatchTool/VtxTruthMatchTool", "Vertex truth matching tool to use"}
ToolHandle< IAthSelectionTool >	m_truthSelectionTool {this, "TruthSelectionTool","AthTruthSelectionTool", "Truth selection tool (for efficiencies and resolutions)"}
ToolHandle< InDet::IInDetTrackTruthOriginTool >	m_trackTruthOriginTool {this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool","truth track origin tool"}
ToolHandle< InDet::IInDetHardScatterSelectionTool >	m_hardScatterSelectionTool
ToolHandle< IGoodRunsListSelectionTool >	m_grlTool {this, "GoodRunsListSelectionTool", "GoodRunsListSelectionTool/GoodRunsListSelectionTool", "GRL selection tool"}
SG::ReadDecorHandleKey< xAOD::EventInfo >	m_weight_pileup_key {this, "PileupWeight_NOSYS", m_eventInfoContainerName, "PileupWeight_NOSYS"}
std::mutex	m_mutex
CutFlow m_truthCutFlow	ATLAS_THREAD_SAFE
std::vector< int >	m_prospectsMatched
int	m_truthCounter = 0
std::ofstream	m_datfile
std::vector< std::string >	m_trackCutflowNames
std::vector< int >	m_trackCutflow
bool	m_usingSpecialPileupSwitch {false}
virtual StatusCode	initialize ()
virtual StatusCode	bookHistograms ()
	An inheriting class should either override this function or bookHists().
virtual StatusCode	fillHistograms (const EventContext &ctx)
	An inheriting class should either override this function or fillHists().
virtual StatusCode	procHistograms ()
	An inheriting class should either override this function or finalHists().
	InDetPhysValMonitoringTool ()
	prevent default construction
void	fillTrackCutFlow (const asg::AcceptData &accept)
const std::vector< const xAOD::TruthParticle * >	getTruthParticles (const EventContext &ctx) const
std::pair< std::vector< const xAOD::TruthVertex * >, std::vector< const xAOD::TruthVertex * > >	getTruthVertices (const EventContext &ctx) const
InDetRttPlotConfig	getFilledPlotConfig () const
	Generate an Rtt config struct based on the user-passed properties.
int	getIndexByEta (const xAOD::TruthParticle &truth) const
	Utility function for evaluation of technical efficiency.
const Trk::TrackParameters *	getUnbiasedTrackParameters (const Trk::TrackParameters *trkParameters, const Trk::MeasurementBase *measurement)
StatusCode	fillHistogramsTrackingInDenseEnvironment (const EventContext &ctx, IDPVM::CachedGetAssocTruth &getAsTruth, const std::vector< const xAOD::TruthParticle * > &truthParticles, const xAOD::TrackParticleContainer &tracks, const xAOD::Vertex *primaryvertex, float beamSpotWeight)
void	decorateTrackParticle (const xAOD::TrackParticle &track, const asg::AcceptData &passed) const
void	decorateTruthParticle (const xAOD::TruthParticle &truth, const IAthSelectionTool::CutResult &passed) const
bool	hasTruthFilled (const xAOD::TruthParticle &truth) const
bool	isSelectedByPileupSwitch (const xAOD::TruthParticle &truth) const
void	markSelectedByPileupSwitch (const std::vector< const xAOD::TruthParticle * > &truthParticles) const
bool	passJetCuts (const xAOD::Jet &jet) const
static void	fillCutFlow (const asg::AcceptData &accept, std::vector< std::string > &names, std::vector< int > &cutFlow)

Detailed Description

Tool to book and fill inner detector histograms for physics validation.

Definition at line 64 of file InDetPhysValMonitoringTool.h.

Member Typedef Documentation

MDMap_t

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

protectedinherited

Definition at line 733 of file ManagedMonitorToolBase.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

Interval_t

enum ManagedMonitorToolBase::Interval_t

inherited

An enumeration describing the interval over which a particular monitoring object is filled (i.e., interval over which the method Fill(...) is called).

This information may be stored with the monitoring object if an application is only able to partially fill the object (i.e., a job sees only part of a run or fill). This information may be ignored in some running Environments. The 'fill' interval corresponds to a fill of the LHC. The 'all' interval corresponds to all available data. The 'lumiBlock' and 'fill' intervals are only valid for the 'collisions' DataType_t.

Enumerator
file
eventsBlock
lumiBlock
lowStat
medStat
higStat
run
fill
all

Definition at line 61 of file ManagedMonitorToolBase.h.

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

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

Constructor & Destructor Documentation

InDetPhysValMonitoringTool() [1/2]

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

Constructor with parameters.

Parametrized constructor.

Definition at line 107 of file InDetPhysValMonitoringTool.cxx.

                                                                                 :
  ManagedMonitorToolBase(type, name, parent){
}

~InDetPhysValMonitoringTool()

InDetPhysValMonitoringTool::~InDetPhysValMonitoringTool ( )

virtualdefault

Destructor.

InDetPhysValMonitoringTool() [2/2]

InDetPhysValMonitoringTool::InDetPhysValMonitoringTool ( )

private

prevent default construction

Member Function Documentation

bookHistograms()

StatusCode InDetPhysValMonitoringTool::bookHistograms ( )

virtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 720 of file InDetPhysValMonitoringTool.cxx.

                                           {
  ATH_MSG_INFO("Booking hists " << name() << "with detailed level: " << m_detailLevel);
  m_monPlots->initialize();
  std::vector<HistData> hists = m_monPlots->retrieveBookedHistograms();
  for (const auto& hist : hists) {
    ATH_CHECK(regHist(hist.first, hist.second, all)); // ??
  }
  // do the same for Efficiencies, but there's a twist:
  std::vector<EfficiencyData> effs = m_monPlots->retrieveBookedEfficiencies();
  for (auto& eff : effs) {
    // reg**** in the monitoring baseclass doesnt have a TEff version, but TGraph *
    // pointers just get passed through, so we use that method after an ugly cast
    ATH_CHECK(regGraph(reinterpret_cast<TGraph*>(eff.first), eff.second, all)); // ??
  }
  // register trees for ntuple writing
  if (m_fillTruthToRecoNtuple) {
    std::vector<TreeData> trees = m_monPlots->retrieveBookedTrees();
    for (auto& t : trees) {
      ATH_CHECK(regTree(t.first, t.second, all));
    }
  }
 
  return StatusCode::SUCCESS;
}

bookHistogramsRecurrent()

StatusCode ManagedMonitorToolBase::bookHistogramsRecurrent ( )

virtualinherited

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

Reimplemented in ManagedMonitorToolTest, MdtVsRpcRawDataValAlg, and MdtVsTgcRawDataValAlg.

Definition at line 1179 of file ManagedMonitorToolBase.cxx.

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

Definition at line 646 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;
}

checkHists()

StatusCode ManagedMonitorToolBase::checkHists ( bool calledFromFinalize )

virtualinherited

This implementation does nothing; equivalent functionality may be provided by procHists(...) with appropriate arguments.

Implements IMonitorToolBase.

Reimplemented in CscCalibMonToolBase.

Definition at line 1561 of file ManagedMonitorToolBase.cxx.

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

declareGaudiProperty()

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

decorateTrackParticle()

void InDetPhysValMonitoringTool::decorateTrackParticle ( const xAOD::TrackParticle & track, const asg::AcceptData & passed ) const

private

Definition at line 684 of file InDetPhysValMonitoringTool.cxx.

                                                                                                                          {
  // Decorate outcome of track selection
  m_dec_passedTrackSelection(track) = (bool)(passed);
}

decorateTruthParticle()

void InDetPhysValMonitoringTool::decorateTruthParticle ( const xAOD::TruthParticle & truth, const IAthSelectionTool::CutResult & passed ) const

private

Definition at line 689 of file InDetPhysValMonitoringTool.cxx.

                                                                                                                                       {  
  // Decorate outcome of truth selection
  m_dec_passedTruthSelection(truth) = (bool)(passed);
 
  // Decorate if selected by pileup switch
  m_dec_selectedByPileupSwitch(truth) = isSelectedByPileupSwitch(truth);
}

deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph * g )

virtualinherited

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

Definition at line 1515 of file ManagedMonitorToolBase.cxx.

{
   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 1507 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 1533 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 1523 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.

{ return m_detStore; }

endOfEventsBlockFlag()

bool ManagedMonitorToolBase::endOfEventsBlockFlag ( ) const

inlineprotectedinherited

Definition at line 721 of file ManagedMonitorToolBase.h.

{ return m_endOfEventsBlock; }

endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const

inlineprotectedinherited

Definition at line 722 of file ManagedMonitorToolBase.h.

{ return m_endOfLowStat; }

endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 723 of file ManagedMonitorToolBase.h.

{ return m_endOfLumiBlock; }

endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const

inlineprotectedinherited

Definition at line 724 of file ManagedMonitorToolBase.h.

{ return m_endOfRun; }

evtStore()

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

{ 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

fillCutFlow()

void InDetPhysValMonitoringTool::fillCutFlow ( const asg::AcceptData & accept, std::vector< std::string > & names, std::vector< int > & cutFlow )

staticprivate

Definition at line 911 of file InDetPhysValMonitoringTool.cxx.

                                                                 {
  // initialise cutflows
  if (cutFlow.empty()) {
    names.emplace_back("preCut");
    cutFlow.push_back(0);
    for (unsigned int i = 0; i != accept.getNCuts(); ++i) {
      cutFlow.push_back(0);
      names.push_back((std::string) accept.getCutName(i));
    }
  }
  // get cutflow
  cutFlow[0] += 1;
  bool cutPositive = true;
  for (unsigned int i = 0; i != (accept.getNCuts() + 1); ++i) {
    if (!cutPositive) {
      continue;
    }
    if (accept.getCutResult(i)) {
      cutFlow[i + 1] += 1;
    } else {
      cutPositive = false;
    }
  }
  }

fillHistograms()

StatusCode InDetPhysValMonitoringTool::fillHistograms ( const EventContext & ctx )

virtual

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

In case of no HS, print a debug message - no warning since this is expected in single particle MC. The downstream code is able to handle the absence of a HS vertex.

Reimplemented from ManagedMonitorToolBase.

Definition at line 310 of file InDetPhysValMonitoringTool.cxx.

                                                                  {
  ATH_MSG_DEBUG("Filling hists " << name() << "...");
  // function object could be used to retrieve truth: IDPVM::CachedGetAssocTruth getTruth;
 
  // retrieve trackParticle container
  SG::ReadHandle<xAOD::TrackParticleContainer> trackHandle(m_trkParticleName, ctx);
  if (not trackHandle.isValid()) {
    ATH_MSG_ERROR("Invalid trackname = " << m_trkParticleName << "!");
    return StatusCode::FAILURE;
  }
  const xAOD::TrackParticleContainer* tracks = trackHandle.cptr();
  
  SG::ReadHandle<xAOD::TruthPileupEventContainer> truthPileupEventContainer;
  if( not m_truthPileUpEventName.key().empty()) {
    truthPileupEventContainer = SG::ReadHandle<xAOD::TruthPileupEventContainer> (m_truthPileUpEventName, ctx);
  }
 
  SG::ReadHandle<xAOD::EventInfo> pie = SG::ReadHandle<xAOD::EventInfo>(m_eventInfoContainerName, ctx);
  if (not pie.isValid()){
    ATH_MSG_WARNING("Shouldn't happen - EventInfo is buggy, setting mu to 0");
  }
  
  // FIX-ME: I'm not sure if we should stop execution if EventInfo is not valid ...
  // it is used after as if they assume it is valid
  if (m_useGRL and pie.isValid() and !pie->eventType(xAOD::EventInfo::IS_SIMULATION)) {
      if (!m_grlTool->passRunLB(*pie)) {
      ATH_MSG_VERBOSE("GRL veto");
      return StatusCode::SUCCESS;
      }
  }
 
  std::vector<const xAOD::TruthParticle*> truthParticlesVec = getTruthParticles(ctx);
 
  // Mark the truth particles in our vector as "selected". 
  // This is needed because we later access the truth matching via xAOD decorations, where we do not 'know' about membership to this vector.
  if (m_usingSpecialPileupSwitch) markSelectedByPileupSwitch(truthParticlesVec);
  const xAOD::EventInfo *eventInfo = nullptr;
  ATH_CHECK (evtStore()->retrieve (eventInfo, "EventInfo"));
  IDPVM::CachedGetAssocTruth getAsTruth; // only cache one way, track->truth, not truth->tracks 
 
  unsigned int truthMu = 0;
  float actualMu = 0.;
  if(not m_truthPileUpEventName.key().empty() and truthPileupEventContainer.isValid()){
    truthMu = static_cast<int>( truthPileupEventContainer->size() );
  }
  if(pie.isValid()) actualMu = pie->actualInteractionsPerCrossing();
 
  // This is questionable but kept for backward compatibility for now
  float puEvents = truthMu>0 ? truthMu : actualMu;
 
  const xAOD::Vertex* primaryvertex = nullptr;
  unsigned int nVertices = 0;
  float beamSpotWeight = 1;
 
  if(not m_vertexContainerName.key().empty()){
    ATH_MSG_DEBUG("Getting number of pu interactings per event");
 
    ATH_MSG_DEBUG("Filling vertex plots");
    SG::ReadHandle<xAOD::VertexContainer>  vertices(m_vertexContainerName, ctx);
    ATH_CHECK(vertices.isValid());
    
    nVertices = not vertices->empty() ? vertices->size() : 0;
    beamSpotWeight = pie->beamSpotWeight();
    ATH_MSG_DEBUG("beamSpotWeight is equal to " <<  beamSpotWeight);
    if(m_doPRW){
      float prwWeight = 1;
      SG::ReadDecorHandle<xAOD::EventInfo,float> readDecorHandle (m_weight_pileup_key, ctx);
      if(readDecorHandle.isAvailable()) prwWeight = readDecorHandle(*pie);
      ATH_MSG_DEBUG("Applying pileup weight equal to " << prwWeight);
      beamSpotWeight *= prwWeight;
    } 
 
    if (vertices.isValid() and not vertices->empty()) {
      ATH_MSG_DEBUG("Number of vertices retrieved for this event " << vertices->size());
      //Find the HS vertex following the user-configured strategy
      if (m_hardScatterSelectionTool.empty()) {
        for (const auto& vertex : *vertices){
          if(vertex->vertexType()==xAOD::VxType::PriVtx){
            primaryvertex = vertex;
            break;
          }
        }
      } else {
        primaryvertex = m_hardScatterSelectionTool->getHardScatter(vertices.get());
      }
 
      if (!primaryvertex){
    ATH_MSG_DEBUG("Failed to find a hard scatter vertex in this event.");
      }
      //Filling plots for all reconstructed vertices and the hard-scatter
      ATH_MSG_DEBUG("Filling vertices info monitoring plots");
 
      // Fill vectors of truth HS and PU vertices
      std::pair<std::vector<const xAOD::TruthVertex*>, std::vector<const xAOD::TruthVertex*>> truthVertices = getTruthVertices(ctx);
      std::vector<const xAOD::TruthVertex*> truthHSVertices = truthVertices.first;
      std::vector<const xAOD::TruthVertex*> truthPUVertices = truthVertices.second;
 
      // Decorate vertices
      if (m_useVertexTruthMatchTool && m_vtxValidTool) {
    ATH_CHECK(m_vtxValidTool->matchVertices(*vertices));
    ATH_MSG_DEBUG("Hard scatter classification type: " << InDetVertexTruthMatchUtils::classifyHardScatter(*vertices) << ", vertex container size = " << vertices->size());
      }
      m_monPlots->fill(*vertices, primaryvertex, truthHSVertices, truthPUVertices, actualMu,  beamSpotWeight);
      
      ATH_MSG_DEBUG("Filling vertex/event info monitoring plots");
      //Filling vertexing plots for the reconstructed hard-scatter as a function of mu
      m_monPlots->fill(*vertices, truthMu, actualMu, beamSpotWeight);
    } else {
      //FIXME: Does this happen for single particles?
      ATH_MSG_WARNING("Skipping vertexing plots.");
    }
  }
 
  if( not m_truthVertexContainerName.key().empty()){
    // get truth vertex container name - m_truthVertexContainerName
    SG::ReadHandle<xAOD::TruthVertexContainer> truthVrt = SG::ReadHandle<xAOD::TruthVertexContainer>( m_truthVertexContainerName, ctx );
 
    //
    //Get the HS vertex position from the truthVertexContainer
    //FIXME: Add plots w.r.t truth HS positions (vertexing plots)
    //
    const xAOD::TruthVertex* truthVertex = nullptr;
    if (truthVrt.isValid()) {
      const auto& stdVertexContainer = truthVrt->stdcont();
      //First truth particle vertex?
      auto findVtx = std::find_if(stdVertexContainer.rbegin(), stdVertexContainer.rend(), acceptTruthVertex);
      truthVertex = (findVtx == stdVertexContainer.rend()) ? nullptr : *findVtx;
    } else {
      ATH_MSG_WARNING("Cannot open " << m_truthVertexContainerName.key() << " truth vertex container");
    }
    if (not truthVertex) ATH_MSG_INFO ("Truth vertex did not pass cuts");
  }
  //
  //Counters for cutflow
  //
  unsigned int nSelectedTruthTracks(0), nSelectedRecoTracks(0), nSelectedMatchedTracks(0), nAssociatedTruth(0), nMissingAssociatedTruth(0), nTruths(0);
 
  CutFlow tmp_truth_cutflow( m_truthSelectionTool.get() ?  m_truthSelectionTool->nCuts() : 0 );
  
  //
  //Loop over all reconstructed tracks
  //
  // If writing ntuples, use a truth-to-track(s) cache to handle truth matching.
  // Based on the assumption that multiple tracks can (albeit rarely) share the same truth association.
  std::map<const xAOD::TruthParticle*, std::vector<const xAOD::TrackParticle*>> cacheTruthMatching {};
  //
  std::vector<const xAOD::TrackParticle*> selectedTracks {};
  selectedTracks.reserve(tracks->size());
  unsigned int nTrackTOT = 0;
  unsigned int nTrackCentral = 0;
  unsigned int nTrackPt1GeV = 0;
  for (const auto *const thisTrack: *tracks) {
    //FIXME: Why is this w.r.t the primary vertex?
    const asg::AcceptData& accept = m_trackSelectionTool->accept(*thisTrack, primaryvertex);
    if (m_useTrackSelection and not accept) continue;
    fillTrackCutFlow(accept); //?? Is this equal???
 
    selectedTracks.push_back(thisTrack);
    //Number of selected reco tracks
    nSelectedRecoTracks++;
 
    //Fill plots for selected reco tracks, hits / perigee / ???
    nTrackTOT++;
    if (thisTrack->pt() >= (1 * Gaudi::Units::GeV))
    nTrackPt1GeV++;
    if (std::abs(thisTrack->eta()) < 2.5)
    nTrackCentral++;
    m_monPlots->fill(*thisTrack, beamSpotWeight);                                      
    m_monPlots->fill(*thisTrack, puEvents, nVertices, beamSpotWeight);  //fill mu dependent plots
    const xAOD::TruthParticle* associatedTruth = getAsTruth.getTruth(thisTrack);
    float prob = getMatchingProbability(*thisTrack); 
 
    // This is where the Fake, and Really Fake fillers need to go. Where would the really really fakes go?
    if (associatedTruth) {
      nAssociatedTruth++;
 
      // if there is associated truth also a truth selection tool was retrieved.
      IAthSelectionTool::CutResult passed( m_truthSelectionTool ?  m_truthSelectionTool->accept(associatedTruth) : IAthSelectionTool::CutResult(0) );
      if (m_truthSelectionTool) {
        //FIXME: What is this for???
        tmp_truth_cutflow.update( passed.missingCuts() );
      }
 
      if ((not std::isnan(prob)) and (prob > m_lowProb) and passed and (not m_usingSpecialPileupSwitch or isSelectedByPileupSwitch(*associatedTruth)) ) {
        nSelectedMatchedTracks++; 
        bool truthIsFromB = false;
        if ( m_doTruthOriginPlots and m_trackTruthOriginTool->isFrom(associatedTruth, 5) ) {
          truthIsFromB = true;
        }
        m_monPlots->fill(*thisTrack, *associatedTruth, truthIsFromB, puEvents, beamSpotWeight); // Make plots requiring matched truth
      }
    }
 
    const bool isAssociatedTruth = associatedTruth != nullptr;
    const bool isFake = not std::isnan(prob) ? (prob < m_lowProb) : true;
 
    if(!isAssociatedTruth) nMissingAssociatedTruth++;
    m_monPlots->fillFakeRate(*thisTrack, isFake, puEvents, beamSpotWeight);
 
    if (m_fillTruthToRecoNtuple || m_doDuplicatePlots) {
      // Decorate track particle with extra flags
      decorateTrackParticle(*thisTrack, accept);
 
      if (isAssociatedTruth) {
        // Decorate truth particle with extra flags
        decorateTruthParticle(*associatedTruth, m_truthSelectionTool->accept(associatedTruth));
 
        // Cache truth-to-track associations
        auto cachedAssoc = cacheTruthMatching.find(associatedTruth);
        // Check if truth particle already present in cache
        if (cachedAssoc == cacheTruthMatching.end()) {
          // If not yet present, add truth-to-track association in cache
          cacheTruthMatching[associatedTruth] = {thisTrack};
        }
        else {
          // If already present, cache additional track associations (here multiple track particle can be linked to the same truth particle)
          cachedAssoc->second.push_back(thisTrack);
        }
      }
      else if(m_fillTruthToRecoNtuple){
        // Fill track only entries with dummy truth values
        m_monPlots->fillNtuple(*thisTrack, primaryvertex);
      }
    }
  }
  if (m_fillTruthToRecoNtuple || m_doDuplicatePlots) {
    // Now fill all truth-to-track associations
    // Involves some double-filling of truth particles in cases where multiple tracks share the same truth association,
    // these duplicates can be filtered in the ntuple by selecting only the 'best matched' truth-associated track particles.
    for (auto& cachedAssoc: cacheTruthMatching) {
      const xAOD::TruthParticle* thisTruth = cachedAssoc.first;
 
      // Decorate that this truth particle is being filled to prevent double counting in truth particle loop
      m_dec_hasTruthFilled(*thisTruth) = true;
 
      // Sort all associated tracks by truth match probability
      std::sort(cachedAssoc.second.begin(), cachedAssoc.second.end(), 
        [](const xAOD::TrackParticle* t1, const xAOD::TrackParticle* t2) { return getMatchingProbability(*t1) > getMatchingProbability(*t2); }
      );
 
      if(m_fillTruthToRecoNtuple){
        // Fill all tracks associated to to this truth particle, also recording 'truth match ranking' as index in probability-sorted vector of matched tracks
        for (int itrack = 0; itrack < (int) cachedAssoc.second.size(); itrack++) {
          const xAOD::TrackParticle* thisTrack = cachedAssoc.second[itrack];
          
          // Fill track entries with truth association
          m_monPlots->fillNtuple(*thisTrack, *thisTruth, primaryvertex, itrack);
        }
      }
    }
  }
 
  m_monPlots->fill(nTrackTOT, nTrackCentral, nTrackPt1GeV, truthMu, actualMu, nVertices, beamSpotWeight);
 
  //FIXME: I don't get why... this is here
  if (m_truthSelectionTool.get()) {
    ATH_MSG_DEBUG( CutFlow(tmp_truth_cutflow).report(m_truthSelectionTool->names()) );
    std::lock_guard<std::mutex> lock(m_mutex);
    m_truthCutFlow.merge(std::move(tmp_truth_cutflow));
  }
  
  //
  //TruthParticle loop to fill efficiencies
  //
  for (int itruth = 0; itruth < (int) truthParticlesVec.size(); itruth++) {  // Outer loop over all truth particles
    nTruths++;
    const xAOD::TruthParticle* thisTruth = truthParticlesVec[itruth];
 
    // if the vector of truth particles is not empty also a truthSelectionTool was retrieved
    const IAthSelectionTool::CutResult accept = m_truthSelectionTool->accept(thisTruth);
    if (accept) {
      ++nSelectedTruthTracks; // total number of truth which pass cuts per event
      bool isEfficient(false); // weight for the trackeff histos
      float matchingProbability{};
      m_monPlots->fill(*thisTruth, beamSpotWeight); // This is filling truth-only plots
 
      if(m_doDuplicatePlots){
        auto cachedAssoc = cacheTruthMatching.find(thisTruth);
        // Check if truth particle already present in cache
        if (cachedAssoc == cacheTruthMatching.end()) {
          // If not yet present, then no track associated
          cacheTruthMatching[thisTruth] = {};
        }
        m_monPlots->fillDuplicate(*thisTruth, cacheTruthMatching[thisTruth], beamSpotWeight);
      }
 
      //
      //Loop over reco tracks to find the match
      //
      const xAOD::TrackParticle* matchedTrack = nullptr;
      for (const auto& thisTrack: selectedTracks) { // Inner loop over selected track particleis
        const xAOD::TruthParticle* associatedTruth = getAsTruth.getTruth(thisTrack);
        if (associatedTruth && associatedTruth == thisTruth) {
          float prob = getMatchingProbability(*thisTrack);
          if (not std::isnan(prob) && prob > m_lowProb) {
            matchingProbability = prob;
            isEfficient = true;
            matchedTrack = thisTrack;
            break;
          }
        }
      }
      if (!m_setCSVName.empty()) {
          m_datfile <<eventInfo->eventNumber()<<","<<thisTruth->pdgId()<<","<<thisTruth->px()/ Gaudi::Units::GeV<<","
                <<thisTruth->py()/ Gaudi::Units::GeV<<","<<thisTruth->pz()/ Gaudi::Units::GeV<<","
                <<thisTruth->e()/ Gaudi::Units::GeV<<","<<thisTruth->pt()/ Gaudi::Units::GeV<<","
                <<thisTruth->eta()<<","<<thisTruth->phi()<<","<<thisTruth->m()/ Gaudi::Units::GeV<<","
                <<puEvents<<","<<nVertices<<","<<matchingProbability<<std::endl;
      }
      if (!thisTruth){ 
        ATH_MSG_ERROR("An error occurred: Truth particle for tracking efficiency calculation is a nullptr");
      }
      else if (isEfficient && !matchedTrack){
        ATH_MSG_ERROR("Something went wrong - we log a truth particle as reconstructed, but the reco track is a nullptr! Bailing out... ");  
      }
      else{ 
        ATH_MSG_DEBUG("Filling efficiency plots info monitoring plots");
        m_monPlots->fillEfficiency(*thisTruth, matchedTrack, isEfficient, truthMu, actualMu, beamSpotWeight);
        if (m_fillTechnicalEfficiency) {
          ATH_MSG_DEBUG("Filling technical efficiency plots info monitoring plots");
          static const SG::ConstAccessor< float > nSilHitsAcc("nSilHits");
          if (nSilHitsAcc.isAvailable(*thisTruth)) {
            if (nSilHitsAcc(*thisTruth) >= m_minHits.value().at(getIndexByEta(*thisTruth))){
              m_monPlots->fillTechnicalEfficiency(*thisTruth, isEfficient,
                          truthMu, actualMu, beamSpotWeight);
        }
          } else {
            ATH_MSG_DEBUG("Cannot fill technical efficiency. Missing si hit information for truth particle.");
          }
        }
      }
    }
    
    if (m_fillTruthToRecoNtuple && thisTruth) {
      // Skip if already filled in track loop
      if (hasTruthFilled(*thisTruth)) continue;
 
      // Decorate truth particle with extra flags
      decorateTruthParticle(*thisTruth, accept);
      
      // Fill truth only entries with dummy track values
      m_monPlots->fillNtuple(*thisTruth);
    }
  }
 
  if (nSelectedRecoTracks == nMissingAssociatedTruth) {
    if (not m_truthParticleName.key().empty()) {
      ATH_MSG_DEBUG("NO TRACKS had associated truth.");
    }
  } else {
    ATH_MSG_DEBUG(nAssociatedTruth << " tracks out of " << tracks->size() << " had associated truth.");
  }
 
  m_monPlots->fillCounter(nSelectedRecoTracks, InDetPerfPlot_nTracks::SELECTEDRECO, beamSpotWeight);
  m_monPlots->fillCounter(tracks->size(), InDetPerfPlot_nTracks::ALLRECO, beamSpotWeight);
  m_monPlots->fillCounter(nSelectedTruthTracks, InDetPerfPlot_nTracks::SELECTEDTRUTH, beamSpotWeight);
  m_monPlots->fillCounter(nTruths, InDetPerfPlot_nTracks::ALLTRUTH, beamSpotWeight);
  m_monPlots->fillCounter(nAssociatedTruth, InDetPerfPlot_nTracks::ALLASSOCIATEDTRUTH, beamSpotWeight);
  m_monPlots->fillCounter(nSelectedMatchedTracks, InDetPerfPlot_nTracks::MATCHEDRECO, beamSpotWeight);
  
  // Tracking In Dense Environment
  if (m_doTrackInJetPlots) {
    ATH_CHECK( fillHistogramsTrackingInDenseEnvironment(ctx,
                            getAsTruth,
                            truthParticlesVec,
                            *tracks,
                            primaryvertex,
                            beamSpotWeight) );
  }
  return StatusCode::SUCCESS;
}

fillHistogramsTrackingInDenseEnvironment()

StatusCode InDetPhysValMonitoringTool::fillHistogramsTrackingInDenseEnvironment ( const EventContext & ctx, IDPVM::CachedGetAssocTruth & getAsTruth, const std::vector< const xAOD::TruthParticle * > & truthParticles, const xAOD::TrackParticleContainer & tracks, const xAOD::Vertex * primaryvertex, float beamSpotWeight )

private

Definition at line 951 of file InDetPhysValMonitoringTool.cxx.

                                                              {
  // Define accessors
  static const SG::ConstAccessor<std::vector<ElementLink<xAOD::IParticleContainer> > > ghosttruth("GhostTruth");
  static const SG::ConstAccessor<int> btagLabel("HadronConeExclTruthLabelID");
 
  if (truthParticles.empty()) {
    ATH_MSG_WARNING("No entries in TruthParticles truth particle container. Skipping jet plots.");
    return StatusCode::SUCCESS;
  }
  
  SG::ReadHandle<xAOD::JetContainer> jetHandle(m_jetContainerName, ctx);
  if (not jetHandle.isValid()) {
    ATH_MSG_WARNING("Cannot open jet container " << m_jetContainerName.key() << ". Skipping jet plots.");
    return StatusCode::SUCCESS;
  }
  const xAOD::JetContainer* jets = jetHandle.cptr();
 
  // loop on jets
  for (const xAOD::Jet *const thisJet: *jets) {
    // pass jet cuts
    if (not passJetCuts(*thisJet)) continue;
    // check if b-jet
    bool isBjet = false;
    if (not btagLabel.isAvailable(*thisJet)){
      ATH_MSG_WARNING("Failed to extract b-tag truth label from jet");
    } else {
      isBjet = (btagLabel(*thisJet) == 5);
    }
 
    // Retrieve associated ghost truth particles
    if(not ghosttruth.isAvailable(*thisJet)) {
      ATH_MSG_WARNING("Failed to extract ghost truth particles from jet");
    } else {
      for(const ElementLink<xAOD::IParticleContainer>& el : ghosttruth(*thisJet)) {
    if (not el.isValid()) continue;
 
    const xAOD::TruthParticle *truth = static_cast<const xAOD::TruthParticle*>(*el);
    
    // Check if ghost truth is in event TruthParticle vector
    if (m_pileupSwitch != "All") {
      if (std::find(truthParticles.begin(), truthParticles.end(), truth) == truthParticles.end()) {
        continue;
      }
    }
 
    // Check delta R between track and jet axis
    if (thisJet->p4().DeltaR(truth->p4()) > m_maxTrkJetDR) {
      continue;
    }
    // Apply truth selection cuts
    const IAthSelectionTool::CutResult accept = m_truthSelectionTool->accept(truth);      
    if(!accept) continue;
    
    bool isEfficient(false);
    
    for (const auto *thisTrack: tracks) {
      if (m_useTrackSelection and not (m_trackSelectionTool->accept(*thisTrack, primaryvertex))) {
        continue;
      }
      
      const xAOD::TruthParticle* associatedTruth = getAsTruth.getTruth(thisTrack);
      if (associatedTruth and associatedTruth == truth) {
        float prob = getMatchingProbability(*thisTrack);
        if (not std::isnan(prob) && prob > m_lowProb) {
          isEfficient = true;
          break;
        }
      }
    }
    
    bool truthIsFromB = false;
    if ( m_doTruthOriginPlots and m_trackTruthOriginTool->isFrom(truth, 5) ) {
      truthIsFromB = true;
    }
    m_monPlots->fillEfficiency(*truth, *thisJet, isEfficient, isBjet, truthIsFromB, beamSpotWeight);
      }
    } // ghost truth
 
    // loop on tracks
    for (const xAOD::TrackParticle *thisTrack: tracks) {
      if (m_useTrackSelection and not (m_trackSelectionTool->accept(*thisTrack, primaryvertex))) {
    continue;
      }
      
      if (thisJet->p4().DeltaR(thisTrack->p4()) > m_maxTrkJetDR) {
    continue;
      }
      
      float prob = getMatchingProbability(*thisTrack);
      if(std::isnan(prob)) prob = 0.0;
      
      const xAOD::TruthParticle* associatedTruth = getAsTruth.getTruth(thisTrack); 
      const bool isFake = (associatedTruth && prob < m_lowProb);
      bool truthIsFromB = false;
      if ( m_doTruthOriginPlots and m_trackTruthOriginTool->isFrom(associatedTruth, 5) ) {
    truthIsFromB = true;
      }
      m_monPlots->fill(*thisTrack, *thisJet, isBjet, isFake, truthIsFromB, beamSpotWeight);                                   
      if (associatedTruth){
    m_monPlots->fillFakeRate(*thisTrack, *thisJet, isFake, isBjet, truthIsFromB, beamSpotWeight);
      }
    }
    
  } // loop on jets
  
  return StatusCode::SUCCESS;
}

fillHists()

StatusCode ManagedMonitorToolBase::fillHists ( const EventContext & ctx )

virtualinherited

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

Implements IMonitorToolBase.

Definition at line 656 of file ManagedMonitorToolBase.cxx.

{
 
   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;
 
   m_newLowStatInterval = false;
   m_newMedStatInterval = false;
   m_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() );
 
      if(m_newRun) {
         m_newLumiBlock = true;
         isNewEventsBlock = true;
      }
 
      m_newEventsBlock = isNewEventsBlock;
 
      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;
         }
      }
 
      // 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;
 
   // just duplicates m_newLowStatInterval
   m_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(ctx));
     }
   }
   
 
   // ...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(ctx).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;
}

fillTrackCutFlow()

void InDetPhysValMonitoringTool::fillTrackCutFlow ( const asg::AcceptData & accept )

private

Definition at line 906 of file InDetPhysValMonitoringTool.cxx.

                                                                        {
  fillCutFlow(accept, m_trackCutflowNames, m_trackCutflow);
}

finalHists()

StatusCode ManagedMonitorToolBase::finalHists ( )

virtualinherited

Calls procHists( true, true, true ).

Implements IMonitorToolBase.

Definition at line 1153 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;
 
     StatusCode sc = procHistograms();
 
     m_d->benchPostProcHistograms();
     return sc;
   }
   return StatusCode::SUCCESS;
}

get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const

inlineprotectedinherited

Definition at line 620 of file ManagedMonitorToolBase.h.

                                              {
          return m_nEvents; 
      }

get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const

inlineprotectedinherited

Definition at line 624 of file ManagedMonitorToolBase.h.

                                              {
          return m_procNEventsProp;
      }

getFilledPlotConfig()

InDetRttPlotConfig InDetPhysValMonitoringTool::getFilledPlotConfig ( ) const

private

Generate an Rtt config struct based on the user-passed properties.

turn off truth if none is present

allow to disable non-truth-matched

account for detail level

Definition at line 193 of file InDetPhysValMonitoringTool.cxx.

                                                                        {
 
 
  InDetRttPlotConfig rttConfig; 
  rttConfig.detailLevel = m_detailLevel; 
 
  rttConfig.isITk = m_isITk;
  rttConfig.hasHGTDReco = m_hasHGTDReco;
 
  rttConfig.doTrkInJetPlots = m_doTrackInJetPlots;
  rttConfig.doTrkInJetPlots_fake = m_doTrackInJetPlots;
  rttConfig.doTrkInJetPlots_matched = m_doTrackInJetPlots;
 
  rttConfig.doHitResidualPlot = m_doHitLevelPlots; 
  rttConfig.doHitEffPlot = m_doHitLevelPlots; 
 
  rttConfig.doTrkInJetPlots_bjets = m_doBjetPlots;
  rttConfig.doTrkInJetPlots_fake_bjets = m_doBjetPlots;
  rttConfig.doTrkInJetPlots_matched_bjets = m_doBjetPlots;
 
  rttConfig.doTrkInJetPlots_truthFromB = m_doTruthOriginPlots && m_doTrackInJetPlots; 
  rttConfig.doResolutionPlotPrim_truthFromB = m_doTruthOriginPlots; 
 
  rttConfig.doNtupleTruthToReco = m_fillTruthToRecoNtuple;
 
  rttConfig.doFakesPerAuthor = m_doPerAuthorPlots;
  rttConfig.doTrackParametersPerAuthor = m_doPerAuthorPlots;
  rttConfig.doEfficienciesPerAuthor = m_doPerAuthorPlots;
  rttConfig.doResolutionsPerAuthor = m_doPerAuthorPlots;
  rttConfig.doHitsRecoTracksPlotsPerAuthor = m_doPerAuthorPlots;
 
  rttConfig.doTrtExtensionPlots = m_doTRTExtensionPlots;
 
  rttConfig.doDuplicatePlots = m_doDuplicatePlots;
  rttConfig.doTechEffPlots = m_fillTechnicalEfficiency;

  if (m_truthParticleName.key().empty()){
    rttConfig.doFakePlots = false; 
    rttConfig.doHitsFakeTracksPlots = false;
    rttConfig.doEffPlots = false; 
    rttConfig.doResolutionPlotPrim = false; 
    rttConfig.doResolutionPlotPrim_truthFromB = false; 
    rttConfig.doResolutionPlotSecd = false; 
    rttConfig.doHitsMatchedTracksPlots = false; 
    rttConfig.doVertexTruthMatchingPlots = false; 
    rttConfig.doHardScatterVertexTruthMatchingPlots = false; 
    rttConfig.doEfficienciesPerAuthor = false; 
    rttConfig.doFakesPerAuthor = false; 
    rttConfig.doResolutionsPerAuthor = false; 
    rttConfig.doNtupleTruthToReco = false; 
    rttConfig.doTrkInJetPlots_fake_bjets = false;
    rttConfig.doTrkInJetPlots_matched_bjets = false;
    rttConfig.doTrkInJetPlots_truthFromB = false;
    rttConfig.doResolutionPlotPrim_truthFromB = false;
  }

  if (m_onlyFillMatched){ 
    rttConfig.doTrackParameters = false;
    rttConfig.doNTracks = false;
    rttConfig.doHitResidualPlot = false;
    rttConfig.doHitEffPlot = false;
    rttConfig.doHitsRecoTracksPlots = false;
    rttConfig.doTrtExtensionPlots = false;
    rttConfig.doFakePlots = false;
    rttConfig.doHitsFakeTracksPlots = false;
    rttConfig.doVertexPlots = false;
    rttConfig.doVerticesVsMuPlots = false;
    rttConfig.doHardScatterVertexPlots = false;
    rttConfig.doVertexTruthMatchingPlots = false;
    rttConfig.doHardScatterVertexTruthMatchingPlots = false;
    rttConfig.doTrkInJetPlots = false;
    rttConfig.doTrkInJetPlots_bjets = false;
    rttConfig.doTrkInJetPlots_matched = false;
    rttConfig.doTrkInJetPlots_matched_bjets = false;
    rttConfig.doTrkInJetPlots_fake = false;
    rttConfig.doTrkInJetPlots_fake_bjets = false;
    rttConfig.doTrkInJetPlots_truthFromB = false;
  }
 
  // For IDTIDE derivation
  // disable the vertex plots since no covariance from IDTIDE
  if (m_doIDTIDEPlots){ 
    rttConfig.doVertexPlots = false;
    rttConfig.doVerticesVsMuPlots = false;
    rttConfig.doHardScatterVertexPlots = false;
    rttConfig.doVertexTruthMatchingPlots = false;
    rttConfig.doHardScatterVertexTruthMatchingPlots = false;
    rttConfig.doTrkInJetPlots = true;
    rttConfig.doTrkInJetPlots_bjets = true;
    rttConfig.doTrkInJetPlots_matched = true;
    rttConfig.doTrkInJetPlots_matched_bjets = true;
    rttConfig.doTrkInJetPlots_fake = true;
    rttConfig.doTrkInJetPlots_fake_bjets = true;
    rttConfig.doTrkInJetPlots_truthFromB = true;
  }

  if (m_detailLevel < 200){
    rttConfig.doResolutionPlotSecd = false;
    rttConfig.doHitsMatchedTracksPlots = false;
    rttConfig.doHitsFakeTracksPlots = false; 
    rttConfig.doFakesPerAuthor = false;
    rttConfig.doTrackParametersPerAuthor = false;
    rttConfig.doEfficienciesPerAuthor = false;
    rttConfig.doResolutionsPerAuthor = false;
    rttConfig.doTrkInJetPlots_matched = false;  
    rttConfig.doTrkInJetPlots_fake = false;  
    rttConfig.doTrkInJetPlots_matched_bjets = false;  
    rttConfig.doTrkInJetPlots_fake_bjets = false;    
  }
 
  return rttConfig; 
}

getHist() [1/4]

StatusCode ManagedMonitorToolBase::getHist ( TH1 *& h, const std::string & hName, const MonGroup & group )

virtualinherited

Returns a TH1 via the pointer passed as the first argument.

The histogram name, without the leading path or stream name, must be given as the second argument.

Definition at line 1310 of file ManagedMonitorToolBase.cxx.

{
   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 1300 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 1329 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 1319 of file ManagedMonitorToolBase.cxx.

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

getIndexByEta()

int InDetPhysValMonitoringTool::getIndexByEta ( const xAOD::TruthParticle & truth ) const

private

Utility function for evaluation of technical efficiency.

Definition at line 937 of file InDetPhysValMonitoringTool.cxx.

                                                                                  {
  double absEta = std::abs(truth.eta());
  if (absEta > m_etaBins.value().back() || absEta < m_etaBins.value().front()) {
    absEta = std::clamp(absEta, m_etaBins.value().front(), m_etaBins.value().back());
    ATH_MSG_INFO("Requesting cut value outside of configured eta range: clamping eta = "
                 << std::abs(truth.eta()) << " to eta= " << absEta);
  } else
    absEta = std::clamp(absEta, m_etaBins.value().front(), m_etaBins.value().back());
  const auto pVal =  std::lower_bound(m_etaBins.value().begin(), m_etaBins.value().end(), absEta);
  const int bin = std::distance(m_etaBins.value().begin(), pVal) - 1;
  ATH_MSG_DEBUG("Checking (abs(eta)/bin) = (" << absEta << "," << bin << ")");
  return bin;
}

getNewStreamNameFcn()

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

protectedvirtualinherited

Definition at line 2029 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;
}

getTruthParticles()

const std::vector< const xAOD::TruthParticle * > InDetPhysValMonitoringTool::getTruthParticles ( const EventContext & ctx ) const

private

Definition at line 771 of file InDetPhysValMonitoringTool.cxx.

                                                                           {
 
  std::vector<const xAOD::TruthParticle*> tempVec {};
 
  if (m_pileupSwitch == "All") {
    if (m_truthParticleName.key().empty()) {
      return tempVec;
    }
    SG::ReadHandle<xAOD::TruthParticleContainer> truthParticleContainer( m_truthParticleName, ctx);
    if (not truthParticleContainer.isValid()) {
      return tempVec;
    }
    tempVec.insert(tempVec.begin(), truthParticleContainer->begin(), truthParticleContainer->end());
  } else {
    if (m_pileupSwitch == "HardScatter") {
      // get truthevent container to separate out pileup and hardscatter truth particles
      if (not m_truthEventName.key().empty()) {
    SG::ReadHandle<xAOD::TruthEventContainer> truthEventContainer( m_truthEventName, ctx);
    const xAOD::TruthEvent* event = (truthEventContainer.isValid()) ? truthEventContainer->at(0) : nullptr;
    if (not event) {
      return tempVec;
    }
    const auto& links = event->truthParticleLinks();
    tempVec.reserve(event->nTruthParticles());
    for (const auto& link : links) {
      if (link.isValid()){
        tempVec.push_back(*link);
      }
    }
      }
    } else if (m_pileupSwitch == "PileUp") {
      if (not m_truthPileUpEventName.key().empty()) {
    ATH_MSG_VERBOSE("getting TruthPileupEvents container");
    // get truth particles from all pileup events
    SG::ReadHandle<xAOD::TruthPileupEventContainer> truthPileupEventContainer(m_truthPileUpEventName, ctx);
    if (truthPileupEventContainer.isValid()) {
      const unsigned int nPileup = truthPileupEventContainer->size();
      tempVec.reserve(nPileup * 200); // quick initial guess, will still save some time
      for (unsigned int i(0); i != nPileup; ++i) {
        const auto *eventPileup = truthPileupEventContainer->at(i);
        // get truth particles from each pileup event
        int ntruth = eventPileup->nTruthParticles();
        ATH_MSG_VERBOSE("Adding " << ntruth << " truth particles from TruthPileupEvents container");
        const auto& links = eventPileup->truthParticleLinks();
        for (const auto& link : links) {
          if (link.isValid()){
        tempVec.push_back(*link);
          }
        }
      }
    } else {
      ATH_MSG_ERROR("no entries in TruthPileupEvents container!");
    }
      }
    } else {
      ATH_MSG_ERROR("bad value for PileUpSwitch");
    }
  }
  return tempVec;
}

getTruthVertices()

std::pair< std::vector< const xAOD::TruthVertex * >, std::vector< const xAOD::TruthVertex * > > InDetPhysValMonitoringTool::getTruthVertices ( const EventContext & ctx ) const

private

Definition at line 833 of file InDetPhysValMonitoringTool.cxx.

                                                                          {
 
  std::vector<const xAOD::TruthVertex*> truthHSVertices = {};
  truthHSVertices.reserve(5);
  std::vector<const xAOD::TruthVertex*> truthPUVertices = {};
  truthPUVertices.reserve(100);
  const xAOD::TruthVertex* truthVtx = nullptr;
 
  bool doHS = false;
  bool doPU = false;
  if (m_pileupSwitch == "All") {
    doHS = true;
    doPU = true;
  }
  else if (m_pileupSwitch == "HardScatter") {
    doHS = true;
  }
  else if (m_pileupSwitch == "PileUp") {
    doPU = true;
  }
  else {
    ATH_MSG_ERROR("Bad value for PileUpSwitch: " << m_pileupSwitch);
  }
 
  if (doHS) {
    if (not m_truthEventName.key().empty()) {
      ATH_MSG_VERBOSE("Getting HS TruthEvents container.");
      SG::ReadHandle<xAOD::TruthEventContainer> truthEventContainer(m_truthEventName, ctx);
      if (truthEventContainer.isValid()) {
        for (const auto *const evt : *truthEventContainer) {
          truthVtx = evt->signalProcessVertex();
          if (truthVtx) {
            truthHSVertices.push_back(truthVtx);
          }
        }
      }
      else {
        ATH_MSG_ERROR("No entries in TruthEvents container!");
      }
    }
  }
 
  if (doPU) {
    if (not m_truthPileUpEventName.key().empty()) {
      ATH_MSG_VERBOSE("Getting PU TruthEvents container.");
      SG::ReadHandle<xAOD::TruthPileupEventContainer> truthPileupEventContainer(m_truthPileUpEventName, ctx);
      if (truthPileupEventContainer.isValid()) {
        for (const auto *const evt : *truthPileupEventContainer) {
          // Get the PU vertex
          // In all cases tested i_vtx=2 for PU
          // but better to keep something generic
          truthVtx = nullptr;
          size_t i_vtx = 0; size_t n_vtx = evt->nTruthVertices();
          while(!truthVtx && i_vtx<n_vtx){
            truthVtx = evt->truthVertex(i_vtx);
            i_vtx++;
          }
 
          if (truthVtx) {
            truthPUVertices.push_back(truthVtx);
          }
        }
      }
      else {
        ATH_MSG_DEBUG("No entries in TruthPileupEvents container");
      }
    }
  }
 
  return {std::move(truthHSVertices), std::move(truthPUVertices)};
}

getUnbiasedTrackParameters()

const Trk::TrackParameters * InDetPhysValMonitoringTool::getUnbiasedTrackParameters ( const Trk::TrackParameters * trkParameters, const Trk::MeasurementBase * measurement )

private

hasTruthFilled()

bool InDetPhysValMonitoringTool::hasTruthFilled ( const xAOD::TruthParticle & truth ) const

private

Definition at line 697 of file InDetPhysValMonitoringTool.cxx.

                                                                                    {
  if (!m_acc_hasTruthFilled.isAvailable(truth)) {
    ATH_MSG_DEBUG("Truth particle not yet filled in ntuple");
    return false;
  }
  return m_acc_hasTruthFilled(truth);
}

initialize()

StatusCode InDetPhysValMonitoringTool::initialize ( )

virtual

Reimplemented from ManagedMonitorToolBase.

Definition at line 115 of file InDetPhysValMonitoringTool.cxx.

                                       {
  ATH_CHECK(ManagedMonitorToolBase::initialize());
  // Get the track selector tool only if m_useTrackSelection is true;
  // first check for consistency i.e. that there is a trackSelectionTool if you ask
  // for trackSelection
  ATH_CHECK(m_trackSelectionTool.retrieve(EnableTool {m_useTrackSelection} ));
  ATH_CHECK(m_truthSelectionTool.retrieve(EnableTool {not m_truthParticleName.key().empty()} ));
  ATH_CHECK(m_vtxValidTool.retrieve(EnableTool {m_useVertexTruthMatchTool}));
  ATH_CHECK(m_trackTruthOriginTool.retrieve( EnableTool {m_doTruthOriginPlots} ));
 
  ATH_CHECK(m_hardScatterSelectionTool.retrieve(EnableTool
                        {not m_vertexContainerName.key().empty() &&
                            not m_hardScatterSelectionTool.empty()}));
 
  ATH_CHECK(m_grlTool.retrieve(EnableTool{m_useGRL}));
 
  ATH_MSG_DEBUG("m_useVertexTruthMatchTool ====== " <<m_useVertexTruthMatchTool);
  if (m_truthSelectionTool.get() ) {
    m_truthCutFlow = CutFlow(m_truthSelectionTool->nCuts());
  }
 
  m_monPlots = std::make_unique<InDetRttPlots>
    (nullptr, static_cast<std::string>(m_dirName) + static_cast<std::string>(m_folder),
     getFilledPlotConfig()); // m_detailLevel := DEBUG, enable expert histograms
 
  ATH_CHECK( m_trkParticleName.initialize() );
  ATH_CHECK( m_truthParticleName.initialize( (m_pileupSwitch == "HardScatter" or m_pileupSwitch == "All") and not m_truthParticleName.key().empty() ) );
  if (not m_truthParticleName.key().empty()) {
     // create decor handle keys for truth particle decorations which are needed by CachedGetAssocTruth
     // The existence of the handles is good enough to ensure that data dependencies are propagated
     // and that the decorations exist when this tool is being called. Albeit not very elegant
     // there is no need to create decor handles for the keys and use those instead of static
     // accessors. To keep changes minimal the original static accessors are not replaced.
     std::vector<std::string> trk_decorations;
     IDPVM::CachedGetAssocTruth::neededTrackParticleDecorations(trk_decorations);
     IDPVM::addReadDecoratorHandleKeys(*this,
                                       m_trkParticleName,
                                       "" /* no configurable prefix*/,
                                       trk_decorations,
                                       m_linkTrkDecor);
  }
  ATH_CHECK( m_vertexContainerName.initialize( not m_vertexContainerName.empty() ) );
  ATH_CHECK( m_truthVertexContainerName.initialize( not m_truthVertexContainerName.key().empty() ) );
  ATH_CHECK( m_eventInfoContainerName.initialize() );
 
  ATH_CHECK( m_truthEventName.initialize( (m_pileupSwitch == "HardScatter" or m_pileupSwitch == "All") and not m_truthEventName.key().empty() ) );
  ATH_CHECK( m_truthPileUpEventName.initialize( (m_pileupSwitch == "PileUp" or m_pileupSwitch == "All") and not m_truthPileUpEventName.key().empty() ) );
  ATH_CHECK( m_jetContainerName.initialize( m_doTrackInJetPlots and not m_jetContainerName.key().empty()) );  
 
  std::vector<std::string> required_float_track_decorations {"d0","hitResiduals_residualLocX","d0err"};
  std::vector<std::string> required_int_track_decorations {};
  std::vector<std::string> required_float_truth_decorations {"d0"};
  std::vector<std::string> required_int_truth_decorations {};
  std::vector<std::string> required_int_jet_decorations {"HadronConeExclTruthLabelID"};
  // The CSV file is for storing event data  related to track overlay ML training purposes.
  if (!m_setCSVName.empty()) {
      m_datfile.open(m_setCSVName);
      ATH_MSG_INFO("Accessing csv file with name " <<m_setCSVName<< "...");
      m_datfile <<"EvtNumber,PdgID,Px,Py,Pz,E,Pt,Eta,Phi,Mass,numPU,numvtx,MatchProb"<<std::endl;
  }
  std::string empty_prefix;
  IDPVM::addReadDecoratorHandleKeys(*this, m_trkParticleName, empty_prefix, required_float_track_decorations, m_floatTrkDecor);
  IDPVM::addReadDecoratorHandleKeys(*this, m_trkParticleName, empty_prefix, required_int_truth_decorations,   m_intTrkDecor);
  if (!m_truthParticleName.key().empty()) {
    IDPVM::addReadDecoratorHandleKeys(*this, m_truthParticleName, empty_prefix, required_float_truth_decorations, m_floatTruthDecor);
    IDPVM::addReadDecoratorHandleKeys(*this, m_truthParticleName, empty_prefix, required_int_truth_decorations,   m_intTruthDecor);
  }
  if (m_doTrackInJetPlots && m_doBjetPlots){
    IDPVM::addReadDecoratorHandleKeys(*this, m_jetContainerName, empty_prefix, required_int_jet_decorations, m_intJetDecor);
  }
 
  ATH_CHECK(m_weight_pileup_key.initialize(m_doPRW));
 
  m_usingSpecialPileupSwitch = (m_pileupSwitch != "All");
  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()

const InterfaceID & IMonitorToolBase::interfaceID ( )

inlinestaticinherited

Definition at line 30 of file IMonitorToolBase.h.

{ return IID_IMonitorToolBase; }

intervalEnumToString()

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

staticinherited

Converts a Interval_t to a string of the same name.

Definition at line 452 of file ManagedMonitorToolBase.cxx.

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

isSelectedByPileupSwitch()

bool InDetPhysValMonitoringTool::isSelectedByPileupSwitch ( const xAOD::TruthParticle & truth ) const

private

Definition at line 705 of file InDetPhysValMonitoringTool.cxx.

                                                                                              {
  if (!m_acc_selectedByPileupSwitch.isAvailable(truth)) {
      ATH_MSG_DEBUG("Selected by pileup switch decoration requested from a truth particle but not available");
      return false;
  }
  return m_acc_selectedByPileupSwitch(truth);
}

lbAverageInteractionsPerCrossing()

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

virtualinherited

Average mu, i.e.

<mu>

Definition at line 1583 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
        return lumi->lbAverageInteractionsPerCrossing();
    } else {
        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 ) const

virtualinherited

Average luminosity livefraction.

Definition at line 1648 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_DEBUG("Warning: lbAverageLivefraction() - luminosity not availble (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

lbAverageLuminosity()

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

virtualinherited

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

Definition at line 1617 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        SG::ReadCondHandle<LuminosityCondData> lumi (m_lumiDataKey, ctx);
        return lumi->lbAverageLuminosity();
    } else {
        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 ) const

virtualinherited

Luminosity block time (in seconds).

Definition at line 1699 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_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 ) const

virtualinherited

Instantaneous number of interactions, i.e.

mu

Definition at line 1598 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_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 ) const

virtualinherited

Instantaneous luminosity.

Definition at line 1632 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_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 ) const

virtualinherited

Average Integrated Luminosity Live Fraction.

Definition at line 1684 of file ManagedMonitorToolBase.cxx.

{
    if (!m_lumiDataKey.empty()) {
        return (lbAverageLuminosity(ctx)*lbDuration(ctx))*lbAverageLivefraction(ctx);
    } else{
        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 ) const

virtualinherited

Livefraction per bunch crossing ID.

Definition at line 1666 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_DEBUG("Warning: livefractionPerBCID() - luminosity retrieved available (i.e. EnableLumi = False)");
        return -1.0;
    }
    // not reached
}

markSelectedByPileupSwitch()

void InDetPhysValMonitoringTool::markSelectedByPileupSwitch ( const std::vector< const xAOD::TruthParticle * > & truthParticles ) const

private

Definition at line 713 of file InDetPhysValMonitoringTool.cxx.

                                                                                                                           {
  for (const auto& thisTruth: truthParticles) {
    m_dec_selectedByPileupSwitch(*thisTruth) = true;
  }
}

msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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

{ return m_newEventsBlock; }

newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 716 of file ManagedMonitorToolBase.h.

{ return m_newHigStatInterval; }

newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const

inlineprotectedinherited

Definition at line 717 of file ManagedMonitorToolBase.h.

{ return m_newLowStat; }

newLowStatIntervalFlag()

bool ManagedMonitorToolBase::newLowStatIntervalFlag ( ) const

inlineprotectedinherited

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

Definition at line 714 of file ManagedMonitorToolBase.h.

{ return m_newLowStatInterval; }

newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 718 of file ManagedMonitorToolBase.h.

{ return m_newLumiBlock; }

newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 715 of file ManagedMonitorToolBase.h.

{ return m_newMedStatInterval; }

newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const

inlineprotectedinherited

Definition at line 719 of file ManagedMonitorToolBase.h.

{ return m_newRun; }

outputHandles()

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

overridevirtualinherited

Return this algorithm's output handles.

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

parseList()

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

protectedinherited

Definition at line 1985 of file ManagedMonitorToolBase.cxx.

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

passJetCuts()

bool InDetPhysValMonitoringTool::passJetCuts ( const xAOD::Jet & jet ) const

private

Definition at line 1065 of file InDetPhysValMonitoringTool.cxx.

                                                                {
  const float jetPt = jet.pt();
  const float jetEta = std::abs(jet.eta());
  
  if (jetEta < m_jetAbsEtaMin) return false;
  if (jetEta > m_jetAbsEtaMax) return false;
  if (jetPt < m_jetPtMin) return false;
  if (jetPt > m_jetPtMax) return false;
  return true;
}

preSelector()

bool ManagedMonitorToolBase::preSelector ( )

virtualinherited

Implements IMonitorToolBase.

Definition at line 1571 of file ManagedMonitorToolBase.cxx.

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

procHistograms()

StatusCode InDetPhysValMonitoringTool::procHistograms ( )

virtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 746 of file InDetPhysValMonitoringTool.cxx.

                                           {
  ATH_MSG_INFO("Finalising hists " << name() << "...");
  //TODO: ADD Printouts for Truth??
  if (m_useTrackSelection) {
    ATH_MSG_INFO("");
    ATH_MSG_INFO("Now Cutflow for track cuts:");
    ATH_MSG_INFO("");
    for (int i = 0; i < (int) m_trackCutflow.size(); ++i) {
      ATH_MSG_INFO("number after " << m_trackCutflowNames[i] << ": " << m_trackCutflow[i]);
    }
  }
 
  ATH_MSG_INFO("");
  ATH_MSG_INFO("Cutflow for truth tracks:");
  if (m_truthSelectionTool.get()) {
    ATH_MSG_INFO("Truth selection report: " << m_truthCutFlow.report( m_truthSelectionTool->names()) );
  }
  if (endOfRunFlag()) {
    m_monPlots->finalize();
  }
  ATH_MSG_INFO("Successfully finalized hists");
  return StatusCode::SUCCESS;
}

regEfficiency()

StatusCode ManagedMonitorToolBase::regEfficiency ( TEfficiency * e, const MonGroup & group )

virtualinherited

Registers a TEfficiency to be included in the output stream using logical parameters that describe the plot.

Definition at line 1337 of file ManagedMonitorToolBase.cxx.

                                                                                        {
    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 1391 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 );
   }
 
   // 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 1381 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 1247 of file ManagedMonitorToolBase.cxx.

{
  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 1238 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 844 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;
      i = m_metadataMap.emplace( mdStreamName, new OutputMetadata(metadata) ).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 1038 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 967 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 870 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 1098 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 1446 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 1436 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();
  }

runStat()

StatusCode ManagedMonitorToolBase::runStat ( )

virtualinherited

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

Implements IMonitorToolBase.

Definition at line 1553 of file ManagedMonitorToolBase.cxx.

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

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

streamNameFunction()

ManagedMonitorToolBase::StreamNameFcn * ManagedMonitorToolBase::streamNameFunction ( )

virtualinherited

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

Definition at line 437 of file ManagedMonitorToolBase.cxx.

{
   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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

THistSvc_deReg_fixTGraph()

StatusCode ManagedMonitorToolBase::THistSvc_deReg_fixTGraph ( TFile * file, TGraph * theGraph, std::string & directoryName )

protectedinherited

Fixes THistSvc->deReg(obj) when obj is TGraph instance.

Read more in source file about this bug.

Definition at line 935 of file ManagedMonitorToolBase.cxx.

{
    // 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 1966 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 2004 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] = std::move(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 1491 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

ATLAS_THREAD_SAFE

CutFlow m_truthCutFlow InDetPhysValMonitoringTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 220 of file InDetPhysValMonitoringTool.h.

m_acc_hasTruthFilled

SG::AuxElement::Accessor<bool> InDetPhysValMonitoringTool::m_acc_hasTruthFilled {"hasTruthFilled"}

private

Definition at line 106 of file InDetPhysValMonitoringTool.h.

{"hasTruthFilled"};

m_acc_selectedByPileupSwitch

SG::AuxElement::Accessor<bool> InDetPhysValMonitoringTool::m_acc_selectedByPileupSwitch {"selectedByPileupSwitch"}

private

Definition at line 110 of file InDetPhysValMonitoringTool.h.

{"selectedByPileupSwitch"};

m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial

privateinherited

Definition at line 800 of file ManagedMonitorToolBase.h.

m_d

Imp* ManagedMonitorToolBase::m_d

privateinherited

Definition at line 807 of file ManagedMonitorToolBase.h.

m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType

protectedinherited

Definition at line 745 of file ManagedMonitorToolBase.h.

m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr

protectedinherited

Definition at line 741 of file ManagedMonitorToolBase.h.

m_datfile

std::ofstream InDetPhysValMonitoringTool::m_datfile

private

Definition at line 223 of file InDetPhysValMonitoringTool.h.

m_dec_hasTruthFilled

SG::AuxElement::Decorator<bool> InDetPhysValMonitoringTool::m_dec_hasTruthFilled {"hasTruthFilled"}

private

Definition at line 107 of file InDetPhysValMonitoringTool.h.

{"hasTruthFilled"}; 

m_dec_passedTrackSelection

SG::AuxElement::Decorator<bool> InDetPhysValMonitoringTool::m_dec_passedTrackSelection {"passedTrackSelection"}

private

Definition at line 109 of file InDetPhysValMonitoringTool.h.

{"passedTrackSelection"};   

m_dec_passedTruthSelection

SG::AuxElement::Decorator<bool> InDetPhysValMonitoringTool::m_dec_passedTruthSelection {"passedTruthSelection"}

private

Definition at line 108 of file InDetPhysValMonitoringTool.h.

{"passedTruthSelection"};   

m_dec_selectedByPileupSwitch

SG::AuxElement::Decorator<bool> InDetPhysValMonitoringTool::m_dec_selectedByPileupSwitch {"selectedByPileupSwitch"}

private

Definition at line 111 of file InDetPhysValMonitoringTool.h.

{"selectedByPileupSwitch"};

m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration

privateinherited

Definition at line 802 of file ManagedMonitorToolBase.h.

m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel

protectedinherited

Definition at line 743 of file ManagedMonitorToolBase.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_dirName

StringProperty InDetPhysValMonitoringTool::m_dirName {this, "DirName", "SquirrelPlots/", "Top level directory to write histograms into"}

private

Definition at line 191 of file InDetPhysValMonitoringTool.h.

{this, "DirName", "SquirrelPlots/", "Top level directory to write histograms into"}; 

m_doBjetPlots

BooleanProperty InDetPhysValMonitoringTool::m_doBjetPlots {this, "FillTrackInBJetPlots", false, "Fill plots for tracks in truth-b-tagged jets"}

private

Definition at line 180 of file InDetPhysValMonitoringTool.h.

{this, "FillTrackInBJetPlots", false, "Fill plots for tracks in truth-b-tagged jets"}; 

m_doDuplicatePlots

BooleanProperty InDetPhysValMonitoringTool::m_doDuplicatePlots {this, "doDuplicatePlots", false, "Fill duplicate=multi-track per particle plots"}

private

Definition at line 176 of file InDetPhysValMonitoringTool.h.

{this, "doDuplicatePlots", false, "Fill duplicate=multi-track per particle plots"};

m_doHitLevelPlots

BooleanProperty InDetPhysValMonitoringTool::m_doHitLevelPlots {this, "doHitLevelPlots", false, "Fill hit efficiency and residual plots"}

private

Definition at line 179 of file InDetPhysValMonitoringTool.h.

{this, "doHitLevelPlots", false, "Fill hit efficiency and residual plots"}; 

m_doIDTIDEPlots

BooleanProperty InDetPhysValMonitoringTool::m_doIDTIDEPlots {this, "doIDTIDEPlots", false, "do ID TIDE derivation plots"}

private

Definition at line 186 of file InDetPhysValMonitoringTool.h.

{this, "doIDTIDEPlots", false, "do ID TIDE derivation plots"};

m_doPerAuthorPlots

BooleanProperty InDetPhysValMonitoringTool::m_doPerAuthorPlots {this, "doPerAuthorPlots", false, "do plots split by track author"}

private

Definition at line 177 of file InDetPhysValMonitoringTool.h.

{this, "doPerAuthorPlots", false, "do plots split by track author"};

m_doPRW

BooleanProperty InDetPhysValMonitoringTool::m_doPRW {this,"doPRW",false,"apply pileup reweight"}

private

Definition at line 188 of file InDetPhysValMonitoringTool.h.

{this,"doPRW",false,"apply pileup reweight"};

m_doTrackInJetPlots

BooleanProperty InDetPhysValMonitoringTool::m_doTrackInJetPlots {this, "FillTrackInJetPlots", true, "Fill plots for tracks in jets"}

private

Definition at line 178 of file InDetPhysValMonitoringTool.h.

{this, "FillTrackInJetPlots", true, "Fill plots for tracks in jets"}; 

m_doTRTExtensionPlots

BooleanProperty InDetPhysValMonitoringTool::m_doTRTExtensionPlots {this, "doTRTExtensionPlots", true, "do TRT extension plots"}

private

Definition at line 184 of file InDetPhysValMonitoringTool.h.

{this, "doTRTExtensionPlots", true, "do TRT extension plots"};

m_doTruthOriginPlots

BooleanProperty InDetPhysValMonitoringTool::m_doTruthOriginPlots {this, "doTruthOriginPlots", false, "do plots split by track truth origin"}

private

Definition at line 175 of file InDetPhysValMonitoringTool.h.

{this, "doTruthOriginPlots", false, "do plots split by track truth origin"};

m_DQFilterTools

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

protectedinherited

Definition at line 756 of file ManagedMonitorToolBase.h.

{this,"FilterTools",{}};

m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock

privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat

privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock

privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun

privateinherited

Definition at line 730 of file ManagedMonitorToolBase.h.

m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment

protectedinherited

Definition at line 746 of file ManagedMonitorToolBase.h.

m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr

protectedinherited

Definition at line 742 of file ManagedMonitorToolBase.h.

m_etaBins

DoubleArrayProperty InDetPhysValMonitoringTool::m_etaBins {this, "EtaBins", {}}

private

Definition at line 197 of file InDetPhysValMonitoringTool.h.

{this, "EtaBins", {}};

m_eventInfoContainerName

SG::ReadHandleKey<xAOD::EventInfo> InDetPhysValMonitoringTool::m_eventInfoContainerName {this,"EventInfoContainerName", "EventInfo", ""}

private

EventInfo container name.

Definition at line 149 of file InDetPhysValMonitoringTool.h.

{this,"EventInfoContainerName", "EventInfo", ""};

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

m_fillTechnicalEfficiency

BooleanProperty InDetPhysValMonitoringTool::m_fillTechnicalEfficiency {this, "fillTechnicalEfficiency", false, "Fill the technical efficiency plot. Requires additional sihit information in input file"}

private

Definition at line 187 of file InDetPhysValMonitoringTool.h.

{this, "fillTechnicalEfficiency", false, "Fill the technical efficiency plot. Requires additional sihit information in input file"};

m_fillTruthToRecoNtuple

BooleanProperty InDetPhysValMonitoringTool::m_fillTruthToRecoNtuple {this, "FillTruthToRecoNtuple", false, "Fill an ntuple with truth and matching reco info for more detailed stuidies"}

private

Definition at line 181 of file InDetPhysValMonitoringTool.h.

{this, "FillTruthToRecoNtuple", false, "Fill an ntuple with truth and matching reco info for more detailed stuidies"}; 

m_floatTrkDecor

std::vector<SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> > InDetPhysValMonitoringTool::m_floatTrkDecor

private

Definition at line 163 of file InDetPhysValMonitoringTool.h.

m_floatTruthDecor

std::vector<SG::ReadDecorHandleKey<xAOD::TruthParticleContainer> > InDetPhysValMonitoringTool::m_floatTruthDecor

private

Definition at line 165 of file InDetPhysValMonitoringTool.h.

m_folder

StringProperty InDetPhysValMonitoringTool::m_folder {this, "SubFolder", "", "Subfolder to add for plots if desired. Used when working with multiple IDPVM tool instances."}

private

Definition at line 192 of file InDetPhysValMonitoringTool.h.

{this, "SubFolder", "", "Subfolder to add for plots if desired. Used when working with multiple IDPVM tool instances."}; 

m_grlTool

ToolHandle<IGoodRunsListSelectionTool> InDetPhysValMonitoringTool::m_grlTool {this, "GoodRunsListSelectionTool", "GoodRunsListSelectionTool/GoodRunsListSelectionTool", "GRL selection tool"}

private

Definition at line 215 of file InDetPhysValMonitoringTool.h.

{this, "GoodRunsListSelectionTool", "GoodRunsListSelectionTool/GoodRunsListSelectionTool", "GRL selection tool"};

m_hardScatterSelectionTool

ToolHandle<InDet::IInDetHardScatterSelectionTool> InDetPhysValMonitoringTool::m_hardScatterSelectionTool

private

Initial value:

{this, "hardScatterSelectionTool", "",
       "tool to select the hard scatter reco vertex"}

Definition at line 212 of file InDetPhysValMonitoringTool.h.

      {this, "hardScatterSelectionTool", "",
       "tool to select the hard scatter reco vertex"};

m_hasHGTDReco

BooleanProperty InDetPhysValMonitoringTool::m_hasHGTDReco {this, "hasHGTDReco", false, "Whether config is set for HGTD reco, to enable/disable some plots"}

private

Definition at line 206 of file InDetPhysValMonitoringTool.h.

{this, "hasHGTDReco", false, "Whether config is set for HGTD reco, to enable/disable some plots"};

m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock

protectedinherited

Definition at line 773 of file ManagedMonitorToolBase.h.

m_highProb

FloatProperty InDetPhysValMonitoringTool::m_highProb {this,"HighProb",0.8,"Truth match prob. cutoff - currently unused"}

private

Definition at line 196 of file InDetPhysValMonitoringTool.h.

{this,"HighProb",0.8,"Truth match prob. cutoff - currently unused"}; 

m_intJetDecor

std::vector<SG::ReadDecorHandleKey<xAOD::JetContainer> > InDetPhysValMonitoringTool::m_intJetDecor

private

Definition at line 167 of file InDetPhysValMonitoringTool.h.

m_intTrkDecor

std::vector<SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> > InDetPhysValMonitoringTool::m_intTrkDecor

private

Definition at line 164 of file InDetPhysValMonitoringTool.h.

m_intTruthDecor

std::vector<SG::ReadDecorHandleKey<xAOD::TruthParticleContainer> > InDetPhysValMonitoringTool::m_intTruthDecor

private

Definition at line 166 of file InDetPhysValMonitoringTool.h.

m_isITk

BooleanProperty InDetPhysValMonitoringTool::m_isITk {this, "isITk", false, "Whether config is set for ITk, to enable/disable some plots"}

private

Definition at line 205 of file InDetPhysValMonitoringTool.h.

{this, "isITk", false, "Whether config is set for ITk, to enable/disable some plots"};

m_jetAbsEtaMax

FloatProperty InDetPhysValMonitoringTool::m_jetAbsEtaMax {this, "JetAbsEtaMax", 2.5f, "Maximum Eta value for jet selection"}

private

Definition at line 201 of file InDetPhysValMonitoringTool.h.

{this, "JetAbsEtaMax", 2.5f, "Maximum Eta value for jet selection"};

m_jetAbsEtaMin

FloatProperty InDetPhysValMonitoringTool::m_jetAbsEtaMin {this, "JetAbsEtaMin", 0.f, "Minimum Eta value for jet selection"}

private

Definition at line 200 of file InDetPhysValMonitoringTool.h.

{this, "JetAbsEtaMin", 0.f, "Minimum Eta value for jet selection"};

m_jetContainerName

SG::ReadHandleKey<xAOD::JetContainer> InDetPhysValMonitoringTool::m_jetContainerName {this, "JetContainerName", "AntiKt4LCTopoJets" , ""}

private

Definition at line 158 of file InDetPhysValMonitoringTool.h.

{this, "JetContainerName", "AntiKt4LCTopoJets" , ""};

m_jetPtMax

FloatProperty InDetPhysValMonitoringTool::m_jetPtMax {this, "JetPtMax", 5000.0f, "Maximum Jet pT for jet selection in GeV"}

private

Definition at line 203 of file InDetPhysValMonitoringTool.h.

{this, "JetPtMax", 5000.0f, "Maximum Jet pT for jet selection in GeV"};

m_jetPtMin

FloatProperty InDetPhysValMonitoringTool::m_jetPtMin {this, "JetPtMin", 100.0f, "Minimum Jet pT for jet selection in GeV"}

private

Definition at line 202 of file InDetPhysValMonitoringTool.h.

{this, "JetPtMin", 100.0f, "Minimum Jet pT for jet selection in GeV"};

m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval

protectedinherited

Definition at line 768 of file ManagedMonitorToolBase.h.

m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval

protectedinherited

Definition at line 768 of file ManagedMonitorToolBase.h.

m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock

protectedinherited

Definition at line 766 of file ManagedMonitorToolBase.h.

m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval

protectedinherited

Definition at line 768 of file ManagedMonitorToolBase.h.

m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun

protectedinherited

Definition at line 767 of file ManagedMonitorToolBase.h.

m_lbDurationDataKey

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

privateinherited

Definition at line 795 of file ManagedMonitorToolBase.h.

{this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"};

m_linkTrkDecor

std::vector<SG::ReadDecorHandleKey<xAOD::TrackParticleContainer> > InDetPhysValMonitoringTool::m_linkTrkDecor

private

Definition at line 168 of file InDetPhysValMonitoringTool.h.

m_lowProb

FloatProperty InDetPhysValMonitoringTool::m_lowProb {this,"LowProb",0.5,"Truth match prob. cutoff for efficiency (lower bound) and fake (upper bound) classification."}

private

Definition at line 195 of file InDetPhysValMonitoringTool.h.

{this,"LowProb",0.5,"Truth match prob. cutoff for efficiency (lower bound) and fake (upper bound) classification."}; 

m_lumiDataKey

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

privateinherited

Definition at line 793 of file ManagedMonitorToolBase.h.

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

m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager

protectedinherited

Definition at line 736 of file ManagedMonitorToolBase.h.

m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp

protectedinherited

Definition at line 738 of file ManagedMonitorToolBase.h.

m_maxTrkJetDR

FloatProperty InDetPhysValMonitoringTool::m_maxTrkJetDR {this,"maxTrkJetDR",0.4,"the maximum dR to jets to allow for track-in-jet plots"}

private

Definition at line 190 of file InDetPhysValMonitoringTool.h.

{this,"maxTrkJetDR",0.4,"the maximum dR to jets to allow for track-in-jet plots"}; 

m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap

protectedinherited

Definition at line 734 of file ManagedMonitorToolBase.h.

m_minHits

IntegerArrayProperty InDetPhysValMonitoringTool::m_minHits {this, "MinNumberClusters", {}}

private

Definition at line 198 of file InDetPhysValMonitoringTool.h.

{this, "MinNumberClusters", {}};

m_monPlots

std::unique_ptr< InDetRttPlots > InDetPhysValMonitoringTool::m_monPlots

private

histograms

Definition at line 171 of file InDetPhysValMonitoringTool.h.

m_mutex

std::mutex InDetPhysValMonitoringTool::m_mutex

mutableprivate

Definition at line 219 of file InDetPhysValMonitoringTool.h.

m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents

protectedinherited

Definition at line 770 of file ManagedMonitorToolBase.h.

m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger

protectedinherited

Definition at line 771 of file ManagedMonitorToolBase.h.

m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock

privateinherited

Definition at line 729 of file ManagedMonitorToolBase.h.

m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval

privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat

privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval

privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock

privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval

privateinherited

Definition at line 727 of file ManagedMonitorToolBase.h.

m_newRun

bool ManagedMonitorToolBase::m_newRun

privateinherited

Definition at line 728 of file ManagedMonitorToolBase.h.

m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks

protectedinherited

Definition at line 772 of file ManagedMonitorToolBase.h.

m_onlyFillMatched

BooleanProperty InDetPhysValMonitoringTool::m_onlyFillMatched {this, "onlyFillTruthMatched", false, "Only fill truth-to-reco (eff, reso, matched hit) plots"}

private

Definition at line 183 of file InDetPhysValMonitoringTool.h.

{this, "onlyFillTruthMatched", false, "Only fill truth-to-reco (eff, reso, matched hit) plots"};

m_path

std::string ManagedMonitorToolBase::m_path

protectedinherited

Definition at line 759 of file ManagedMonitorToolBase.h.

m_pileupSwitch

StringProperty InDetPhysValMonitoringTool::m_pileupSwitch {this, "PileupSwitch", "HardScatter", "Pileup truth strategy to use. May be \"All\", \"HardScatter\", or \"PileUp\""}

private

Definition at line 193 of file InDetPhysValMonitoringTool.h.

{this, "PileupSwitch", "HardScatter", "Pileup truth strategy to use. May be \"All\", \"HardScatter\", or \"PileUp\""}; 

m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp

protectedinherited

Definition at line 760 of file ManagedMonitorToolBase.h.

m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp

protectedinherited

Definition at line 758 of file ManagedMonitorToolBase.h.

m_prospectsMatched

std::vector<int> InDetPhysValMonitoringTool::m_prospectsMatched

private

Definition at line 221 of file InDetPhysValMonitoringTool.h.

m_setCSVName

StringProperty InDetPhysValMonitoringTool::m_setCSVName {this, "setCSVName", "", "convert AOD to a scv file"}

private

Definition at line 194 of file InDetPhysValMonitoringTool.h.

{this, "setCSVName", "", "convert AOD to a scv file"};

m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn

protectedinherited

Definition at line 748 of file ManagedMonitorToolBase.h.

m_supportedIntervalsForRebooking

std::set<Interval_t> ManagedMonitorToolBase::m_supportedIntervalsForRebooking

privateinherited

Definition at line 803 of file ManagedMonitorToolBase.h.

m_templateEfficiencies

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

protectedinherited

Definition at line 604 of file ManagedMonitorToolBase.h.

m_templateGraphs

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

protectedinherited

Definition at line 596 of file ManagedMonitorToolBase.h.

m_templateHistograms

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

protectedinherited

Definition at line 592 of file ManagedMonitorToolBase.h.

m_templateTrees

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

protectedinherited

Definition at line 600 of file ManagedMonitorToolBase.h.

m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc

protectedinherited

Definition at line 750 of file ManagedMonitorToolBase.h.

m_trackCutflow

std::vector<int> InDetPhysValMonitoringTool::m_trackCutflow

private

Definition at line 225 of file InDetPhysValMonitoringTool.h.

m_trackCutflowNames

std::vector<std::string> InDetPhysValMonitoringTool::m_trackCutflowNames

private

Definition at line 224 of file InDetPhysValMonitoringTool.h.

m_trackSelectionTool

ToolHandle<InDet::IInDetTrackSelectionTool> InDetPhysValMonitoringTool::m_trackSelectionTool {this, "TrackSelectionTool", "InDet::InDetTrackSelectionTool/TrackSelectionTool", "Track selection tool to use"}

private

Definition at line 208 of file InDetPhysValMonitoringTool.h.

{this, "TrackSelectionTool", "InDet::InDetTrackSelectionTool/TrackSelectionTool", "Track selection tool to use"};

m_trackTruthOriginTool

ToolHandle<InDet::IInDetTrackTruthOriginTool> InDetPhysValMonitoringTool::m_trackTruthOriginTool {this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool","truth track origin tool"}

private

Definition at line 211 of file InDetPhysValMonitoringTool.h.

{this, "trackTruthOriginTool", "InDet::InDetTrackTruthOriginTool","truth track origin tool"};

m_trigDecTool

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

protectedinherited

Definition at line 752 of file ManagedMonitorToolBase.h.

{this, "TrigDecisionTool",""};

m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp

protectedinherited

Definition at line 761 of file ManagedMonitorToolBase.h.

m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp

protectedinherited

Definition at line 762 of file ManagedMonitorToolBase.h.

m_trigLiveFractionDataKey

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

privateinherited

Definition at line 797 of file ManagedMonitorToolBase.h.

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

m_trigTranslator

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

protectedinherited

Definition at line 754 of file ManagedMonitorToolBase.h.

{this,"TriggerTranslatorTool",""};

m_trkParticleName

SG::ReadHandleKey<xAOD::TrackParticleContainer> InDetPhysValMonitoringTool::m_trkParticleName {this,"TrackParticleContainerName", "InDetTrackParticles"}

private

TrackParticle container's name.

Definition at line 133 of file InDetPhysValMonitoringTool.h.

{this,"TrackParticleContainerName", "InDetTrackParticles"};

m_truthCounter

int InDetPhysValMonitoringTool::m_truthCounter = 0

private

Definition at line 222 of file InDetPhysValMonitoringTool.h.

m_truthEventName

SG::ReadHandleKey<xAOD::TruthEventContainer> InDetPhysValMonitoringTool::m_truthEventName {this, "TruthEvents", "TruthEvents","Name of the truth events container probably either TruthEvent or TruthEvents"}

private

Definition at line 152 of file InDetPhysValMonitoringTool.h.

{this, "TruthEvents", "TruthEvents","Name of the truth events container probably either TruthEvent or TruthEvents"};

m_truthParticleName

SG::ReadHandleKey<xAOD::TruthParticleContainer> InDetPhysValMonitoringTool::m_truthParticleName {this, "TruthParticleContainerName", "TruthParticles", ""}

private

TruthParticle container's name.

Definition at line 137 of file InDetPhysValMonitoringTool.h.

{this, "TruthParticleContainerName",  "TruthParticles", ""};

m_truthPileUpEventName

SG::ReadHandleKey<xAOD::TruthPileupEventContainer> InDetPhysValMonitoringTool::m_truthPileUpEventName {this, "TruthPileupEvents", "TruthPileupEvents","Name of the truth pileup events container probably TruthPileupEvent(s)"}

private

Definition at line 155 of file InDetPhysValMonitoringTool.h.

{this, "TruthPileupEvents", "TruthPileupEvents","Name of the truth pileup events container probably TruthPileupEvent(s)"};

m_truthSelectionTool

ToolHandle<IAthSelectionTool> InDetPhysValMonitoringTool::m_truthSelectionTool {this, "TruthSelectionTool","AthTruthSelectionTool", "Truth selection tool (for efficiencies and resolutions)"}

private

Definition at line 210 of file InDetPhysValMonitoringTool.h.

{this, "TruthSelectionTool","AthTruthSelectionTool", "Truth selection tool (for efficiencies and resolutions)"};

m_truthVertexContainerName

SG::ReadHandleKey<xAOD::TruthVertexContainer> InDetPhysValMonitoringTool::m_truthVertexContainerName {this,"TruthVertexContainerName", "TruthVertices",""}

private

Truth vertex container's name.

Definition at line 145 of file InDetPhysValMonitoringTool.h.

{this,"TruthVertexContainerName",  "TruthVertices",""};

m_useGRL

BooleanProperty InDetPhysValMonitoringTool::m_useGRL {this, "useGRL", false, "Apply GRL selection or not when running on data"}

private

Definition at line 185 of file InDetPhysValMonitoringTool.h.

{this, "useGRL", false, "Apply GRL selection or not when running on data"};

m_useLumi

bool ManagedMonitorToolBase::m_useLumi

privateinherited

Definition at line 801 of file ManagedMonitorToolBase.h.

m_useTrackSelection

BooleanProperty InDetPhysValMonitoringTool::m_useTrackSelection {this, "useTrackSelection", false, "plot only tracks accepted by selection tool"}

private

Properties to fine-tune the tool behaviour.

Definition at line 174 of file InDetPhysValMonitoringTool.h.

{this, "useTrackSelection", false, "plot only tracks accepted by selection tool"};

m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger

protectedinherited

Definition at line 764 of file ManagedMonitorToolBase.h.

m_useVertexTruthMatchTool

BooleanProperty InDetPhysValMonitoringTool::m_useVertexTruthMatchTool {this, "useVertexTruthMatchTool", false, "Use the vertex truth matching tool"}

private

Definition at line 182 of file InDetPhysValMonitoringTool.h.

{this, "useVertexTruthMatchTool", false, "Use the vertex truth matching tool"}; 

m_usingSpecialPileupSwitch

bool InDetPhysValMonitoringTool::m_usingSpecialPileupSwitch {false}

private

Definition at line 227 of file InDetPhysValMonitoringTool.h.

{false};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexContainerName

SG::ReadHandleKey<xAOD::VertexContainer> InDetPhysValMonitoringTool::m_vertexContainerName {this,"VertexContainerName", "PrimaryVertices", ""}

private

Primary vertex container's name.

Definition at line 141 of file InDetPhysValMonitoringTool.h.

{this,"VertexContainerName", "PrimaryVertices", ""};

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_vTrigChainNames

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

protectedinherited

Definition at line 608 of file ManagedMonitorToolBase.h.

m_vTrigGroupNames

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

protectedinherited

Definition at line 608 of file ManagedMonitorToolBase.h.

m_vtxValidTool

ToolHandle<IInDetVertexTruthMatchTool> InDetPhysValMonitoringTool::m_vtxValidTool {this, "VertexTruthMatchTool", "InDetVertexTruthMatchTool/VtxTruthMatchTool", "Vertex truth matching tool to use"}

private

Definition at line 209 of file InDetPhysValMonitoringTool.h.

{this, "VertexTruthMatchTool", "InDetVertexTruthMatchTool/VtxTruthMatchTool", "Vertex truth matching tool to use"};

m_weight_pileup_key

SG::ReadDecorHandleKey<xAOD::EventInfo> InDetPhysValMonitoringTool::m_weight_pileup_key {this, "PileupWeight_NOSYS", m_eventInfoContainerName, "PileupWeight_NOSYS"}

private

Definition at line 217 of file InDetPhysValMonitoringTool.h.

{this, "PileupWeight_NOSYS", m_eventInfoContainerName, "PileupWeight_NOSYS"};

---

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

• InDetPhysValMonitoringTool.h
• InDetPhysValMonitoringTool.cxx