MissingEtDQA::PhysValMET Class Reference

#include <PhysValMET.h>

Inheritance diagram for MissingEtDQA::PhysValMET:

Collaboration diagram for MissingEtDQA::PhysValMET:

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

Public Member Functions
	PhysValMET (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters:
virtual	~PhysValMET ()
	Destructor:
virtual StatusCode	initialize ()
virtual StatusCode	bookHistograms ()
	An inheriting class should either override this function or bookHists().
virtual StatusCode	fillHistograms ()
	An inheriting class should either override this function or fillHists().
virtual StatusCode	procHistograms ()
	An inheriting class should either override this function or finalHists().
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 ()
	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=Gaudi::Hive::currentContext()) const
	Average mu, i.e.
virtual float	lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Instantaneous number of interactions, i.e.
virtual float	lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1)
virtual float	lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Instantaneous luminosity.
virtual double	lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Luminosity block time (in seconds)
virtual float	lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Average luminosity livefraction.
virtual float	livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Livefraction per bunch crossing ID.
virtual double	lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
	Average Integrated Luminosity Live Fraction.
	MMTB_DEPRECATED (newLowStatInterval)
	MMTB_DEPRECATED (newMedStatInterval)
	MMTB_DEPRECATED (newHigStatInterval)
	MMTB_DEPRECATED (newLowStat)
	MMTB_DEPRECATED (newLumiBlock)
	MMTB_DEPRECATED (newRun)
	MMTB_DEPRECATED (newEventsBlock)
	MMTB_DEPRECATED (endOfEventsBlock)
	MMTB_DEPRECATED (endOfLowStat)
	MMTB_DEPRECATED (endOfLumiBlock)
	MMTB_DEPRECATED (endOfRun)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

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

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

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

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

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
	PhysValMET ()
	Default constructor:
bool	Accept (const xAOD::Electron *el)
bool	Accept (const xAOD::Photon *ph)
bool	Accept (const xAOD::TauJet *tau)
bool	Accept (const xAOD::Muon *muon)
bool	Accept (const xAOD::Jet *jet, double JvtCut, ToolHandle< IJetUpdateJvt > *jvtTool)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
bool	m_doTruth
bool	m_inputIsDAOD
bool	m_doMETRefPlots
std::string	m_eleColl
std::string	m_gammaColl
std::string	m_tauColl
std::string	m_muonColl
std::string	m_mapname
std::string	m_corename
std::vector< std::string >	m_types
std::vector< std::string >	m_terms
std::map< std::string, std::string >	m_names
TH1D *	m_MET_Track = nullptr
TH1D *	m_MET_Track_x = nullptr
TH1D *	m_MET_Track_y = nullptr
TH1D *	m_MET_Track_phi = nullptr
TH1D *	m_MET_Track_sum = nullptr
TH1D *	m_MET_PVTrack_Nominal = nullptr
TH1D *	m_MET_PVTrack_Nominal_x = nullptr
TH1D *	m_MET_PVTrack_Nominal_y = nullptr
TH1D *	m_MET_PVTrack_Nominal_phi = nullptr
TH1D *	m_MET_PVTrack_Nominal_sum = nullptr
TH1D *	m_MET_PVTrack_Pileup = nullptr
TH1D *	m_MET_PVTrack_Pileup_x = nullptr
TH1D *	m_MET_PVTrack_Pileup_y = nullptr
TH1D *	m_MET_PVTrack_Pileup_phi = nullptr
TH1D *	m_MET_PVTrack_Pileup_sum = nullptr
TH1D *	m_MET_Calo = nullptr
TH1D *	m_MET_Calo_x = nullptr
TH1D *	m_MET_Calo_y = nullptr
TH1D *	m_MET_Calo_phi = nullptr
TH1D *	m_MET_Calo_sum = nullptr
std::map< std::string, std::vector< TH1D * > >	m_MET_Ref
std::map< std::string, std::vector< TH1D * > >	m_MET_Ref_x
std::map< std::string, std::vector< TH1D * > >	m_MET_Ref_y
std::map< std::string, std::vector< TH1D * > >	m_MET_Ref_phi
std::map< std::string, std::vector< TH1D * > >	m_MET_Ref_sum
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Ref
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Ref_x
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Ref_y
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Ref_phi
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Ref_sum
std::map< std::string, std::vector< TH1D * > >	m_MET_Cumu_Ref
std::map< std::string, std::vector< TH1D * > >	m_MET_Resolution_Ref
std::map< std::string, std::vector< TH1D * > >	m_MET_Significance_Ref
std::map< std::string, std::vector< TH1D * > >	m_MET_dPhi_Ref
std::map< std::string, std::vector< TH2D * > >	m_MET_CorrFinalTrk_Ref
std::map< std::string, std::vector< TH2D * > >	m_MET_CorrFinalClus_Ref
std::map< std::string, std::vector< TH1D * > >	m_MET_Reb
std::map< std::string, std::vector< TH1D * > >	m_MET_Reb_x
std::map< std::string, std::vector< TH1D * > >	m_MET_Reb_y
std::map< std::string, std::vector< TH1D * > >	m_MET_Reb_phi
std::map< std::string, std::vector< TH1D * > >	m_MET_Reb_sum
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Reb
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Reb_x
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Reb_y
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Reb_phi
std::map< std::string, std::vector< TH1D * > >	m_MET_Diff_Reb_sum
std::map< std::string, std::vector< TH1D * > >	m_MET_Cumu_Reb
std::map< std::string, std::vector< TH1D * > >	m_MET_Resolution_Reb
std::map< std::string, std::vector< TH1D * > >	m_MET_Significance_Reb
std::map< std::string, std::vector< TH1D * > >	m_MET_dPhi_Reb
std::map< std::string, std::vector< TH2D * > >	m_MET_CorrFinalTrk_Reb
std::map< std::string, std::vector< TH2D * > >	m_MET_CorrFinalClus_Reb
std::vector< std::string >	m_dir_met
ToolHandle< CP::IMuonSelectionTool >	m_muonSelTool {this, "MuonSelectionTool", "", "Muon selection tool"}
ToolHandle< IAsgElectronLikelihoodTool >	m_elecSelLHTool {this, "ElectronLHSelectionTool", "", "Electron likelihood selection tool"}
ToolHandle< IAsgPhotonIsEMSelector >	m_photonSelIsEMTool {this, "PhotonIsEMSelectionTool" , "", "Photon selection tool"}
ToolHandle< IJetUpdateJvt >	m_jvtToolEM {this, "JVTToolEMTopo", "", "JVT tool for EMTopo jets"}
ToolHandle< IJetUpdateJvt >	m_jvtToolPFlow {this, "JVTToolEMPFlow", "", "JVT tool forEMPFlow jets"}
ToolHandle< IMETMaker >	m_metmakerTopo {this, "METMakerTopo", "", "METMaker for EMTopo jets"}
ToolHandle< IMETMaker >	m_metmakerPFlow {this, "METMakerPFlow", "", "METMaker for EMPFlow jets"}
ToolHandle< TauAnalysisTools::ITauSelectionTool >	m_tauSelTool {this, "TauSelectionTool", "", "Tau selection tool"}
ToolHandle< IMETMaker > *	m_metmaker
bool	m_newLowStatInterval
bool	m_newMedStatInterval
bool	m_newHigStatInterval
bool	m_newLowStat
bool	m_newLumiBlock
bool	m_newRun
bool	m_newEventsBlock
bool	m_endOfEventsBlock
bool	m_endOfLowStat
bool	m_endOfLumiBlock
bool	m_endOfRun
SG::ReadCondHandleKey< LuminosityCondData >	m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
SG::ReadCondHandleKey< LBDurationCondData >	m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
SG::ReadCondHandleKey< TrigLiveFractionCondData >	m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData","SG Key of TrigLiveFractionCondData object"}
bool	m_bookHistogramsInitial
bool	m_useLumi
float	m_defaultLBDuration
std::set< Interval_t >	m_supportedIntervalsForRebooking
Imp *	m_d
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 44 of file PhysValMET.h.

Member Typedef Documentation

MDMap_t

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

protectedinherited

Definition at line 826 of file ManagedMonitorToolBase.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

Interval_t

enum ManagedMonitorToolBase::Interval_t

inherited

An enumeration describing how detailed a particular monitoring object is.

summary: used to summarize the state of the system

runstat: same as summary

shift: used to flag potential problems

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

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

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

Enumerator
file
eventsBlock
lumiBlock
lowStat
medStat
higStat
run
fill
all

Definition at line 113 of file ManagedMonitorToolBase.h.

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

MgmtAttr_t

enum ManagedMonitorToolBase::MgmtAttr_t

inherited

An enumeration describing how the class handles the histogram.

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

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

Enumerator
ATTRIB_MANAGED
ATTRIB_UNMANAGED
ATTRIB_X_VS_LB

Definition at line 130 of file ManagedMonitorToolBase.h.

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

Constructor & Destructor Documentation

PhysValMET() [1/2]

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

Constructor with parameters:

Definition at line 55 of file PhysValMET.cxx.

                                                    : 
    ManagedMonitorToolBase( type, name, parent ),
    m_metmaker(nullptr)
  {
    declareProperty( "InputElectrons", m_eleColl   = "Electrons"         );
    declareProperty( "InputPhotons",   m_gammaColl = "Photons"           );
    declareProperty( "InputTaus",      m_tauColl   = "TauJets"           );
    declareProperty( "InputMuons",     m_muonColl  = "Muons"             );
    declareProperty( "DoTruth", m_doTruth = false );
    declareProperty( "InputIsDAOD",    m_inputIsDAOD = false              );
    declareProperty( "DoMETRefPlots",  m_doMETRefPlots = false           );
    declareProperty( "METMapName",     m_mapname   = "METAssoc"          );
    declareProperty( "METCoreName",    m_corename  = "MET_Core"          );
  }

~PhysValMET()

MissingEtDQA::PhysValMET::~PhysValMET ( )

virtual

Destructor:

Definition at line 74 of file PhysValMET.cxx.

  {
    m_names.clear();
    m_types.clear();
    m_terms.clear();
    m_MET_Ref.clear();
    m_MET_Ref_x.clear();
    m_MET_Ref_y.clear();
    m_MET_Ref_phi.clear();
    m_MET_Ref_sum.clear();
    m_MET_Diff_Ref.clear();
    m_MET_Diff_Ref_x.clear();
    m_MET_Diff_Ref_y.clear();
    m_MET_Diff_Ref_phi.clear();
    m_MET_Diff_Ref_sum.clear();
    m_MET_Cumu_Ref.clear();
    m_MET_Resolution_Ref.clear();
    m_MET_Significance_Ref.clear();
    m_MET_dPhi_Ref.clear();
    m_MET_CorrFinalTrk_Ref.clear();
    m_MET_CorrFinalClus_Ref.clear();
    m_MET_Reb.clear();
    m_MET_Reb_x.clear();
    m_MET_Reb_y.clear();
    m_MET_Reb_phi.clear();
    m_MET_Reb_sum.clear();
    m_MET_Diff_Reb.clear();
    m_MET_Diff_Reb_x.clear();
    m_MET_Diff_Reb_y.clear();
    m_MET_Diff_Reb_phi.clear();
    m_MET_Diff_Reb_sum.clear();
    m_MET_Cumu_Reb.clear();
    m_MET_Resolution_Reb.clear();
    m_MET_Significance_Reb.clear();
    m_MET_dPhi_Reb.clear();
    m_MET_CorrFinalTrk_Reb.clear();
    m_MET_CorrFinalClus_Reb.clear();
}

PhysValMET() [2/2]

MissingEtDQA::PhysValMET::PhysValMET ( )

private

Default constructor:

Member Function Documentation

Accept() [1/5]

bool MissingEtDQA::PhysValMET::Accept ( const xAOD::Electron * el )

private

Definition at line 1503 of file PhysValMET.cxx.

  {
    if( fabs(el->eta())>2.47 || el->pt()<10e3 ) return false;
    return static_cast<bool> (m_elecSelLHTool->accept(el));
  }

Accept() [2/5]

bool MissingEtDQA::PhysValMET::Accept ( const xAOD::Jet * jet, double JvtCut, ToolHandle< IJetUpdateJvt > * jvtTool )

private

Definition at line 1518 of file PhysValMET.cxx.

  {
    if( jet->pt()<20e3 || jvtTool == nullptr) return false;
    return (fabs(jet->eta()) > 2.4 || jet->pt() > 60e3 || (*jvtTool)->updateJvt(*jet) > JvtCut);
  }

Accept() [3/5]

bool MissingEtDQA::PhysValMET::Accept ( const xAOD::Muon * muon )

private

Definition at line 1497 of file PhysValMET.cxx.

  {
    if( mu->pt()<2.5e3 || mu->pt()/cosh(mu->eta())<4e3 ) return false;
    return static_cast<bool> (m_muonSelTool->accept(*mu));
  }

Accept() [4/5]

bool MissingEtDQA::PhysValMET::Accept ( const xAOD::Photon * ph )

private

Definition at line 1509 of file PhysValMET.cxx.

  {
    if( !(ph->author()&20) || fabs(ph->eta())>2.47 || ph->pt()<10e3 ) return false;
    return static_cast<bool>(m_photonSelIsEMTool->accept(ph));
  }

Accept() [5/5]

bool MissingEtDQA::PhysValMET::Accept ( const xAOD::TauJet * tau )

private

Definition at line 1515 of file PhysValMET.cxx.

  { return static_cast<bool> (m_tauSelTool->accept( *tau )); }

bookHistograms()

StatusCode MissingEtDQA::PhysValMET::bookHistograms ( )

virtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 195 of file PhysValMET.cxx.

  {
    ATH_MSG_INFO ("Booking hists " << name() << "...");
      
    // Physics validation plots are level 10
 
    int nbinp = 100;
    int nbinpxy = 100;
    int nbinphi = 63;
    int nbinE = 100;
    double suptmi = 500.;
    double suptmixy = 250.;
    double binphi = 3.15;
    double lowET = 0.;
    double suET = 2500.;
 
    if (m_detailLevel >= 10) {
 
      for (const auto& type : m_types){
        std::string name_met;
        std::string name_sub;
        std::vector<std::string> corrClus_names;
        std::vector<std::string> corrTrk_names;
        std::vector<std::string> sum_names;
        std::string dir;
 
        corrClus_names.emplace_back("RefEle");
        corrClus_names.emplace_back("RefGamma");
        corrClus_names.emplace_back("RefTau");
        corrClus_names.emplace_back("Muons");
        corrClus_names.emplace_back("RefJet");
        corrClus_names.emplace_back("SoftClus");
        
        corrTrk_names.emplace_back("RefEle");
        corrTrk_names.emplace_back("RefGamma");
        corrTrk_names.emplace_back("RefTau");
        corrTrk_names.emplace_back("Muons");
        corrTrk_names.emplace_back("RefJet");
        corrTrk_names.emplace_back("PVSoftTrk");
 
        sum_names.emplace_back("RefEle");
        sum_names.emplace_back("RefGamma");
        sum_names.emplace_back("RefTau");
        sum_names.emplace_back("Muons");
        sum_names.emplace_back("RefJet");
 
        //-------------------------------------------------------------------------------------
        // First set-up Reference MET histograms (if we want them)
        if (m_doMETRefPlots){
        name_met = "MET_Reference_" + type;
        m_dir_met.clear();
        std::vector<TH1D*> v_MET_Ref;
        std::vector<TH1D*> v_MET_Ref_x;
        std::vector<TH1D*> v_MET_Ref_y;
        std::vector<TH1D*> v_MET_Ref_phi;
        std::vector<TH1D*> v_MET_Ref_sum;
        std::vector<TH1D*> v_MET_Cumu_Ref;
        std::vector<TH1D*> v_MET_Resolution_Ref;
        std::vector<TH1D*> v_MET_Significance_Ref;
        std::vector<TH1D*> v_MET_dPhi_Ref;
        std::vector<TH2D*> v_MET_CorrFinalTrk_Ref;
        std::vector<TH2D*> v_MET_CorrFinalClus_Ref;
        std::vector<TH1D*> v_MET_Diff_Ref;
        std::vector<TH1D*> v_MET_Diff_Ref_x;
        std::vector<TH1D*> v_MET_Diff_Ref_y;
        std::vector<TH1D*> v_MET_Diff_Ref_phi;
        std::vector<TH1D*> v_MET_Diff_Ref_sum;
 
        for(const auto& term : m_terms) {
          v_MET_Ref.push_back( new  TH1D((name_met + "_" + term).c_str(), (name_met + " " + m_names[term] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
          v_MET_Ref_x.push_back( new  TH1D((name_met + "_" + term +"_x").c_str(), (name_met + " " + m_names[term] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
          v_MET_Ref_y.push_back( new  TH1D((name_met + "_" + term + "_y").c_str(), (name_met + " " + m_names[term] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
          v_MET_Ref_phi.push_back( new  TH1D((name_met + "_" + term + "_phi").c_str(), (name_met + " " + m_names[term] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi) );
          v_MET_Ref_sum.push_back( new  TH1D((name_met + "_" + term + "_sum").c_str(), (name_met + " " + m_names[term] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET) );
          m_dir_met.push_back("MET/" + name_met + "/Terms/" + term + "/");
        }
        
        m_MET_Ref[type] = v_MET_Ref;
        m_MET_Ref_x[type] = v_MET_Ref_x;
        m_MET_Ref_y[type] = v_MET_Ref_y;
        m_MET_Ref_phi[type] = v_MET_Ref_phi;
        m_MET_Ref_sum[type] = v_MET_Ref_sum;
 
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Ref.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Ref[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Ref_x[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Ref_y[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Ref_phi[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Ref_sum[type].at(i),m_dir_met[i],all));
        }
 
        name_sub = name_met + "/Cumulative";
        v_MET_Cumu_Ref.push_back( new  TH1D((name_met + "_Cumulative_FinalClus").c_str(), (name_met + " CST MET cumulative; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
        v_MET_Cumu_Ref.push_back( new  TH1D((name_met + "_Cumulative_FinalTrk").c_str(), (name_met + " TST MET cumulative; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
        
        m_MET_Cumu_Ref[type] = v_MET_Cumu_Ref;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Cumu_Ref.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Cumu_Ref[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        name_sub = name_met + "/Residuals";
        v_MET_Resolution_Ref.push_back(  new TH1D((name_met + "_Resolution_FinalClus_x").c_str(), ("x-Residual of CST MET in " + name_met + "; #Delta(E_{T,CST}^{miss}, E_{T,truth}^{miss})_{x} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
        v_MET_Resolution_Ref.push_back(  new TH1D((name_met + "_Resolution_FinalClus_y").c_str(), ("y-Residual of CST MET in " + name_met + "; #Delta(E_{T,CST}^{miss}, E_{T,truth}^{miss})_{y} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
        v_MET_Resolution_Ref.push_back(  new TH1D((name_met + "_Resolution_FinalTrk_x").c_str(), ("x-Residual of TST MET in " + name_met + "; #Delta(E_{T,TST}^{miss}, E_{T,truth}^{miss})_{x} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
        v_MET_Resolution_Ref.push_back(  new TH1D((name_met + "_Resolution_FinalTrk_y").c_str(), ("y-Residual of TST MET in " + name_met + "; #Delta(E_{T,TST}^{miss}, E_{T,truth}^{miss})_{y} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
        
        m_MET_Resolution_Ref[type] = v_MET_Resolution_Ref;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Resolution_Ref.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Resolution_Ref[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        name_sub = name_met + "/Significance";
        v_MET_Significance_Ref.push_back(  new TH1D((name_met + "_Significance_FinalClus").c_str(), ("MET / sqrt(sumet) for " + name_met + " CST; MET/#sqrt{SET} [#sqrt{GeV}]; Entries / 0.25 #sqrt{GeV}").c_str(), nbinp, 0., 25.) );
        v_MET_Significance_Ref.push_back(  new TH1D((name_met + "_Significance_FinalTrk").c_str(), ("MET / sqrt(sumet) for " + name_met + " TST; MET/#sqrt{SET} [#sqrt{GeV}]; Entries / 0.25 #sqrt{GeV}").c_str(), nbinp, 0., 25.) );
        
        m_MET_Significance_Ref[type] = v_MET_Significance_Ref;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Significance_Ref.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Significance_Ref[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        name_sub = name_met + "/dPhi";
        v_MET_dPhi_Ref.push_back(  new TH1D((name_met + "_dPhi_leadJetMET_FinalClus").c_str(), ("MET deltaPhi vs leading jet for " + name_met + " CST; #Delta#Phi(leadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Ref.push_back(  new TH1D((name_met + "_dPhi_subleadJetMET_FinalClus").c_str(), ("MET deltaPhi vs subleading jet for " + name_met + " CST; #Delta#Phi(subleadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Ref.push_back(  new TH1D((name_met + "_dPhi_leadLepMET_FinalClus").c_str(), ("MET deltaPhi vs leading lepton for " + name_met + " CST; #Delta#Phi(leadLep, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Ref.push_back(  new TH1D((name_met + "_dPhi_leadJetMET_FinalTrk").c_str(), ("MET deltaPhi vs leading jet for " + name_met + " TST; #Delta#Phi(leadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Ref.push_back(  new TH1D((name_met + "_dPhi_subleadJetMET_FinalTrk").c_str(), ("MET deltaPhi vs subleading jet for " + name_met + " TST; #Delta#Phi(subleadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Ref.push_back(  new TH1D((name_met + "_dPhi_leadLepMET_FinalTrk").c_str(), ("MET deltaPhi vs leading lepton for " + name_met + " TST; #Delta#Phi(leadLep, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        
        m_MET_dPhi_Ref[type] = v_MET_dPhi_Ref;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_dPhi_Ref.size(); ++i) {
          ATH_CHECK(regHist(m_MET_dPhi_Ref[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        name_sub = name_met + "/Correlations";
        
        v_MET_CorrFinalClus_Ref.reserve(corrClus_names.size());
 
        for(const auto& it : corrClus_names) {
          v_MET_CorrFinalClus_Ref.push_back( new  TH2D((name_met + "_" + it + "_FinalClus").c_str(), (name_met + " " + m_names[it] + " vs. CST MET; E_{T," + it + "}^{miss} [GeV]; E_{T,CST}^{miss} [GeV]; Entries").c_str(), nbinp, 0., suptmi, nbinp, 0., suptmi) );
        }
        v_MET_CorrFinalTrk_Ref.reserve(corrTrk_names.size());
 
        for(const auto& it : corrTrk_names) {
          v_MET_CorrFinalTrk_Ref.push_back( new  TH2D((name_met + "_" + it + "_FinalTrk").c_str(), (name_met + " " + m_names[it] + " vs. TST MET; E_{T," + it + "}^{miss} [GeV]; E_{T,TST}^{miss} [GeV]; Entries").c_str(), nbinp, 0., suptmi, nbinp, 0., suptmi) );
        }
 
        m_MET_CorrFinalClus_Ref[type] = v_MET_CorrFinalClus_Ref;
        m_MET_CorrFinalTrk_Ref[type] = v_MET_CorrFinalTrk_Ref;
 
        for(std::vector<TH2D*>::size_type i = 0; i < v_MET_CorrFinalTrk_Ref.size(); ++i) {
          ATH_CHECK(regHist(m_MET_CorrFinalTrk_Ref[type].at(i),"MET/" + name_sub + "/",all));
        }
        for(std::vector<TH2D*>::size_type i = 0; i < v_MET_CorrFinalClus_Ref.size(); ++i) {
          ATH_CHECK(regHist(m_MET_CorrFinalClus_Ref[type].at(i),"MET/" + name_sub + "/",all));
        }
 
        m_dir_met.clear();
        
        for(const auto& it : sum_names) {
          v_MET_Diff_Ref.push_back( new  TH1D((name_met + "_Diff_" + it).c_str(), ("MET_Diff " + m_names[it] + " in " + name_met +"; E_{T}^{miss} - #Sigma p_{T} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150));
          v_MET_Diff_Ref_x.push_back( new  TH1D((name_met + "_Diff_" + it +"_x").c_str(), ("MET_Diff x " + m_names[it] + " in " + name_met +"; E_{x}^{miss} - #Sigma p_{x} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150) );
          v_MET_Diff_Ref_y.push_back( new  TH1D((name_met + "_Diff_" + it +"_y").c_str(), ("MET_Diff y " + m_names[it] + " in " + name_met +"; E_{y}^{miss} - #Sigma p_{y} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150) );
          v_MET_Diff_Ref_phi.push_back( new  TH1D((name_met + "_Diff_" + it +"_phi").c_str(), ("MET_Diff phi " + m_names[it] + " in " + name_met +"; #Delta#Phi(E_{T}^{miss},#Sigma p_{T}); Entries / 0.1").c_str(), nbinphi,-binphi,binphi) );
          v_MET_Diff_Ref_sum.push_back( new  TH1D((name_met + "_Diff_" + it +"_sum").c_str(), ("MET_Diff sumet " + m_names[it] + " in " + name_met +"; E_{T}^{sum} - #Sigma |p_{T}| [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -250, 250) );
          m_dir_met.push_back("MET/" + name_met + "/Differences/" + it + "/");
        }
        
        m_MET_Diff_Ref[type] = v_MET_Diff_Ref;
        m_MET_Diff_Ref_x[type] = v_MET_Diff_Ref_x;
        m_MET_Diff_Ref_y[type] = v_MET_Diff_Ref_y;
        m_MET_Diff_Ref_phi[type] = v_MET_Diff_Ref_phi;
        m_MET_Diff_Ref_sum[type] = v_MET_Diff_Ref_sum;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Diff_Ref.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Diff_Ref[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Diff_Ref_x[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Diff_Ref_y[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Diff_Ref_phi[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Diff_Ref_sum[type].at(i),m_dir_met[i],all));
        }
        // End of if-statement (m_doMETRefPlots) 
        }
 
        //-------------------------------------------------------------------------------------
        // Now the same for Rebuilt MET
        
        name_met = "MET_Rebuilt_" + type;
        m_dir_met.clear();
        std::vector<TH1D*> v_MET_Reb;
        std::vector<TH1D*> v_MET_Reb_x;
        std::vector<TH1D*> v_MET_Reb_y;
        std::vector<TH1D*> v_MET_Reb_phi;
        std::vector<TH1D*> v_MET_Reb_sum;
        std::vector<TH1D*> v_MET_Cumu_Reb;
        std::vector<TH1D*> v_MET_Resolution_Reb;
        std::vector<TH1D*> v_MET_Significance_Reb;
        std::vector<TH1D*> v_MET_dPhi_Reb;
        std::vector<TH2D*> v_MET_CorrFinalTrk_Reb;
        std::vector<TH2D*> v_MET_CorrFinalClus_Reb;
        std::vector<TH1D*> v_MET_Diff_Reb;
        std::vector<TH1D*> v_MET_Diff_Reb_x;
        std::vector<TH1D*> v_MET_Diff_Reb_y;
        std::vector<TH1D*> v_MET_Diff_Reb_phi;
        std::vector<TH1D*> v_MET_Diff_Reb_sum;
        
        for(const auto& term : m_terms) {
          v_MET_Reb.push_back( new  TH1D((name_met + "_" + term).c_str(), (name_met + " " + m_names[term] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
          v_MET_Reb_x.push_back( new  TH1D((name_met + "_" + term + "_x").c_str(), (name_met + " " + m_names[term] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
          v_MET_Reb_y.push_back( new  TH1D((name_met + "_" + term + "_y").c_str(), (name_met + " " + m_names[term] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
          v_MET_Reb_phi.push_back( new  TH1D((name_met + "_" + term + "_phi").c_str(), (name_met + " " + m_names[term] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi) );
          v_MET_Reb_sum.push_back( new  TH1D((name_met + "_" + term + "_sum").c_str(), (name_met + " " + m_names[term] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET) );
          m_dir_met.push_back("MET/" + name_met + "/Terms/" + term + "/");
        }
        
        m_MET_Reb[type] = v_MET_Reb;
        m_MET_Reb_x[type] = v_MET_Reb_x;
        m_MET_Reb_y[type] = v_MET_Reb_y;
        m_MET_Reb_phi[type] = v_MET_Reb_phi;
        m_MET_Reb_sum[type] = v_MET_Reb_sum;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Reb.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Reb[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Reb_x[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Reb_y[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Reb_phi[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Reb_sum[type].at(i),m_dir_met[i],all));
        }
        
        name_sub = name_met + "/Cumulative";
        v_MET_Cumu_Reb.push_back( new  TH1D((name_met + "_Cumulative_FinalClus").c_str(), (name_met + " CST MET cumulative; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
        v_MET_Cumu_Reb.push_back( new  TH1D((name_met + "_Cumulative_FinalTrk").c_str(), (name_met + " TST MET cumulative; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi) );
        
        m_MET_Cumu_Reb[type] = v_MET_Cumu_Reb;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Cumu_Reb.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Cumu_Reb[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        name_sub = name_met + "/Residuals";
        v_MET_Resolution_Reb.push_back(  new TH1D((name_met + "_Resolution_FinalClus_x").c_str(), ("x-Residual of CST MET in " + name_met + "; #Delta(E_{T,CST}^{miss}, E_{T,truth}^{miss})_{x} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
        v_MET_Resolution_Reb.push_back(  new TH1D((name_met + "_Resolution_FinalClus_y").c_str(), ("y-Residual of CST MET in " + name_met + "; #Delta(E_{T,CST}^{miss}, E_{T,truth}^{miss})_{y} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
        v_MET_Resolution_Reb.push_back(  new TH1D((name_met + "_Resolution_FinalTrk_x").c_str(), ("x-Residual of TST MET in " + name_met + "; #Delta(E_{T,TST}^{miss}, E_{T,truth}^{miss})_{x} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
        v_MET_Resolution_Reb.push_back(  new TH1D((name_met + "_Resolution_FinalTrk_y").c_str(), ("y-Residual of TST MET in " + name_met + "; #Delta(E_{T,TST}^{miss}, E_{T,truth}^{miss})_{y} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy) );
        m_MET_Resolution_Reb[type] = v_MET_Resolution_Reb;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Resolution_Reb.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Resolution_Reb[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        name_sub = name_met + "/Significance";
        v_MET_Significance_Reb.push_back(  new TH1D((name_met + "_Significance_FinalClus").c_str(), ("MET / sqrt(sumet) for " + name_met + " CST; MET/#sqrt{SET} [#sqrt{GeV}]; Entries / 0.25 #sqrt{GeV}").c_str(), nbinp, 0., 25.) );
        v_MET_Significance_Reb.push_back(  new TH1D((name_met + "_Significance_FinalTrk").c_str(), ("MET / sqrt(sumet) for " + name_met + " TST; MET/sqrt{SET} [#sqrt{GeV}]; Entries / 0.25 #sqrt{GeV}").c_str(), nbinp, 0., 25.) );
        
        m_MET_Significance_Reb[type] = v_MET_Significance_Reb;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Significance_Reb.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Significance_Reb[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        name_sub = name_met + "/dPhi";
        v_MET_dPhi_Reb.push_back(  new TH1D((name_met + "_dPhi_leadJetMET_FinalClus").c_str(), ("MET deltaPhi vs leading jet for " + name_met + " CST; #Delta#Phi(leadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Reb.push_back(  new TH1D((name_met + "_dPhi_subleadJetMET_FinalClus").c_str(), ("MET deltaPhi vs subleading jet for " + name_met + " CST; #Delta#Phi(subleadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Reb.push_back(  new TH1D((name_met + "_dPhi_leadLepMET_FinalClus").c_str(), ("MET deltaPhi vs leading lepton for " + name_met + " CST; #Delta#Phi(leadLep, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Reb.push_back(  new TH1D((name_met + "_dPhi_leadJetMET_FinalTrk").c_str(), ("MET deltaPhi vs leading jet for " + name_met + " TST; #Delta#Phi(leadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Reb.push_back(  new TH1D((name_met + "_dPhi_subleadJetMET_FinalTrk").c_str(), ("MET deltaPhi vs subleading jet for " + name_met + " TST; #Delta#Phi(subleadJet, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        v_MET_dPhi_Reb.push_back(  new TH1D((name_met + "_dPhi_leadLepMET_FinalTrk").c_str(), ("MET deltaPhi vs leading lepton for " + name_met + " TST; #Delta#Phi(leadLep, MET); Entries / 0.05").c_str(), nbinphi, 0., binphi) );
        
        m_MET_dPhi_Reb[type] = v_MET_dPhi_Reb;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_dPhi_Reb.size(); ++i) {
          ATH_CHECK(regHist(m_MET_dPhi_Reb[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        name_sub = name_met + "/Correlations";
        v_MET_CorrFinalClus_Reb.reserve(corrClus_names.size());
 
        for(const auto& it : corrClus_names) {
          v_MET_CorrFinalClus_Reb.push_back( new  TH2D((name_met + "_" + it + "_FinalClus").c_str(), (name_met + " " + m_names[it] + " vs. CST MET; E_{T," + it + "}^{miss} [GeV]; E_{T,CST}^{miss} [GeV]; Entries").c_str(), nbinp, 0., suptmi, nbinp, 0., suptmi) );
        }
        v_MET_CorrFinalTrk_Reb.reserve(corrTrk_names.size());
 
        for(const auto& it : corrTrk_names) {
          v_MET_CorrFinalTrk_Reb.push_back( new  TH2D((name_met + "_" + it + "_FinalTrk").c_str(), (name_met + " " + m_names[it] + " vs. TST MET; E_{T," + it + "}^{miss} [GeV]; E_{T,TST}^{miss} [GeV]; Entries").c_str(), nbinp, 0., suptmi, nbinp, 0., suptmi) );
        }
 
        m_MET_CorrFinalClus_Reb[type] = v_MET_CorrFinalClus_Reb;
        m_MET_CorrFinalTrk_Reb[type] = v_MET_CorrFinalTrk_Reb;
        
        for(std::vector<TH2D*>::size_type i = 0; i < v_MET_CorrFinalTrk_Reb.size(); ++i) {
          ATH_CHECK(regHist(m_MET_CorrFinalTrk_Reb[type].at(i),"MET/" + name_sub + "/",all));
        }
        for(std::vector<TH2D*>::size_type i = 0; i < v_MET_CorrFinalClus_Reb.size(); ++i) {
          ATH_CHECK(regHist(m_MET_CorrFinalClus_Reb[type].at(i),"MET/" + name_sub + "/",all));
        }
        
        m_dir_met.clear();
        
        for(const auto& it : sum_names) {
          v_MET_Diff_Reb.push_back( new  TH1D((name_met + "_Diff_" + it).c_str(), ("MET_Diff " + m_names[it] + " in " + name_met +"; E_{T}^{miss} - #Sigma p_{T} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150));
          v_MET_Diff_Reb_x.push_back( new  TH1D((name_met + "_Diff_" + it + "_x").c_str(), ("MET_Diff x " + m_names[it] + " in " + name_met +"; E_{x}^{miss} - #Sigma p_{x} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150) );
          v_MET_Diff_Reb_y.push_back( new  TH1D((name_met + "_Diff_" + it + "_y").c_str(), ("MET_Diff y " + m_names[it] + " in " + name_met +"; E_{y}^{miss} - #Sigma p_{y} [GeV]; Entries / 3 GeV").c_str(), nbinpxy, -150, 150) );
          v_MET_Diff_Reb_phi.push_back( new  TH1D((name_met + "_Diff_" + it + "_phi").c_str(), ("MET_Diff phi " + m_names[it] + " in " + name_met +"; #Delta#Phi(E_{T}^{miss}, #Sigma p_{T}); Entries / 0.1").c_str(), nbinphi,-binphi,binphi) );
          v_MET_Diff_Reb_sum.push_back( new  TH1D((name_met + "_Diff_" + it + "_sum").c_str(), ("MET_Diff sumet " + m_names[it] + " in " + name_met +"; E_{T}^{sum} - #Sigma |p_{T}| [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -250, 250) );
          m_dir_met.push_back("MET/" + name_met + "/Differences/" + it + "/");
        }
        
        m_MET_Diff_Reb[type] = v_MET_Diff_Reb;
        m_MET_Diff_Reb_x[type] = v_MET_Diff_Reb_x;
        m_MET_Diff_Reb_y[type] = v_MET_Diff_Reb_y;
        m_MET_Diff_Reb_phi[type] = v_MET_Diff_Reb_phi;
        m_MET_Diff_Reb_sum[type] = v_MET_Diff_Reb_sum;
        
        for(std::vector<TH1D*>::size_type i = 0; i < v_MET_Diff_Reb.size(); ++i) {
          ATH_CHECK(regHist(m_MET_Diff_Reb[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Diff_Reb_x[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Diff_Reb_y[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Diff_Reb_phi[type].at(i),m_dir_met[i],all));
          ATH_CHECK(regHist(m_MET_Diff_Reb_sum[type].at(i),m_dir_met[i],all));
        }
      } 
 
      //-------------------------------------------------------------------------------------
      // Now MET_Track (only built if METRef is too)
      if (m_doMETRefPlots){
        std::string name_met = "MET_Track";
        std::string dir = "MET/" + name_met + "/";
        std::string sub_dir;
 
        sub_dir = dir + "Track/";
        ATH_CHECK(regHist(m_MET_Track = new  TH1D("Track", (name_met + " " + m_names["Track"] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi), sub_dir, all));
        ATH_CHECK(regHist(m_MET_Track_x = new  TH1D("Track_x", (name_met + " " + m_names["Track"] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
        ATH_CHECK(regHist(m_MET_Track_y = new  TH1D("Track_y", (name_met + " " + m_names["Track"] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
        ATH_CHECK(regHist(m_MET_Track_phi = new  TH1D("Track_phi", (name_met + " " + m_names["Track"] + " phi;  #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi), sub_dir, all));
        ATH_CHECK(regHist(m_MET_Track_sum = new  TH1D("Track_sum", (name_met + " " + m_names["Track"] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET), sub_dir, all));
        
        sub_dir = dir + "PVTrack_Nominal/";
        ATH_CHECK(regHist(m_MET_PVTrack_Nominal = new TH1D("PVTrack_Nominal", (name_met + " " + m_names["PVTrack_Nominal"] + " ; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi), sub_dir, all));
        ATH_CHECK(regHist(m_MET_PVTrack_Nominal_x = new  TH1D("PVTrack_Nominal_x", (name_met + " " + m_names["PVTrack_Nominal"] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
        ATH_CHECK(regHist(m_MET_PVTrack_Nominal_y = new  TH1D("PVTrack_Nominal_y", (name_met + " " + m_names["PVTrack_Nominal"] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
        ATH_CHECK(regHist(m_MET_PVTrack_Nominal_phi = new  TH1D("PVTrack_Nominal_phi", (name_met + " " + m_names["PVTrack_Nominal"] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi), sub_dir, all));
        ATH_CHECK(regHist(m_MET_PVTrack_Nominal_sum = new  TH1D("PVTrack_Nominal_sum", (name_met + " " + m_names["PVTrack_Nominal"] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET), sub_dir, all));
        
        sub_dir = dir + "PVTrack_Pileup/";
        ATH_CHECK(regHist(m_MET_PVTrack_Pileup = new  TH1D("PVTrack_Pileup", (name_met + " " + m_names["PVTrack_Pileup"] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi), sub_dir, all));
        ATH_CHECK(regHist(m_MET_PVTrack_Pileup_x = new  TH1D("PVTrack_Pileup_x", (name_met + " " + m_names["PVTrack_Pileup"] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
        ATH_CHECK(regHist(m_MET_PVTrack_Pileup_y = new  TH1D("PVTrack_Pileup_y", (name_met +" " +  m_names["PVTrack_Pileup"] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), sub_dir, all));
        ATH_CHECK(regHist(m_MET_PVTrack_Pileup_phi = new  TH1D("PVTrack_Pileup_phi", (name_met + " " + m_names["PVTrack_Pileup"] + " phi; #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi), sub_dir, all));
        ATH_CHECK(regHist(m_MET_PVTrack_Pileup_sum = new  TH1D("PVTrack_Pileup_sum", (name_met + " " + m_names["PVTrack_Pileup"] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET), sub_dir, all));
        }
 
        //-------------------------------------------------------------------------------------
        //Now MET_Calo
 
        std::string name_met = "MET_Calo";
        std::string dir = "MET/" + name_met + "/";
 
        ATH_CHECK(regHist(m_MET_Calo = new  TH1D("Calo", (name_met + " " + m_names["Calo"] + "; E_{T}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinp, 0., suptmi), dir, all));
        ATH_CHECK(regHist(m_MET_Calo_x = new  TH1D("Calo_x", (name_met + " " + m_names["Calo"] + " x; E_{x}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), dir, all));
        ATH_CHECK(regHist(m_MET_Calo_y = new  TH1D("Calo_y", (name_met + " " + m_names["Calo"] + " y; E_{y}^{miss} [GeV]; Entries / 5 GeV").c_str(), nbinpxy, -suptmixy, suptmixy), dir, all));
        ATH_CHECK(regHist(m_MET_Calo_phi = new  TH1D("Calo_phi", (name_met + " " + m_names["Calo"] + " phi;  #Phi; Entries / 0.1").c_str(), nbinphi,-binphi,binphi), dir, all));
        ATH_CHECK(regHist(m_MET_Calo_sum = new  TH1D("Calo_sum", (name_met + " " + m_names["Calo"] + " sum; E_{T}^{sum} [GeV]; Entries / 25 GeV").c_str(), nbinE, lowET, suET), dir, 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 1284 of file ManagedMonitorToolBase.cxx.

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

bookHists()

StatusCode ManagedMonitorToolBase::bookHists ( )

virtualinherited

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

Implements IMonitorToolBase.

Reimplemented in TileDigitsMonTool, and TileRawChannelMonTool.

Definition at line 729 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, TileCellNoiseMonTool, TileDigitsMonTool, and TileRawChannelMonTool.

Definition at line 1669 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());
  }

deregGraph()

StatusCode ManagedMonitorToolBase::deregGraph ( TGraph * g )

virtualinherited

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

Definition at line 1623 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 1615 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 1641 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 1631 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 794 of file ManagedMonitorToolBase.h.

{ return m_endOfEventsBlock; }

endOfLowStatFlag()

bool ManagedMonitorToolBase::endOfLowStatFlag ( ) const

inlineprotectedinherited

Definition at line 795 of file ManagedMonitorToolBase.h.

{ return m_endOfLowStat; }

endOfLumiBlockFlag()

bool ManagedMonitorToolBase::endOfLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 796 of file ManagedMonitorToolBase.h.

{ return m_endOfLumiBlock; }

endOfRunFlag()

bool ManagedMonitorToolBase::endOfRunFlag ( ) const

inlineprotectedinherited

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

fillHistograms()

StatusCode MissingEtDQA::PhysValMET::fillHistograms ( )

virtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 566 of file PhysValMET.cxx.

  {
    ATH_MSG_DEBUG ("Filling hists " << name() << "...");
 
    //If we're running over new AODs without MET containers, don't do anything!
    if(!m_inputIsDAOD && !m_doMETRefPlots)
      return StatusCode::SUCCESS;
 
    //Beamspot weight
    const xAOD::EventInfo* eventInfo(nullptr);
    ATH_CHECK(evtStore()->retrieve(eventInfo, "EventInfo"));
 
    float weight = eventInfo->beamSpotWeight();
 
    //Retrieve MET Truth
    const xAOD::MissingETContainer* met_Truth = nullptr;
    if(m_doTruth) {
      ATH_CHECK( evtStore()->retrieve(met_Truth,"MET_Truth") );
      if (!met_Truth) {
        ATH_MSG_ERROR ( "Failed to retrieve MET_Truth. Exiting." );
        return StatusCode::FAILURE;
      }
    }
 
    //Physics Objects
    const xAOD::MuonContainer* muons = nullptr;
    ATH_CHECK( evtStore()->retrieve(muons,m_muonColl) );
    if (!muons) {
      ATH_MSG_ERROR ( "Failed to retrieve Muon container. Exiting." );
      return StatusCode::FAILURE;
    }
    ConstDataVector<MuonContainer> metMuons(SG::VIEW_ELEMENTS);
    bool is_muon = 0;
    for(const auto mu : *muons) {
      if(Accept(mu)) {
        metMuons.push_back(mu);
        is_muon = 1;
      }
    }
 
    const xAOD::ElectronContainer* electrons = nullptr;
    ATH_CHECK( evtStore()->retrieve(electrons,m_eleColl) );
    if (!electrons) {
      ATH_MSG_ERROR ( "Failed to retrieve Electron container. Exiting." );
      return StatusCode::FAILURE;
    }
   ConstDataVector<ElectronContainer> metElectrons(SG::VIEW_ELEMENTS);
   bool is_electron = 0;
   for(const auto el : *electrons) {
     if(Accept(el)) {
       metElectrons.push_back(el);
       is_electron = 1;
     }
   }
 
    const xAOD::PhotonContainer* photons = nullptr;
    ATH_CHECK( evtStore()->retrieve(photons,m_gammaColl) );
    if (!electrons) {
      ATH_MSG_ERROR ( "Failed to retrieve Photon container. Exiting." );
      return StatusCode::FAILURE;
    }
    ConstDataVector<PhotonContainer> metPhotons(SG::VIEW_ELEMENTS);
    for(const auto ph : *photons) {
      if(Accept(ph)) {
        metPhotons.push_back(ph);
      }
    }
 
    const TauJetContainer* taus = nullptr;
    ATH_CHECK( evtStore()->retrieve(taus, m_tauColl) );
    if(!taus) {
      ATH_MSG_ERROR("Failed to retrieve TauJet container: " << m_tauColl);
      return StatusCode::SUCCESS;
    }
    ConstDataVector<TauJetContainer> metTaus(SG::VIEW_ELEMENTS);
    for(const auto tau : *taus) {
      if(Accept(tau)) {
        metTaus.push_back(tau);
      }
    }
 
    // Overlap removal
 
    ConstDataVector<PhotonContainer>::iterator pho_itr;
    ConstDataVector<ElectronContainer>::iterator ele_itr;
    ConstDataVector<TauJetContainer>::iterator taujet_itr;
    ConstDataVector<MuonContainer>::iterator mu_itr;
    ConstDataVector<JetContainer>::iterator jetc_itr;
 
    //Photons
    bool is_photon = 0;
    ConstDataVector<PhotonContainer> metPhotonsOR(SG::VIEW_ELEMENTS);
    for(pho_itr = metPhotons.begin(); pho_itr != metPhotons.end(); ++pho_itr ) {
      TLorentzVector phtlv = (*pho_itr)->p4();
      bool passOR = 1;
      for(ele_itr = metElectrons.begin(); ele_itr != metElectrons.end(); ++ele_itr) {
        if(phtlv.DeltaR((*ele_itr)->p4()) < 0.2) {
          passOR = 0;
          break;
        }
      }
      if(passOR){
        metPhotonsOR.push_back(*pho_itr);
        is_photon = 1;
      }
    }
  
    //TauJets
    ConstDataVector<TauJetContainer> metTausOR(SG::VIEW_ELEMENTS);
    bool is_tau = 0;
    for(taujet_itr = metTaus.begin(); taujet_itr != metTaus.end(); ++taujet_itr ) {
      TLorentzVector tautlv = (*taujet_itr)->p4();
      bool passOR = 1;
      for(ele_itr = metElectrons.begin(); ele_itr != metElectrons.end(); ++ele_itr) {
        if(tautlv.DeltaR((*ele_itr)->p4()) < 0.2) {
          passOR = 0;
          break;
        }
      }
      for(pho_itr = metPhotonsOR.begin(); pho_itr != metPhotonsOR.end(); ++pho_itr) {
        if(tautlv.DeltaR((*pho_itr)->p4()) < 0.2) {
          passOR = 0;
          break;
        }
      }
      if(passOR){
        metTausOR.push_back(*taujet_itr);
        is_tau = 1;
      }
    }
 
    //Sum up the pT's of the objects
    TLorentzVector el_tlv;
    double sum_el = 0;
    for(ele_itr = metElectrons.begin(); ele_itr != metElectrons.end(); ++ele_itr ) {
      el_tlv += (*ele_itr)->p4();
      sum_el += (*ele_itr)->pt();
    }
    
    TLorentzVector mu_tlv;
    double sum_mu = 0;
    for(mu_itr = metMuons.begin(); mu_itr != metMuons.end(); ++mu_itr ) {
      mu_tlv += (*mu_itr)->p4();
      sum_mu += (*mu_itr)->pt();
    }
 
    TLorentzVector tau_tlv;
    double sum_tau = 0;
    for(taujet_itr = metTausOR.begin(); taujet_itr != metTausOR.end(); ++taujet_itr ) {
      tau_tlv += (*taujet_itr)->p4();
      sum_tau += (*taujet_itr)->pt();
    }
  
    TLorentzVector photon_tlv;
    double sum_photon = 0;
    for(pho_itr = metPhotonsOR.begin(); pho_itr != metPhotonsOR.end(); ++pho_itr ) {
      photon_tlv += (*pho_itr)->p4();
      sum_photon += (*pho_itr)->pt();
    }
 
    for (const auto& type : m_types){
      ToolHandle<IJetUpdateJvt>* jvtTool(nullptr);
      double JvtCut = 0.59;
      if (type == "AntiKt4EMPFlow"){
        JvtCut = 0.2;
        jvtTool = &m_jvtToolPFlow;
      }
      else if (type == "AntiKt4EMTopo"){
        jvtTool = &m_jvtToolEM;
      }
    
      if(jvtTool == nullptr){
        ATH_MSG_ERROR("Unrecognized jet container: " << type << "Jets");
        return StatusCode::FAILURE;
      }
 
      // Retrieve Jets
      std::string name_jet = type + "Jets";
      const xAOD::JetContainer* jets = nullptr;
      ATH_CHECK( evtStore()->retrieve(jets,name_jet) );
      if (!jets) {
        ATH_MSG_ERROR ( "Failed to retrieve Jet container: " << name_jet << ". Exiting." );
        return StatusCode::FAILURE;
      }
      SG::Decorator<float> NewJvtDec("NewJvt");
      for(auto jet : *jets) {
        float newjvt = (*jvtTool)->updateJvt(*jet); 
        NewJvtDec(*jet) = newjvt;
      }
      ConstDataVector<JetContainer> metJets(SG::VIEW_ELEMENTS);
      for(const auto jet : *jets) { 
        metJets.push_back(jet);
      }
      //Overlap Removal
      ConstDataVector<JetContainer> metJetsOR(SG::VIEW_ELEMENTS);
      bool is_jet = 0;
      for(jetc_itr = metJets.begin(); jetc_itr != metJets.end(); ++jetc_itr ) {
        TLorentzVector jettlv = (*jetc_itr)->p4();
        bool passOR = 1;
        for(ele_itr = metElectrons.begin(); ele_itr != metElectrons.end(); ++ele_itr) {
          if(jettlv.DeltaR((*ele_itr)->p4()) < 0.2) {
            passOR = 0;
            break;
          }
        }
        for(pho_itr = metPhotonsOR.begin(); pho_itr != metPhotonsOR.end(); ++pho_itr) {
          if(jettlv.DeltaR((*pho_itr)->p4()) < 0.2) {
            passOR = 0;
            break;
          }
        }
        for(taujet_itr = metTausOR.begin(); taujet_itr != metTausOR.end(); ++taujet_itr) {
          if(jettlv.DeltaR((*taujet_itr)->p4()) < 0.2) {
            passOR = 0;
            break;
          }
        }
        if(passOR){
          metJetsOR.push_back(*jetc_itr);
          is_jet = 1;
        }
      }
 
      TLorentzVector jet_tlv;
      double sum_jet = 0;
      for(jetc_itr = metJetsOR.begin(); jetc_itr != metJetsOR.end(); ++jetc_itr ) {
        jet_tlv += (*jetc_itr)->p4();
        sum_jet += (*jetc_itr)->pt();
      }
 
      // Fill MET_Ref 
      std::string name_met = "MET_Reference_" + type;
      const xAOD::MissingETContainer* met_Ref = nullptr;
      // We're not building METReference anymore in derivations
 
      if(m_doMETRefPlots){
 
        // Retrieve Reference MET
        ATH_CHECK( evtStore()->retrieve(met_Ref, name_met) );
        if (!met_Ref) {
          ATH_MSG_ERROR ("Couldn't retrieve " << name_met);
          return StatusCode::FAILURE;
        }
 
        ATH_MSG_INFO( "  MET_Ref_" << type << ":" );
        for(const auto it : *met_Ref) {
          const std::string& name = it->name();
          if(name == "RefEle"){
            (m_MET_Ref[type]).at(0)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(0)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(0)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(0)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(0)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
          if(name == "RefGamma"){
            (m_MET_Ref[type]).at(1)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(1)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(1)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(1)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(1)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
          if(name == "RefTau"){
            (m_MET_Ref[type]).at(2)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(2)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(2)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(2)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(2)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
          if(name == "Muons"){
            (m_MET_Ref[type]).at(3)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(3)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(3)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(3)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(3)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
          if(name == "RefJet"){
            (m_MET_Ref[type]).at(4)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(4)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(4)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(4)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(4)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
          if(name == "SoftClus"){
            (m_MET_Ref[type]).at(5)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(5)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(5)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(5)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(5)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
          if(name == "PVSoftTrk"){
            (m_MET_Ref[type]).at(6)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(6)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(6)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(6)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(6)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
          if(name == "FinalTrk"){
            (m_MET_Ref[type]).at(7)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(7)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(7)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(7)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(7)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
          if(name == "FinalClus"){
            (m_MET_Ref[type]).at(8)->Fill((*met_Ref)[name.c_str()]->met()/1000., weight);
            (m_MET_Ref_x[type]).at(8)->Fill((*met_Ref)[name.c_str()]->mpx()/1000., weight);
            (m_MET_Ref_y[type]).at(8)->Fill((*met_Ref)[name.c_str()]->mpy()/1000., weight);
            (m_MET_Ref_phi[type]).at(8)->Fill((*met_Ref)[name.c_str()]->phi(), weight);
            (m_MET_Ref_sum[type]).at(8)->Fill((*met_Ref)[name.c_str()]->sumet()/1000., weight);
          }
        }
      }
 
      //Prepare Rebuilding MET
      ATH_MSG_INFO( "  Rebuilding MET_" << type );
      MissingETContainer* met_Reb = new MissingETContainer();
      if( evtStore()->record(met_Reb,("MET_Rebuilt"+type).c_str()).isFailure() ) {
        ATH_MSG_WARNING("Unable to record MissingETContainer: MET_Rebuilt_" << type);
        return StatusCode::FAILURE;
      }
      MissingETAuxContainer* met_RebAux = new MissingETAuxContainer();
      if( evtStore()->record(met_RebAux,("MET_Rebuilt"+type+"Aux").c_str()).isFailure() ) {
        ATH_MSG_WARNING("Unable to record MissingETAuxContainer: MET_Rebuilt" << type);
        return StatusCode::FAILURE;
      }
      met_Reb->setStore(met_RebAux);
 
      m_mapname = "METAssoc_"+type;
      m_corename = "MET_Core_"+type;
      const MissingETAssociationMap* metMap = nullptr;
      if( evtStore()->retrieve(metMap, m_mapname).isFailure() ) {
        ATH_MSG_WARNING("Unable to retrieve MissingETAssociationMap: " << m_mapname);
        return StatusCode::SUCCESS;
      }
      MissingETAssociationHelper metHelper(metMap);
      const MissingETContainer* coreMet(nullptr);
      if( evtStore()->retrieve(coreMet, m_corename).isFailure() ) {
        ATH_MSG_WARNING("Unable to retrieve MissingETContainer: " << m_corename);
        return StatusCode::SUCCESS;
      }
 
      ATH_MSG_INFO( "  MET_Rebuilt_" << type << ":" );
      //Select and flag objects for final MET building ***************************
      if( type.find("PFlow") != std::string::npos) m_metmaker = &m_metmakerPFlow;
      else m_metmaker = &m_metmakerTopo;
 
      // Electrons
      if( (*m_metmaker)->rebuildMET("RefEle", xAOD::Type::Electron, met_Reb, metElectrons.asDataVector(), metHelper).isFailure() ) {
        ATH_MSG_WARNING("Failed to build electron term.");
      }
 
      // Photons
      if( (*m_metmaker)->rebuildMET("RefGamma", xAOD::Type::Photon, met_Reb, metPhotons.asDataVector(), metHelper).isFailure() ) {
        ATH_MSG_WARNING("Failed to build photon term.");
      }
 
      // Taus
      if( (*m_metmaker)->rebuildMET("RefTau", xAOD::Type::Tau, met_Reb,metTaus.asDataVector(),metHelper).isFailure() ){
        ATH_MSG_WARNING("Failed to build tau term.");
      }
 
      // Muons
      if( (*m_metmaker)->rebuildMET("Muons", xAOD::Type::Muon, met_Reb, metMuons.asDataVector(), metHelper).isFailure() ) {
        ATH_MSG_WARNING("Failed to build muon term.");
      }
 
      // Jets
      if( (*m_metmaker)->rebuildJetMET("RefJet", "SoftClus", "PVSoftTrk", met_Reb, jets, coreMet, metHelper, true).isFailure() ) {
        ATH_MSG_WARNING("Failed to build jet and soft terms.");
      }
      MissingETBase::Types::bitmask_t trksource = static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::Track);
      if((*met_Reb)["PVSoftTrk"]) trksource = (*met_Reb)["PVSoftTrk"]->source();
      if( met::buildMETSum("FinalTrk", met_Reb, trksource).isFailure() ){
        ATH_MSG_WARNING("Building MET FinalTrk sum failed.");
      }
      MissingETBase::Types::bitmask_t clsource;
      if (type == "AntiKt4EMTopo") clsource = static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::EMTopo);
      else clsource = static_cast<MissingETBase::Types::bitmask_t>(MissingETBase::Source::Signal::UnknownSignal);
      
      if((*met_Reb)["SoftClus"]) clsource = (*met_Reb)["SoftClus"]->source();
      if( met::buildMETSum("FinalClus", met_Reb, clsource).isFailure() ) {
        ATH_MSG_WARNING("Building MET FinalClus sum failed.");
      }
 
      // Fill MET_Reb
      for(const auto it : *met_Reb) {
        std::string name = it->name();
        if(name == "RefEle"){
          (m_MET_Reb[type]).at(0)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(0)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(0)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(0)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(0)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
        if(name == "RefGamma"){
          (m_MET_Reb[type]).at(1)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(1)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(1)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(1)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(1)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
        if(name == "RefTau"){
          (m_MET_Reb[type]).at(2)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(2)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(2)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(2)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(2)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
        if(name == "Muons"){
          (m_MET_Reb[type]).at(3)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(3)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(3)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(3)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(3)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
        if(name == "RefJet"){
          (m_MET_Reb[type]).at(4)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(4)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(4)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(4)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(4)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
        if(name == "SoftClus"){
          (m_MET_Reb[type]).at(5)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(5)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(5)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(5)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(5)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
        if(name == "PVSoftTrk"){
          (m_MET_Reb[type]).at(6)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(6)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(6)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(6)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(6)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
        if(name == "FinalTrk"){
          (m_MET_Reb[type]).at(7)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(7)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(7)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(7)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(7)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
        if(name == "FinalClus"){
          (m_MET_Reb[type]).at(8)->Fill((*met_Reb)[name.c_str()]->met()/1000., weight);
          (m_MET_Reb_x[type]).at(8)->Fill((*met_Reb)[name.c_str()]->mpx()/1000., weight);
          (m_MET_Reb_y[type]).at(8)->Fill((*met_Reb)[name.c_str()]->mpy()/1000., weight);
          (m_MET_Reb_phi[type]).at(8)->Fill((*met_Reb)[name.c_str()]->phi(), weight);
          (m_MET_Reb_sum[type]).at(8)->Fill((*met_Reb)[name.c_str()]->sumet()/1000., weight);
        }
      }
 
      //Fill MET Angles
      ATH_MSG_INFO( "  MET_Angles :" );
 
      double leadPt = 0., subleadPt = 0., leadPhi = 0., subleadPhi = 0.;
 
      for (auto jet_itr = jets->begin(); jet_itr != jets->end(); ++jet_itr) {
        if ((*jet_itr)->pt() > leadPt && Accept(*jet_itr,JvtCut,jvtTool)) {
          subleadPt = leadPt;
          subleadPhi = leadPhi;
          leadPt = (*jet_itr)->pt();
          leadPhi = (*jet_itr)->phi();
        }
        else if ((*jet_itr)->pt() > subleadPt && Accept(*jet_itr,JvtCut,jvtTool)) {
          subleadPt = (*jet_itr)->pt();
          subleadPhi = (*jet_itr)->phi();
        }
      }
 
      if(m_doMETRefPlots){
        (m_MET_dPhi_Ref[type]).at(0)->Fill( -remainder( leadPhi - (*met_Ref)["FinalClus"]->phi(), 2*M_PI ), weight );
        (m_MET_dPhi_Ref[type]).at(1)->Fill( -remainder( subleadPhi - (*met_Ref)["FinalClus"]->phi(), 2*M_PI ), weight );
        (m_MET_dPhi_Ref[type]).at(3)->Fill( -remainder( leadPhi - (*met_Ref)["FinalTrk"]->phi(), 2*M_PI ), weight );
        (m_MET_dPhi_Ref[type]).at(4)->Fill( -remainder( subleadPhi - (*met_Ref)["FinalTrk"]->phi(), 2*M_PI ), weight );
      }
 
      (m_MET_dPhi_Reb[type]).at(0)->Fill( -remainder( leadPhi - (*met_Reb)["FinalClus"]->phi(), 2*M_PI ), weight );
      (m_MET_dPhi_Reb[type]).at(1)->Fill( -remainder( subleadPhi - (*met_Reb)["FinalClus"]->phi(), 2*M_PI ), weight );
      (m_MET_dPhi_Reb[type]).at(3)->Fill( -remainder( leadPhi - (*met_Reb)["FinalTrk"]->phi(), 2*M_PI ), weight );
      (m_MET_dPhi_Reb[type]).at(4)->Fill( -remainder( subleadPhi - (*met_Reb)["FinalTrk"]->phi(), 2*M_PI ), weight );
  
      leadPt = 0.; leadPhi = 0.;
 
      xAOD::MuonContainer::const_iterator muon_itr = muons->begin();
      xAOD::MuonContainer::const_iterator muon_end = muons->end();
 
      for( ; muon_itr != muon_end; ++muon_itr ) {
        if((*muon_itr)->pt() > leadPt) {
          leadPt = (*muon_itr)->pt();
          leadPhi = (*muon_itr)->phi();
        }
      }
 
      xAOD::ElectronContainer::const_iterator electron_itr = electrons->begin();
      xAOD::ElectronContainer::const_iterator electron_end = electrons->end();
 
      for( ; electron_itr != electron_end; ++electron_itr ) {
        if((*electron_itr)->pt() > leadPt) {
          leadPt = (*electron_itr)->pt();
          leadPhi = (*electron_itr)->phi();
        }
      }
 
      (m_MET_dPhi_Reb[type]).at(2)->Fill( -remainder( leadPhi - (*met_Reb)["FinalClus"]->phi(), 2*M_PI ), weight );
      (m_MET_dPhi_Reb[type]).at(5)->Fill( -remainder( leadPhi - (*met_Reb)["FinalTrk"]->phi(), 2*M_PI ), weight );
 
      if(m_doMETRefPlots){
 
        (m_MET_dPhi_Ref[type]).at(2)->Fill( -remainder( leadPhi - (*met_Ref)["FinalClus"]->phi(), 2*M_PI ), weight );
        (m_MET_dPhi_Ref[type]).at(5)->Fill( -remainder( leadPhi - (*met_Ref)["FinalTrk"]->phi(), 2*M_PI ), weight );
        
        //Fill Correlation Plots
        //Reference
        for(const auto it : *met_Ref) {
          const std::string& name = it->name();
          if(name == "RefEle"){
            (m_MET_CorrFinalTrk_Ref[type]).at(0)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
            (m_MET_CorrFinalClus_Ref[type]).at(0)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
          }
          if(name == "RefGamma"){
            (m_MET_CorrFinalTrk_Ref[type]).at(1)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
            (m_MET_CorrFinalClus_Ref[type]).at(1)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
          }
          if(name == "RefTau"){
            (m_MET_CorrFinalTrk_Ref[type]).at(2)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
            (m_MET_CorrFinalClus_Ref[type]).at(2)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
          }
          if(name == "Muons"){
            (m_MET_CorrFinalTrk_Ref[type]).at(3)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
            (m_MET_CorrFinalClus_Ref[type]).at(3)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
          }
          if(name == "RefJet"){
            (m_MET_CorrFinalTrk_Ref[type]).at(4)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
            (m_MET_CorrFinalClus_Ref[type]).at(4)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
          }
          if(name == "PVSoftTrk"){
            (m_MET_CorrFinalTrk_Ref[type]).at(5)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalTrk"]->met()/1000., weight);
          }
          if(name == "SoftClus"){
            (m_MET_CorrFinalClus_Ref[type]).at(5)->Fill((*met_Ref)[name.c_str()]->met()/1000.,(*met_Ref)["FinalClus"]->met()/1000., weight);
          }
        }
      }
 
      //Rebuilt
 
      for(const auto it : *met_Reb) {
        std::string name = it->name();
        if(name == "RefEle"){
          (m_MET_CorrFinalTrk_Reb[type]).at(0)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
          (m_MET_CorrFinalClus_Reb[type]).at(0)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
        }
        if(name == "RefGamma"){
          (m_MET_CorrFinalTrk_Reb[type]).at(1)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
          (m_MET_CorrFinalClus_Reb[type]).at(1)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
        }
        if(name == "RefTau"){
          (m_MET_CorrFinalTrk_Reb[type]).at(2)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
          (m_MET_CorrFinalClus_Reb[type]).at(2)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
        }
        if(name == "Muons"){
          (m_MET_CorrFinalTrk_Reb[type]).at(3)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
          (m_MET_CorrFinalClus_Reb[type]).at(3)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
        }
        if(name == "RefJet"){
          (m_MET_CorrFinalTrk_Reb[type]).at(4)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
          (m_MET_CorrFinalClus_Reb[type]).at(4)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
        }
        if(name == "PVSoftTrk"){
          (m_MET_CorrFinalTrk_Reb[type]).at(5)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalTrk"]->met()/1000., weight);
        }
        if(name == "SoftClus"){
          (m_MET_CorrFinalClus_Reb[type]).at(5)->Fill((*met_Reb)[name.c_str()]->met()/1000.,(*met_Reb)["FinalClus"]->met()/1000., weight);
        }
      }
 
      // Fill Resolution
      if(m_doTruth){
        ATH_MSG_INFO( "  Resolution:" );
        if(m_doMETRefPlots){
          (m_MET_Resolution_Ref[type]).at(0)->Fill(((*met_Ref)["FinalClus"]->mpx()-(*met_Truth)["NonInt"]->mpx())/1000., weight);
          (m_MET_Resolution_Ref[type]).at(1)->Fill(((*met_Ref)["FinalClus"]->mpy()-(*met_Truth)["NonInt"]->mpy())/1000., weight);
          (m_MET_Resolution_Ref[type]).at(2)->Fill(((*met_Ref)["FinalTrk"]->mpx()-(*met_Truth)["NonInt"]->mpx())/1000., weight);
          (m_MET_Resolution_Ref[type]).at(3)->Fill(((*met_Ref)["FinalTrk"]->mpy()-(*met_Truth)["NonInt"]->mpy())/1000., weight);
        }
        (m_MET_Resolution_Reb[type]).at(0)->Fill(((*met_Reb)["FinalClus"]->mpx()-(*met_Truth)["NonInt"]->mpx())/1000., weight);
        (m_MET_Resolution_Reb[type]).at(1)->Fill(((*met_Reb)["FinalClus"]->mpy()-(*met_Truth)["NonInt"]->mpy())/1000., weight);
        (m_MET_Resolution_Reb[type]).at(2)->Fill(((*met_Reb)["FinalTrk"]->mpx()-(*met_Truth)["NonInt"]->mpx())/1000., weight);
        (m_MET_Resolution_Reb[type]).at(3)->Fill(((*met_Reb)["FinalTrk"]->mpy()-(*met_Truth)["NonInt"]->mpy())/1000., weight);
      }
 
      //Fill MET significance
      if( (*met_Reb)["FinalClus"]->sumet() != 0) (m_MET_Significance_Reb[type]).at(0)->Fill((*met_Reb)["FinalClus"]->met()/sqrt((*met_Reb)["FinalClus"]->sumet()*1000.), weight);
      if( (*met_Reb)["FinalTrk"]->sumet() != 0) (m_MET_Significance_Reb[type]).at(1)->Fill((*met_Reb)["FinalTrk"]->met()/sqrt((*met_Reb)["FinalTrk"]->sumet()*1000.), weight);
 
      TLorentzVector target_tlv;
      if(m_doMETRefPlots){
        //Fill MET Significance
        ATH_MSG_INFO( "  MET_significance:" );
        if( (*met_Ref)["FinalClus"]->sumet() != 0) (m_MET_Significance_Ref[type]).at(0)->Fill((*met_Ref)["FinalClus"]->met()/sqrt((*met_Ref)["FinalClus"]->sumet()*1000.), weight);
        if( (*met_Ref)["FinalTrk"]->sumet() != 0) (m_MET_Significance_Ref[type]).at(1)->Fill((*met_Ref)["FinalTrk"]->met()/sqrt((*met_Ref)["FinalTrk"]->sumet()*1000.), weight);
        
        //Fill Diff histograms
        for(const auto it : *met_Ref) {
          if(it->name() == "RefEle"){
            if(is_electron or (it->sumet() > 0)){
              target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
              (m_MET_Diff_Ref[type]).at(0)->Fill((target_tlv.Pt() - el_tlv.Pt())/1000., weight);
              (m_MET_Diff_Ref_x[type]).at(0)->Fill((target_tlv.Px() - el_tlv.Px())/1000., weight);
              (m_MET_Diff_Ref_y[type]).at(0)->Fill((target_tlv.Py() - el_tlv.Py())/1000., weight);
              (m_MET_Diff_Ref_phi[type]).at(0)->Fill(el_tlv.DeltaPhi(target_tlv), weight);
              (m_MET_Diff_Ref_sum[type]).at(0)->Fill((it->sumet() - sum_el)/1000., weight);
            }
          }
          if(it->name() == "RefGamma"){
            if(is_photon or (it->sumet() > 0)){
              target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
              (m_MET_Diff_Ref[type]).at(1)->Fill((target_tlv.Pt() - photon_tlv.Pt())/1000., weight);
              (m_MET_Diff_Ref_x[type]).at(1)->Fill((target_tlv.Px() - photon_tlv.Px())/1000., weight);
              (m_MET_Diff_Ref_y[type]).at(1)->Fill((target_tlv.Py() - photon_tlv.Py())/1000., weight);
              (m_MET_Diff_Ref_phi[type]).at(1)->Fill(photon_tlv.DeltaPhi(target_tlv), weight);
              (m_MET_Diff_Ref_sum[type]).at(1)->Fill((it->sumet() - sum_photon)/1000., weight);
            }
          }
          if(it->name() == "RefTau"){
            if(is_tau or (it->sumet() > 0)){
              target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
              (m_MET_Diff_Ref[type]).at(2)->Fill((target_tlv.Pt() - tau_tlv.Pt())/1000., weight);
              (m_MET_Diff_Ref_x[type]).at(2)->Fill((target_tlv.Px() - tau_tlv.Px())/1000., weight);
              (m_MET_Diff_Ref_y[type]).at(2)->Fill((target_tlv.Py() - tau_tlv.Py())/1000., weight);
              (m_MET_Diff_Ref_phi[type]).at(2)->Fill(tau_tlv.DeltaPhi(target_tlv), weight);
              (m_MET_Diff_Ref_sum[type]).at(2)->Fill((it->sumet() - sum_tau)/1000., weight);
            }
          }
          if(it->name() == "Muons"){
            if(is_muon or (it->sumet() > 0)){
              target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
              (m_MET_Diff_Ref[type]).at(3)->Fill((target_tlv.Pt() - mu_tlv.Pt())/1000., weight);
              (m_MET_Diff_Ref_x[type]).at(3)->Fill((target_tlv.Px() - mu_tlv.Px())/1000., weight);
              (m_MET_Diff_Ref_y[type]).at(3)->Fill((target_tlv.Py() - mu_tlv.Py())/1000., weight);
              (m_MET_Diff_Ref_phi[type]).at(3)->Fill(mu_tlv.DeltaPhi(target_tlv), weight);
              (m_MET_Diff_Ref_sum[type]).at(3)->Fill((it->sumet() - sum_mu)/1000., weight);
            }
          }
          if(it->name() == "RefJet"){
            if(is_jet or (it->sumet() > 0)){
              target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
              (m_MET_Diff_Ref[type]).at(4)->Fill((target_tlv.Pt() - jet_tlv.Pt())/1000., weight);
              (m_MET_Diff_Ref_x[type]).at(4)->Fill((target_tlv.Px() - jet_tlv.Px())/1000., weight);
              (m_MET_Diff_Ref_y[type]).at(4)->Fill((target_tlv.Py() - jet_tlv.Py())/1000., weight);
              (m_MET_Diff_Ref_phi[type]).at(4)->Fill(jet_tlv.DeltaPhi(target_tlv), weight);
              (m_MET_Diff_Ref_sum[type]).at(4)->Fill((it->sumet() - sum_jet)/1000., weight);
            }
          }
        }
      }
 
      // For rebuilt MET add only jets with pT>20e3 and JVT cut
      TLorentzVector jetReb_tlv;
      double sum_jetReb = 0;
      for(const auto jet : metJetsOR) {
        if(Accept(jet, JvtCut, jvtTool)) {
          jetReb_tlv += jet->p4();
          sum_jetReb += jet->pt();
        }
      }
 
      for(const auto it : *met_Reb) {
        if(it->name() == "RefEle"){
          if(is_electron or (it->sumet() > 0)){
            target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
            (m_MET_Diff_Reb[type]).at(0)->Fill((target_tlv.Pt() - el_tlv.Pt())/1000., weight);
            (m_MET_Diff_Reb_x[type]).at(0)->Fill((target_tlv.Px() - el_tlv.Px())/1000., weight);
            (m_MET_Diff_Reb_y[type]).at(0)->Fill((target_tlv.Py() - el_tlv.Py())/1000., weight);
            (m_MET_Diff_Reb_phi[type]).at(0)->Fill(el_tlv.DeltaPhi(target_tlv), weight);
            (m_MET_Diff_Reb_sum[type]).at(0)->Fill((it->sumet() - sum_el)/1000., weight);
          }
        }
        if(it->name() == "RefGamma"){
          if(is_photon or (it->sumet() > 0)){
            target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
            (m_MET_Diff_Reb[type]).at(1)->Fill((target_tlv.Pt() - photon_tlv.Pt())/1000., weight);
            (m_MET_Diff_Reb_x[type]).at(1)->Fill((target_tlv.Px() - photon_tlv.Px())/1000., weight);
            (m_MET_Diff_Reb_y[type]).at(1)->Fill((target_tlv.Py() - photon_tlv.Py())/1000., weight);
            (m_MET_Diff_Reb_phi[type]).at(1)->Fill(photon_tlv.DeltaPhi(target_tlv), weight);
            (m_MET_Diff_Reb_sum[type]).at(1)->Fill((it->sumet() - sum_photon)/1000., weight);
          }
        }
        if(it->name() == "RefTau"){
          if(is_tau or (it->sumet() > 0)){
            target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
            (m_MET_Diff_Reb[type]).at(2)->Fill((target_tlv.Pt() - tau_tlv.Pt())/1000., weight);
            (m_MET_Diff_Reb_x[type]).at(2)->Fill((target_tlv.Px() - tau_tlv.Px())/1000., weight);
            (m_MET_Diff_Reb_y[type]).at(2)->Fill((target_tlv.Py() - tau_tlv.Py())/1000., weight);
            (m_MET_Diff_Reb_phi[type]).at(2)->Fill(tau_tlv.DeltaPhi(target_tlv), weight);
            (m_MET_Diff_Reb_sum[type]).at(2)->Fill((it->sumet() - sum_tau)/1000., weight);
          }
        }
        if(it->name() == "Muons"){
          if(is_muon or (it->sumet() > 0)){
            target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
            (m_MET_Diff_Reb[type]).at(3)->Fill((target_tlv.Pt() - mu_tlv.Pt())/1000., weight);
            (m_MET_Diff_Reb_x[type]).at(3)->Fill((target_tlv.Px() - mu_tlv.Px())/1000., weight);
            (m_MET_Diff_Reb_y[type]).at(3)->Fill((target_tlv.Py() - mu_tlv.Py())/1000., weight);
            (m_MET_Diff_Reb_phi[type]).at(3)->Fill(mu_tlv.DeltaPhi(target_tlv), weight);
            (m_MET_Diff_Reb_sum[type]).at(3)->Fill((it->sumet() - sum_mu)/1000., weight);
          }
        }
        if(it->name() == "RefJet"){
          if(is_jet or (it->sumet() > 0)){
            target_tlv.SetPxPyPzE(-it->mpx(), -it->mpy(), 0, it->met());
            (m_MET_Diff_Reb[type]).at(4)->Fill((target_tlv.Pt() - jetReb_tlv.Pt())/1000., weight);
            (m_MET_Diff_Reb_x[type]).at(4)->Fill((target_tlv.Px() - jetReb_tlv.Px())/1000., weight);
            (m_MET_Diff_Reb_y[type]).at(4)->Fill((target_tlv.Py() - jetReb_tlv.Py())/1000., weight);
            (m_MET_Diff_Reb_phi[type]).at(4)->Fill(jetReb_tlv.DeltaPhi(target_tlv), weight);
            (m_MET_Diff_Reb_sum[type]).at(4)->Fill((it->sumet() - sum_jetReb)/1000., weight);
          }
        }
      }
 
      if(type == "AntiKt4EMTopo") {
        //Calo MET
        //const xAOD::JetContainer* emptyjets = 0;
        ConstDataVector<JetContainer> metJetsEmpty(SG::VIEW_ELEMENTS);
        MissingETContainer* met_Calo = new MissingETContainer();
        if( evtStore()->record(met_Calo,("MET_Calo"+type).c_str()).isFailure() ) {
          ATH_MSG_WARNING("Unable to record MissingETContainer: MET_Calo_" << type);
          return StatusCode::FAILURE;
        }
        MissingETAuxContainer* met_CaloAux = new MissingETAuxContainer();
        if( evtStore()->record(met_CaloAux,("MET_Calo"+type+"Aux").c_str()).isFailure() ) {
          ATH_MSG_WARNING("Unable to record MissingETAuxContainer: MET_Calo" << type);
          return StatusCode::FAILURE;
        }
        met_Calo->setStore(met_CaloAux);
        MissingETAssociationHelper metHelper(metMap);
        if( (*m_metmaker)->rebuildJetMET("RefJet", "SoftClus", "PVSoftTrk", met_Calo, metJetsEmpty.asDataVector(), coreMet, metHelper, true).isFailure() ) {
          ATH_MSG_WARNING("Failed to build jet and soft terms.");
        }
        
        if((*met_Calo)["SoftClus"]) clsource = (*met_Calo)["SoftClus"]->source();
        if( met::buildMETSum("FinalClus", met_Calo, clsource).isFailure() ) {
          ATH_MSG_WARNING("Building MET FinalClus sum failed.");
        }
        
        m_MET_Calo->Fill((*met_Calo)["FinalClus"]->met()/1000., weight);
        m_MET_Calo_x->Fill((*met_Calo)["FinalClus"]->mpx()/1000., weight);
        m_MET_Calo_y->Fill((*met_Calo)["FinalClus"]->mpy()/1000., weight);
        m_MET_Calo_phi->Fill((*met_Calo)["FinalClus"]->phi(), weight);
        m_MET_Calo_sum->Fill((*met_Calo)["FinalClus"]->sumet()/1000., weight);
 
      }
 
    }
 
    //Currently we don't store MET_Track in the derivations
    //if MET_Ref not present, then we also dont have MET_Track
    if(m_doMETRefPlots){
 
      //Retrieve MET Track
      const xAOD::MissingETContainer* met_Track = nullptr;
      ATH_CHECK( evtStore()->retrieve(met_Track,"MET_Track") );
      if (!met_Track) {
        ATH_MSG_ERROR ( "Failed to retrieve MET_Track. Exiting." );
        return StatusCode::FAILURE;
      }
 
      // Fill MET Track
      ATH_MSG_INFO( "  MET_Track:" );
      
      m_MET_Track->Fill((*met_Track)["Track"]->met()/1000., weight);
      m_MET_Track_x->Fill((*met_Track)["Track"]->mpx()/1000., weight);
      m_MET_Track_y->Fill((*met_Track)["Track"]->mpy()/1000., weight);
      m_MET_Track_phi->Fill((*met_Track)["Track"]->phi(), weight);
      m_MET_Track_sum->Fill((*met_Track)["Track"]->sumet()/1000., weight);
      
      const xAOD::VertexContainer *vxCont = nullptr;
      ATH_CHECK( evtStore()->retrieve(vxCont, "PrimaryVertices") );
      for(const auto vx : *vxCont) {
        int N = vx->index();
        const std::string name = "PVTrack_vx"+std::to_string(N);
        if(vx->vertexType()!=xAOD::VxType::NoVtx) {
          if(vx->vertexType()==xAOD::VxType::PriVtx) {
            m_MET_PVTrack_Nominal->Fill((*met_Track)[name]->met()/1000., weight);
            m_MET_PVTrack_Nominal_x->Fill((*met_Track)[name]->mpx()/1000., weight);
            m_MET_PVTrack_Nominal_y->Fill((*met_Track)[name]->mpy()/1000., weight);
            m_MET_PVTrack_Nominal_phi->Fill((*met_Track)[name]->phi(), weight);
            m_MET_PVTrack_Nominal_sum->Fill((*met_Track)[name]->sumet()/1000., weight);
          } else { 
            m_MET_PVTrack_Pileup->Fill((*met_Track)[name]->met()/1000., weight);
            m_MET_PVTrack_Pileup_x->Fill((*met_Track)[name]->mpx()/1000., weight);
            m_MET_PVTrack_Pileup_y->Fill((*met_Track)[name]->mpy()/1000., weight);
            m_MET_PVTrack_Pileup_phi->Fill((*met_Track)[name]->phi(), weight);
            m_MET_PVTrack_Pileup_sum->Fill((*met_Track)[name]->sumet()/1000., weight);
          }
        }
      }
    }
 
   return StatusCode::SUCCESS;
   //return StatusCode::FAILURE;
  }

fillHists()

StatusCode ManagedMonitorToolBase::fillHists ( )

virtualinherited

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

Implements IMonitorToolBase.

Reimplemented in TileDigitsMonTool, and TileRawChannelMonTool.

Definition at line 739 of file ManagedMonitorToolBase.cxx.

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

finalHists()

StatusCode ManagedMonitorToolBase::finalHists ( )

virtualinherited

Calls procHists( true, true, true ).

Implements IMonitorToolBase.

Reimplemented in TileCellNoiseMonTool, TileDigitsMonTool, and TileRawChannelMonTool.

Definition at line 1254 of file ManagedMonitorToolBase.cxx.

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

get_nEvents()

unsigned int ManagedMonitorToolBase::get_nEvents ( ) const

inlineprotectedinherited

Definition at line 692 of file ManagedMonitorToolBase.h.

                                              {
          return m_nEvents; 
      }

get_procNEventsProp()

long ManagedMonitorToolBase::get_procNEventsProp ( ) const

inlineprotectedinherited

Definition at line 696 of file ManagedMonitorToolBase.h.

                                              {
          return m_procNEventsProp;
      }

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 1417 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 1407 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 1436 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 1426 of file ManagedMonitorToolBase.cxx.

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

getNewStreamNameFcn()

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

protectedvirtualinherited

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

initialize()

StatusCode MissingEtDQA::PhysValMET::initialize ( )

virtual

Reimplemented from ManagedMonitorToolBase.

Definition at line 115 of file PhysValMET.cxx.

  {
    ATH_MSG_INFO ("Initializing " << name() << "...");    
    ATH_CHECK(ManagedMonitorToolBase::initialize());
 
    m_names.clear();
    m_names["RefEle"] = "Electron term";
    m_names["RefGamma"] = "Photon term";
    m_names["RefTau"] = "Tau term";
    m_names["Muons"] = "Muon term";
    m_names["RefJet"] = "Jet term";
    m_names["SoftClus"] = "Cluster-based soft term";
    m_names["PVSoftTrk"] = "Track-based soft term (PV-matched)";
    m_names["FinalTrk"] = "Total MET with TST";
    m_names["FinalClus"] = "Total MET with CST";
    m_names["Track"] = "Track MET, loose selection";
    m_names["PVTrack_Nominal"] = "Track MET for highest sum p_{T}^{2} PV";
    m_names["PVTrack_Pileup"] = "Track MET for each pileup vertex";
 
    m_types.clear();
    m_types.emplace_back("AntiKt4EMTopo");
    m_types.emplace_back("AntiKt4EMPFlow");
 
    m_terms.clear();
    m_terms.emplace_back("RefEle");
    m_terms.emplace_back("RefGamma");
    m_terms.emplace_back("RefTau");
    m_terms.emplace_back("Muons");
    m_terms.emplace_back("RefJet");
    m_terms.emplace_back("SoftClus");
    m_terms.emplace_back("PVSoftTrk");
    m_terms.emplace_back("FinalTrk");
    m_terms.emplace_back("FinalClus");
 
    ATH_MSG_INFO("Retrieving tools...");
 
    ATH_CHECK( m_metmakerTopo.retrieve() ); 
    ATH_CHECK( m_metmakerPFlow.retrieve() );
    ATH_CHECK( m_muonSelTool.retrieve() );
    ATH_CHECK( m_elecSelLHTool.retrieve() );
    ATH_CHECK( m_photonSelIsEMTool.retrieve() );
    ATH_CHECK( m_tauSelTool.retrieve() );
    ATH_CHECK( m_jvtToolEM.retrieve() );
    ATH_CHECK( m_jvtToolPFlow.retrieve() );
    m_MET_Ref.clear();
    m_MET_Ref_x.clear();
    m_MET_Ref_y.clear();
    m_MET_Ref_phi.clear();
    m_MET_Ref_sum.clear();
    m_MET_Diff_Ref.clear();
    m_MET_Diff_Ref_x.clear();
    m_MET_Diff_Ref_y.clear();
    m_MET_Diff_Ref_phi.clear();
    m_MET_Diff_Ref_sum.clear();
    m_MET_Cumu_Ref.clear();
    m_MET_Resolution_Ref.clear();
    m_MET_Significance_Ref.clear();
    m_MET_dPhi_Ref.clear();
    m_MET_CorrFinalTrk_Ref.clear();
    m_MET_CorrFinalClus_Ref.clear();
    m_MET_Reb.clear();
    m_MET_Reb_x.clear();
    m_MET_Reb_y.clear();
    m_MET_Reb_phi.clear();
    m_MET_Reb_sum.clear();
    m_MET_Diff_Reb.clear();
    m_MET_Diff_Reb_x.clear();
    m_MET_Diff_Reb_y.clear();
    m_MET_Diff_Reb_phi.clear();
    m_MET_Diff_Reb_sum.clear();
    m_MET_Cumu_Reb.clear();
    m_MET_Resolution_Reb.clear();
    m_MET_Significance_Reb.clear();
    m_MET_dPhi_Reb.clear();
    m_MET_CorrFinalTrk_Reb.clear();
    m_MET_CorrFinalClus_Reb.clear();
    
    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 29 of file IMonitorToolBase.h.

{ return IID_IMonitorToolBase; }

intervalEnumToString()

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

staticinherited

Converts a LevelOfDetail_t to a string of the same name.

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

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

lbAverageInteractionsPerCrossing()

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

virtualinherited

Average mu, i.e.

<mu>

Definition at line 1691 of file ManagedMonitorToolBase.cxx.

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

lbAverageLivefraction()

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

virtualinherited

Average luminosity livefraction.

Definition at line 1760 of file ManagedMonitorToolBase.cxx.

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

lbAverageLuminosity()

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

virtualinherited

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

Definition at line 1727 of file ManagedMonitorToolBase.cxx.

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

lbDuration()

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

virtualinherited

Luminosity block time (in seconds)

Definition at line 1814 of file ManagedMonitorToolBase.cxx.

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

lbInteractionsPerCrossing()

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

virtualinherited

Instantaneous number of interactions, i.e.

mu

Definition at line 1707 of file ManagedMonitorToolBase.cxx.

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

lbLuminosityPerBCID()

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

virtualinherited

Instantaneous luminosity.

Definition at line 1743 of file ManagedMonitorToolBase.cxx.

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

lbLumiWeight()

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

virtualinherited

Average Integrated Luminosity Live Fraction.

Definition at line 1798 of file ManagedMonitorToolBase.cxx.

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

livefractionPerBCID()

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

virtualinherited

Livefraction per bunch crossing ID.

Definition at line 1779 of file ManagedMonitorToolBase.cxx.

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

MMTB_DEPRECATED() [1/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfEventsBlock )

inherited

MMTB_DEPRECATED() [2/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLowStat )

inherited

MMTB_DEPRECATED() [3/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfLumiBlock )

inherited

MMTB_DEPRECATED() [4/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( endOfRun )

inherited

MMTB_DEPRECATED() [5/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newEventsBlock )

inherited

MMTB_DEPRECATED() [6/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newHigStatInterval )

inherited

MMTB_DEPRECATED() [7/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStat )

inherited

MMTB_DEPRECATED() [8/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLowStatInterval )

inherited

MMTB_DEPRECATED() [9/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newLumiBlock )

inherited

MMTB_DEPRECATED() [10/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newMedStatInterval )

inherited

MMTB_DEPRECATED() [11/11]

ManagedMonitorToolBase::MMTB_DEPRECATED ( newRun )

inherited

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

{ return m_newEventsBlock; }

newHigStatIntervalFlag()

bool ManagedMonitorToolBase::newHigStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 789 of file ManagedMonitorToolBase.h.

{ return m_newHigStatInterval; }

newLowStatFlag()

bool ManagedMonitorToolBase::newLowStatFlag ( ) const

inlineprotectedinherited

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

{ return m_newLowStatInterval; }

newLumiBlockFlag()

bool ManagedMonitorToolBase::newLumiBlockFlag ( ) const

inlineprotectedinherited

Definition at line 791 of file ManagedMonitorToolBase.h.

{ return m_newLumiBlock; }

newMedStatIntervalFlag()

bool ManagedMonitorToolBase::newMedStatIntervalFlag ( ) const

inlineprotectedinherited

Definition at line 788 of file ManagedMonitorToolBase.h.

{ return m_newMedStatInterval; }

newRunFlag()

bool ManagedMonitorToolBase::newRunFlag ( ) const

inlineprotectedinherited

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

preSelector()

bool ManagedMonitorToolBase::preSelector ( )

virtualinherited

Implements IMonitorToolBase.

Definition at line 1679 of file ManagedMonitorToolBase.cxx.

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

procHistograms()

StatusCode MissingEtDQA::PhysValMET::procHistograms ( )

virtual

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

Reimplemented from ManagedMonitorToolBase.

Definition at line 1370 of file PhysValMET.cxx.

  {
    ATH_MSG_INFO ("Finalising hists " << name() << "...");
 
    for (const auto& type : m_types){
      for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Reb[type]).size(); ++i) {
        if (m_doMETRefPlots){
          (m_MET_Ref[type]).at(i)->Sumw2();
          (m_MET_Ref_x[type]).at(i)->Sumw2();
          (m_MET_Ref_y[type]).at(i)->Sumw2();
          (m_MET_Ref_phi[type]).at(i)->Sumw2();
          (m_MET_Ref_sum[type]).at(i)->Sumw2();
        }
        (m_MET_Reb[type]).at(i)->Sumw2();
        (m_MET_Reb_x[type]).at(i)->Sumw2();
        (m_MET_Reb_y[type]).at(i)->Sumw2();
        (m_MET_Reb_phi[type]).at(i)->Sumw2();
        (m_MET_Reb_sum[type]).at(i)->Sumw2();
      }
  
      for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Diff_Reb[type]).size(); ++i) {
        if (m_doMETRefPlots){
          (m_MET_Diff_Ref[type]).at(i)->Sumw2();
          (m_MET_Diff_Ref_x[type]).at(i)->Sumw2();
          (m_MET_Diff_Ref_y[type]).at(i)->Sumw2();
          (m_MET_Diff_Ref_phi[type]).at(i)->Sumw2();
          (m_MET_Diff_Ref_sum[type]).at(i)->Sumw2();
        }
        (m_MET_Diff_Reb[type]).at(i)->Sumw2();
        (m_MET_Diff_Reb_x[type]).at(i)->Sumw2();
        (m_MET_Diff_Reb_y[type]).at(i)->Sumw2();
        (m_MET_Diff_Reb_phi[type]).at(i)->Sumw2();
        (m_MET_Diff_Reb_sum[type]).at(i)->Sumw2();
      }
 
      for(std::vector<TH2D*>::size_type i = 0; i < (m_MET_CorrFinalTrk_Reb[type]).size(); ++i) {
        if (m_doMETRefPlots){
          (m_MET_CorrFinalTrk_Ref[type]).at(i)->Sumw2();
        }
        (m_MET_CorrFinalTrk_Reb[type]).at(i)->Sumw2();
      }
 
      for(std::vector<TH2D*>::size_type i = 0; i < (m_MET_CorrFinalClus_Reb[type]).size(); ++i) {
        if (m_doMETRefPlots){
          (m_MET_CorrFinalClus_Ref[type]).at(i)->Sumw2();
        }
        (m_MET_CorrFinalClus_Reb[type]).at(i)->Sumw2();
      }
 
      for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Significance_Reb[type]).size(); ++i) {
        if (m_doMETRefPlots){
          (m_MET_Significance_Ref[type]).at(i)->Sumw2();
        }
        (m_MET_Significance_Reb[type]).at(i)->Sumw2();
      }
  
      for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Resolution_Reb[type]).size(); ++i) { 
        if (m_doMETRefPlots){
         (m_MET_Resolution_Ref[type]).at(i)->Sumw2();
        }
       (m_MET_Resolution_Reb[type]).at(i)->Sumw2();
      }
  
      for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_dPhi_Ref[type]).size(); ++i) {
        if (m_doMETRefPlots){
          (m_MET_dPhi_Ref[type]).at(i)->Sumw2();
        }
        (m_MET_dPhi_Reb[type]).at(i)->Sumw2();
      }
  
      int nBins = (m_MET_Reb[type]).at(7)->GetNbinsX();
      for(int i=1;i<=nBins;i++){
        double err;
        if (m_doMETRefPlots){
          (m_MET_Cumu_Ref[type]).at(0)->SetBinContent(i, (m_MET_Ref[type]).at(8)->IntegralAndError(i,nBins+1,err));
          (m_MET_Cumu_Ref[type]).at(0)->SetBinError(i, err);
          (m_MET_Cumu_Ref[type]).at(1)->SetBinContent(i, (m_MET_Ref[type]).at(7)->IntegralAndError(i,nBins+1,err));
          (m_MET_Cumu_Ref[type]).at(1)->SetBinError(i, err);
        }
        (m_MET_Cumu_Reb[type]).at(0)->SetBinContent(i, (m_MET_Reb[type]).at(8)->IntegralAndError(i,nBins+1,err));
        (m_MET_Cumu_Reb[type]).at(0)->SetBinError(i, err);
        (m_MET_Cumu_Reb[type]).at(1)->SetBinContent(i, (m_MET_Reb[type]).at(7)->IntegralAndError(i,nBins+1,err));
        (m_MET_Cumu_Reb[type]).at(1)->SetBinError(i, err);
      }
      for(std::vector<TH1D*>::size_type i = 0; i < (m_MET_Cumu_Ref[type]).size(); ++i) {
        if (m_doMETRefPlots){
          m_MET_Cumu_Ref[type].at(i)->Scale(1./(m_MET_Cumu_Ref[type]).at(i)->GetBinContent(1));
        }
        m_MET_Cumu_Reb[type].at(i)->Scale(1./(m_MET_Cumu_Reb[type]).at(i)->GetBinContent(1));
      }
 
    }
 
    if (m_doMETRefPlots){
      m_MET_Track->Sumw2();
      m_MET_Track_x->Sumw2();
      m_MET_Track_y->Sumw2();
      m_MET_Track_phi->Sumw2();
      m_MET_Track_sum->Sumw2();
      m_MET_PVTrack_Nominal->Sumw2();
      m_MET_PVTrack_Nominal_x->Sumw2();
      m_MET_PVTrack_Nominal_y->Sumw2();
      m_MET_PVTrack_Nominal_phi->Sumw2();
      m_MET_PVTrack_Nominal_sum->Sumw2();
      m_MET_PVTrack_Pileup->Sumw2();
      m_MET_PVTrack_Pileup_x->Sumw2();
      m_MET_PVTrack_Pileup_y->Sumw2();
      m_MET_PVTrack_Pileup_phi->Sumw2();
      m_MET_PVTrack_Pileup_sum->Sumw2();
    }
 
    m_MET_Calo->Sumw2();
    m_MET_Calo_x->Sumw2();
    m_MET_Calo_y->Sumw2();
    m_MET_Calo_phi->Sumw2();
    m_MET_Calo_sum->Sumw2();
 
    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 1444 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.

Reimplemented in TilePaterMonTool.

Definition at line 1498 of file ManagedMonitorToolBase.cxx.

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

regGraph() [2/2]

StatusCode ManagedMonitorToolBase::regGraph ( TGraph * g, const std::string & system, Interval_t interval, MgmtAttr_t histo_mgmt = ATTRIB_MANAGED, const std::string & chain = "", const std::string & merge = "" )

virtualinherited

Registers a TGraph to be included in the output stream using logical parameters that describe the graph.

Reimplemented in TilePaterMonTool.

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

Reimplemented in TilePaterMonTool.

Definition at line 1352 of file ManagedMonitorToolBase.cxx.

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

regHist() [2/2]

StatusCode ManagedMonitorToolBase::regHist ( TH1 * h, const std::string & system, Interval_t interval, MgmtAttr_t histo_mgmt = ATTRIB_MANAGED, const std::string & chain = "", const std::string & merge = "" )

virtualinherited

Registers a TH1 (including TH2, TH3, and TProfile) to be included in the output stream using logical parameters that describe the histogram.

Reimplemented in TilePaterMonTool.

Definition at line 1343 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 945 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 1139 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 1068 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 971 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 1199 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 1554 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 1544 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 1661 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 1325 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 1650 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 450 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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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 1036 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 2092 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 2130 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 1599 of file ManagedMonitorToolBase.cxx.

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

Member Data Documentation

m_bookHistogramsInitial

bool ManagedMonitorToolBase::m_bookHistogramsInitial

privateinherited

Definition at line 893 of file ManagedMonitorToolBase.h.

m_corename

std::string MissingEtDQA::PhysValMET::m_corename

private

Definition at line 95 of file PhysValMET.h.

m_d

Imp* ManagedMonitorToolBase::m_d

privateinherited

Definition at line 900 of file ManagedMonitorToolBase.h.

m_dataType

AthenaMonManager::DataType_t ManagedMonitorToolBase::m_dataType

protectedinherited

Definition at line 838 of file ManagedMonitorToolBase.h.

m_dataTypeStr

std::string ManagedMonitorToolBase::m_dataTypeStr

protectedinherited

Definition at line 834 of file ManagedMonitorToolBase.h.

m_defaultLBDuration

float ManagedMonitorToolBase::m_defaultLBDuration

privateinherited

Definition at line 895 of file ManagedMonitorToolBase.h.

m_detailLevel

unsigned int ManagedMonitorToolBase::m_detailLevel

protectedinherited

Definition at line 836 of file ManagedMonitorToolBase.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_dir_met

std::vector<std::string> MissingEtDQA::PhysValMET::m_dir_met

private

Definition at line 153 of file PhysValMET.h.

m_doMETRefPlots

bool MissingEtDQA::PhysValMET::m_doMETRefPlots

private

Definition at line 84 of file PhysValMET.h.

m_doTruth

bool MissingEtDQA::PhysValMET::m_doTruth

private

Definition at line 82 of file PhysValMET.h.

m_DQFilterTools

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

protectedinherited

Definition at line 849 of file ManagedMonitorToolBase.h.

{this,"FilterTools",{}};

m_eleColl

std::string MissingEtDQA::PhysValMET::m_eleColl

private

Definition at line 90 of file PhysValMET.h.

m_elecSelLHTool

ToolHandle<IAsgElectronLikelihoodTool> MissingEtDQA::PhysValMET::m_elecSelLHTool {this, "ElectronLHSelectionTool", "", "Electron likelihood selection tool"}

private

Definition at line 156 of file PhysValMET.h.

{this, "ElectronLHSelectionTool",  "", "Electron likelihood selection tool"};

m_endOfEventsBlock

bool ManagedMonitorToolBase::m_endOfEventsBlock

privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

m_endOfLowStat

bool ManagedMonitorToolBase::m_endOfLowStat

privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

m_endOfLumiBlock

bool ManagedMonitorToolBase::m_endOfLumiBlock

privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

m_endOfRun

bool ManagedMonitorToolBase::m_endOfRun

privateinherited

Definition at line 823 of file ManagedMonitorToolBase.h.

m_environment

AthenaMonManager::Environment_t ManagedMonitorToolBase::m_environment

protectedinherited

Definition at line 839 of file ManagedMonitorToolBase.h.

m_environmentStr

std::string ManagedMonitorToolBase::m_environmentStr

protectedinherited

Definition at line 835 of file ManagedMonitorToolBase.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_fileKey

std::string ManagedMonitorToolBase::m_fileKey

protectedinherited

Definition at line 833 of file ManagedMonitorToolBase.h.

m_gammaColl

std::string MissingEtDQA::PhysValMET::m_gammaColl

private

Definition at line 91 of file PhysValMET.h.

m_haveClearedLastEventBlock

bool ManagedMonitorToolBase::m_haveClearedLastEventBlock

protectedinherited

Definition at line 866 of file ManagedMonitorToolBase.h.

m_inputIsDAOD

bool MissingEtDQA::PhysValMET::m_inputIsDAOD

private

Definition at line 83 of file PhysValMET.h.

m_jvtToolEM

ToolHandle<IJetUpdateJvt> MissingEtDQA::PhysValMET::m_jvtToolEM {this, "JVTToolEMTopo", "", "JVT tool for EMTopo jets"}

private

Definition at line 158 of file PhysValMET.h.

{this, "JVTToolEMTopo",            "", "JVT tool for EMTopo jets"};

m_jvtToolPFlow

ToolHandle<IJetUpdateJvt> MissingEtDQA::PhysValMET::m_jvtToolPFlow {this, "JVTToolEMPFlow", "", "JVT tool forEMPFlow jets"}

private

Definition at line 159 of file PhysValMET.h.

{this, "JVTToolEMPFlow",           "", "JVT tool forEMPFlow jets"};

m_lastHigStatInterval

int ManagedMonitorToolBase::m_lastHigStatInterval

protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

m_lastLowStatInterval

int ManagedMonitorToolBase::m_lastLowStatInterval

protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

m_lastLumiBlock

unsigned int ManagedMonitorToolBase::m_lastLumiBlock

protectedinherited

Definition at line 859 of file ManagedMonitorToolBase.h.

m_lastMedStatInterval

int ManagedMonitorToolBase::m_lastMedStatInterval

protectedinherited

Definition at line 861 of file ManagedMonitorToolBase.h.

m_lastRun

unsigned int ManagedMonitorToolBase::m_lastRun

protectedinherited

Definition at line 860 of file ManagedMonitorToolBase.h.

m_lbDurationDataKey

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

privateinherited

Definition at line 888 of file ManagedMonitorToolBase.h.

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

m_lumiDataKey

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

privateinherited

Definition at line 886 of file ManagedMonitorToolBase.h.

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

m_manager

AthenaMonManager* ManagedMonitorToolBase::m_manager

protectedinherited

Definition at line 829 of file ManagedMonitorToolBase.h.

m_managerNameProp

std::string ManagedMonitorToolBase::m_managerNameProp

protectedinherited

Definition at line 831 of file ManagedMonitorToolBase.h.

m_mapname

std::string MissingEtDQA::PhysValMET::m_mapname

private

Definition at line 94 of file PhysValMET.h.

m_MET_Calo

TH1D* MissingEtDQA::PhysValMET::m_MET_Calo = nullptr

private

Definition at line 117 of file PhysValMET.h.

m_MET_Calo_phi

TH1D * MissingEtDQA::PhysValMET::m_MET_Calo_phi = nullptr

private

Definition at line 117 of file PhysValMET.h.

m_MET_Calo_sum

TH1D * MissingEtDQA::PhysValMET::m_MET_Calo_sum = nullptr

private

Definition at line 117 of file PhysValMET.h.

m_MET_Calo_x

TH1D * MissingEtDQA::PhysValMET::m_MET_Calo_x = nullptr

private

Definition at line 117 of file PhysValMET.h.

m_MET_Calo_y

TH1D * MissingEtDQA::PhysValMET::m_MET_Calo_y = nullptr

private

Definition at line 117 of file PhysValMET.h.

m_MET_CorrFinalClus_Reb

std::map<std::string,std::vector<TH2D*> > MissingEtDQA::PhysValMET::m_MET_CorrFinalClus_Reb

private

Definition at line 151 of file PhysValMET.h.

m_MET_CorrFinalClus_Ref

std::map<std::string,std::vector<TH2D*> > MissingEtDQA::PhysValMET::m_MET_CorrFinalClus_Ref

private

Definition at line 135 of file PhysValMET.h.

m_MET_CorrFinalTrk_Reb

std::map<std::string,std::vector<TH2D*> > MissingEtDQA::PhysValMET::m_MET_CorrFinalTrk_Reb

private

Definition at line 150 of file PhysValMET.h.

m_MET_CorrFinalTrk_Ref

std::map<std::string,std::vector<TH2D*> > MissingEtDQA::PhysValMET::m_MET_CorrFinalTrk_Ref

private

Definition at line 134 of file PhysValMET.h.

m_MET_Cumu_Reb

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Cumu_Reb

private

Definition at line 146 of file PhysValMET.h.

m_MET_Cumu_Ref

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Cumu_Ref

private

Definition at line 130 of file PhysValMET.h.

m_MET_Diff_Reb

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Reb

private

Definition at line 141 of file PhysValMET.h.

m_MET_Diff_Reb_phi

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Reb_phi

private

Definition at line 144 of file PhysValMET.h.

m_MET_Diff_Reb_sum

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Reb_sum

private

Definition at line 145 of file PhysValMET.h.

m_MET_Diff_Reb_x

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Reb_x

private

Definition at line 142 of file PhysValMET.h.

m_MET_Diff_Reb_y

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Reb_y

private

Definition at line 143 of file PhysValMET.h.

m_MET_Diff_Ref

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Ref

private

Definition at line 125 of file PhysValMET.h.

m_MET_Diff_Ref_phi

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Ref_phi

private

Definition at line 128 of file PhysValMET.h.

m_MET_Diff_Ref_sum

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Ref_sum

private

Definition at line 129 of file PhysValMET.h.

m_MET_Diff_Ref_x

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Ref_x

private

Definition at line 126 of file PhysValMET.h.

m_MET_Diff_Ref_y

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Diff_Ref_y

private

Definition at line 127 of file PhysValMET.h.

m_MET_dPhi_Reb

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_dPhi_Reb

private

Definition at line 149 of file PhysValMET.h.

m_MET_dPhi_Ref

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_dPhi_Ref

private

Definition at line 133 of file PhysValMET.h.

m_MET_PVTrack_Nominal

TH1D* MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal = nullptr

private

Definition at line 115 of file PhysValMET.h.

m_MET_PVTrack_Nominal_phi

TH1D * MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal_phi = nullptr

private

Definition at line 115 of file PhysValMET.h.

m_MET_PVTrack_Nominal_sum

TH1D * MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal_sum = nullptr

private

Definition at line 115 of file PhysValMET.h.

m_MET_PVTrack_Nominal_x

TH1D * MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal_x = nullptr

private

Definition at line 115 of file PhysValMET.h.

m_MET_PVTrack_Nominal_y

TH1D * MissingEtDQA::PhysValMET::m_MET_PVTrack_Nominal_y = nullptr

private

Definition at line 115 of file PhysValMET.h.

m_MET_PVTrack_Pileup

TH1D* MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup = nullptr

private

Definition at line 116 of file PhysValMET.h.

m_MET_PVTrack_Pileup_phi

TH1D * MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup_phi = nullptr

private

Definition at line 116 of file PhysValMET.h.

m_MET_PVTrack_Pileup_sum

TH1D * MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup_sum = nullptr

private

Definition at line 116 of file PhysValMET.h.

m_MET_PVTrack_Pileup_x

TH1D * MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup_x = nullptr

private

Definition at line 116 of file PhysValMET.h.

m_MET_PVTrack_Pileup_y

TH1D * MissingEtDQA::PhysValMET::m_MET_PVTrack_Pileup_y = nullptr

private

Definition at line 116 of file PhysValMET.h.

m_MET_Reb

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Reb

private

Definition at line 136 of file PhysValMET.h.

m_MET_Reb_phi

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Reb_phi

private

Definition at line 139 of file PhysValMET.h.

m_MET_Reb_sum

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Reb_sum

private

Definition at line 140 of file PhysValMET.h.

m_MET_Reb_x

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Reb_x

private

Definition at line 137 of file PhysValMET.h.

m_MET_Reb_y

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Reb_y

private

Definition at line 138 of file PhysValMET.h.

m_MET_Ref

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Ref

private

Definition at line 120 of file PhysValMET.h.

m_MET_Ref_phi

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Ref_phi

private

Definition at line 123 of file PhysValMET.h.

m_MET_Ref_sum

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Ref_sum

private

Definition at line 124 of file PhysValMET.h.

m_MET_Ref_x

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Ref_x

private

Definition at line 121 of file PhysValMET.h.

m_MET_Ref_y

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Ref_y

private

Definition at line 122 of file PhysValMET.h.

m_MET_Resolution_Reb

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Resolution_Reb

private

Definition at line 147 of file PhysValMET.h.

m_MET_Resolution_Ref

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Resolution_Ref

private

Definition at line 131 of file PhysValMET.h.

m_MET_Significance_Reb

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Significance_Reb

private

Definition at line 148 of file PhysValMET.h.

m_MET_Significance_Ref

std::map<std::string,std::vector<TH1D*> > MissingEtDQA::PhysValMET::m_MET_Significance_Ref

private

Definition at line 132 of file PhysValMET.h.

m_MET_Track

TH1D* MissingEtDQA::PhysValMET::m_MET_Track = nullptr

private

Definition at line 114 of file PhysValMET.h.

m_MET_Track_phi

TH1D * MissingEtDQA::PhysValMET::m_MET_Track_phi = nullptr

private

Definition at line 114 of file PhysValMET.h.

m_MET_Track_sum

TH1D * MissingEtDQA::PhysValMET::m_MET_Track_sum = nullptr

private

Definition at line 114 of file PhysValMET.h.

m_MET_Track_x

TH1D * MissingEtDQA::PhysValMET::m_MET_Track_x = nullptr

private

Definition at line 114 of file PhysValMET.h.

m_MET_Track_y

TH1D * MissingEtDQA::PhysValMET::m_MET_Track_y = nullptr

private

Definition at line 114 of file PhysValMET.h.

m_metadataMap

MDMap_t ManagedMonitorToolBase::m_metadataMap

protectedinherited

Definition at line 827 of file ManagedMonitorToolBase.h.

m_metmaker

ToolHandle<IMETMaker>* MissingEtDQA::PhysValMET::m_metmaker

private

Definition at line 163 of file PhysValMET.h.

m_metmakerPFlow

ToolHandle<IMETMaker> MissingEtDQA::PhysValMET::m_metmakerPFlow {this, "METMakerPFlow", "", "METMaker for EMPFlow jets"}

private

Definition at line 161 of file PhysValMET.h.

{this, "METMakerPFlow",            "", "METMaker for EMPFlow jets"};

m_metmakerTopo

ToolHandle<IMETMaker> MissingEtDQA::PhysValMET::m_metmakerTopo {this, "METMakerTopo", "", "METMaker for EMTopo jets"}

private

Definition at line 160 of file PhysValMET.h.

{this, "METMakerTopo",             "", "METMaker for EMTopo jets"};

m_muonColl

std::string MissingEtDQA::PhysValMET::m_muonColl

private

Definition at line 93 of file PhysValMET.h.

m_muonSelTool

ToolHandle<CP::IMuonSelectionTool> MissingEtDQA::PhysValMET::m_muonSelTool {this, "MuonSelectionTool", "", "Muon selection tool"}

private

Definition at line 155 of file PhysValMET.h.

{this, "MuonSelectionTool",        "", "Muon selection tool"};

m_names

std::map<std::string,std::string> MissingEtDQA::PhysValMET::m_names

private

Definition at line 111 of file PhysValMET.h.

m_nEvents

unsigned int ManagedMonitorToolBase::m_nEvents

protectedinherited

Definition at line 863 of file ManagedMonitorToolBase.h.

m_nEventsIgnoreTrigger

unsigned int ManagedMonitorToolBase::m_nEventsIgnoreTrigger

protectedinherited

Definition at line 864 of file ManagedMonitorToolBase.h.

m_newEventsBlock

bool ManagedMonitorToolBase::m_newEventsBlock

privateinherited

Definition at line 822 of file ManagedMonitorToolBase.h.

m_newHigStatInterval

bool ManagedMonitorToolBase::m_newHigStatInterval

privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

m_newLowStat

bool ManagedMonitorToolBase::m_newLowStat

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

m_newLowStatInterval

bool ManagedMonitorToolBase::m_newLowStatInterval

privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

m_newLumiBlock

bool ManagedMonitorToolBase::m_newLumiBlock

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

m_newMedStatInterval

bool ManagedMonitorToolBase::m_newMedStatInterval

privateinherited

Definition at line 820 of file ManagedMonitorToolBase.h.

m_newRun

bool ManagedMonitorToolBase::m_newRun

privateinherited

Definition at line 821 of file ManagedMonitorToolBase.h.

m_nLumiBlocks

unsigned int ManagedMonitorToolBase::m_nLumiBlocks

protectedinherited

Definition at line 865 of file ManagedMonitorToolBase.h.

m_path

std::string ManagedMonitorToolBase::m_path

protectedinherited

Definition at line 852 of file ManagedMonitorToolBase.h.

m_photonSelIsEMTool

ToolHandle<IAsgPhotonIsEMSelector> MissingEtDQA::PhysValMET::m_photonSelIsEMTool {this, "PhotonIsEMSelectionTool" , "", "Photon selection tool"}

private

Definition at line 157 of file PhysValMET.h.

{this, "PhotonIsEMSelectionTool" , "", "Photon selection tool"};

m_preScaleProp

long ManagedMonitorToolBase::m_preScaleProp

protectedinherited

Definition at line 853 of file ManagedMonitorToolBase.h.

m_procNEventsProp

long ManagedMonitorToolBase::m_procNEventsProp

protectedinherited

Definition at line 851 of file ManagedMonitorToolBase.h.

m_streamNameFcn

StreamNameFcn* ManagedMonitorToolBase::m_streamNameFcn

protectedinherited

Definition at line 841 of file ManagedMonitorToolBase.h.

m_supportedIntervalsForRebooking

std::set<Interval_t> ManagedMonitorToolBase::m_supportedIntervalsForRebooking

privateinherited

Definition at line 896 of file ManagedMonitorToolBase.h.

m_tauColl

std::string MissingEtDQA::PhysValMET::m_tauColl

private

Definition at line 92 of file PhysValMET.h.

m_tauSelTool

ToolHandle<TauAnalysisTools::ITauSelectionTool> MissingEtDQA::PhysValMET::m_tauSelTool {this, "TauSelectionTool", "", "Tau selection tool"}

private

Definition at line 162 of file PhysValMET.h.

{this, "TauSelectionTool",         "", "Tau selection tool"};

m_templateEfficiencies

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

protectedinherited

Definition at line 676 of file ManagedMonitorToolBase.h.

m_templateGraphs

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

protectedinherited

Definition at line 668 of file ManagedMonitorToolBase.h.

m_templateHistograms

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

protectedinherited

Definition at line 664 of file ManagedMonitorToolBase.h.

m_templateTrees

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

protectedinherited

Definition at line 672 of file ManagedMonitorToolBase.h.

m_terms

std::vector<std::string> MissingEtDQA::PhysValMET::m_terms

private

Definition at line 108 of file PhysValMET.h.

m_THistSvc

ServiceHandle<ITHistSvc> ManagedMonitorToolBase::m_THistSvc

protectedinherited

Definition at line 843 of file ManagedMonitorToolBase.h.

m_trigDecTool

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

protectedinherited

Definition at line 845 of file ManagedMonitorToolBase.h.

{this, "TrigDecisionTool",""};

m_triggerChainProp

std::string ManagedMonitorToolBase::m_triggerChainProp

protectedinherited

Definition at line 854 of file ManagedMonitorToolBase.h.

m_triggerGroupProp

std::string ManagedMonitorToolBase::m_triggerGroupProp

protectedinherited

Definition at line 855 of file ManagedMonitorToolBase.h.

m_trigLiveFractionDataKey

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

privateinherited

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

{this,"TriggerTranslatorTool",""};

m_types

std::vector<std::string> MissingEtDQA::PhysValMET::m_types

private

Definition at line 105 of file PhysValMET.h.

m_useLumi

bool ManagedMonitorToolBase::m_useLumi

privateinherited

Definition at line 894 of file ManagedMonitorToolBase.h.

m_useTrigger

bool ManagedMonitorToolBase::m_useTrigger

protectedinherited

Definition at line 857 of file ManagedMonitorToolBase.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

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

m_vTrigGroupNames

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

protectedinherited

Definition at line 680 of file ManagedMonitorToolBase.h.

---

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

• PhysValMET.h
• PhysValMET.cxx