TrigEDMChecker Class Reference

#include <TrigEDMChecker.h>

Inheritance diagram for TrigEDMChecker:

Collaboration diagram for TrigEDMChecker:

Public Member Functions
	TrigEDMChecker (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~TrigEDMChecker ()
virtual StatusCode	initialize () override
virtual StatusCode	execute () override
virtual StatusCode	sysInitialize () override
	Function initialising the tool in the correct way in Athena. More...
virtual StatusCode	sysExecute (const EventContext &) override
	override to do firstEvent method More...
template<typename T >
StatusCode	retrieveMetadata (const std::string &folder, const std::string &key, T &out)
	Helper function to access IOVMetaDataContainer information helped in the MetaDataStore. More...
template<typename T >
StatusCode	retrieveMetadata (const std::string &folder, const std::string &key, T &out, const IOVTime &time, int channel=-1)
	Helper function to access IOVMetaDataContainer information held in InputMetaDataStore, but will check IOVTime. More...
const ServiceHandle< ITHistSvc > &	histSvc () const
	The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a pointer to the THistSvc. More...
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
virtual StatusCode	sysStart () override
	Handle START transition. More...
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...
Functions providing access to the input/output metadata
const ServiceHandle< StoreGateSvc > &	inputMetaStore () const
	Const accessor for the input metadata store. More...
ServiceHandle< StoreGateSvc > &	inputMetaStore ()
	Accessor for the input metadata store. More...
const ServiceHandle< StoreGateSvc > &	outputMetaStore () const
	Const accessor for the output metadata store. More...
ServiceHandle< StoreGateSvc > &	outputMetaStore ()
	Accessor for the output metadata store. More...

Protected Member Functions
void	updateEvtStore (Gaudi::Details::PropertyBase &prop)
virtual void	handle (const Incident &inc) override
	Function receiving incidents from IncidentSvc/TEvent Experts can override but they should ensure they add AthAnalysisAlgorithm::handle(); to the end of their own implementation. More...
virtual StatusCode	beginInputFile ()
	Function called when a new input file is opened user can read input metadata from inputMetaStore() More...
virtual StatusCode	endInputFile ()
	Function called as an input file is being closed. More...
virtual StatusCode	metaDataStop ()
	Function called before finalize user can read output metadata from outputMetaStore() More...
virtual StatusCode	firstExecute ()
	Function called when first execute is encountered user can read event information with evtStore() More...
virtual TFile *	currentFile (const char *evtSelName="EventSelector") final
	Function returning the TFile pointer of the currently open file of the given EventSelector (in athena jobs this defaults to "EventSelector") More...
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...
StatusCode	configAthHistogramming (const ServiceHandle< ITHistSvc > &histSvc, const std::string &prefix, const std::string &rootDir, const std::string &histNamePrefix, const std::string &histNamePostfix, const std::string &histTitlePrefix, const std::string &histTitlePostfix)
	To be called by the derived classes to fill the internal configuration. More...
TH1 *	bookGetPointer (const TH1 &hist, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of histograms. More...
TH1 *	bookGetPointer (TH1 *hist, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of histograms. More...
TH1 *	bookGetPointer (TH1 &histRef, std::string tDir="", std::string stream="")
	Simplify the booking and registering (into THistSvc) of histograms. More...
TTree *	bookGetPointer (const TTree &treeRef, std::string tDir="", std::string stream="")
	Simplify the booking and registering (into THistSvc) of TTrees. More...
TGraph *	bookGetPointer (const TGraph &graphRef, std::string tDir="", std::string stream="")
	Simplify the booking and registering (into THistSvc) of TGraphs. More...
TEfficiency *	bookGetPointer (const TEfficiency &eff, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency. More...
TEfficiency *	bookGetPointer (TEfficiency *eff, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency. More...
TEfficiency *	bookGetPointer (TEfficiency &effRef, std::string tDir="", std::string stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency. More...
StatusCode	book (const TH1 &hist, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of histograms. More...
StatusCode	book (TH1 *hist, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of histograms. More...
StatusCode	book (TH1 &histRef, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of histograms. More...
StatusCode	book (const TTree &treeRef, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of TTrees. More...
StatusCode	book (const TGraph &graphRef, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of TGraphs. More...
StatusCode	book (const TEfficiency &eff, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency. More...
StatusCode	book (TEfficiency *eff, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency. More...
StatusCode	book (TEfficiency &effRef, const std::string &tDir="", const std::string &stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency. More...
TH1 *	hist (const std::string &histName, const std::string &tDir="", const std::string &stream="")
	Simplify the retrieval of registered histograms of any type. More...
TH2 *	hist2d (const std::string &histName, const std::string &tDir="", const std::string &stream="")
	Simplify the retrieval of registered 2-d histograms. More...
TH3 *	hist3d (const std::string &histName, const std::string &tDir="", const std::string &stream="")
	Simplify the retrieval of registered 3-d histograms. More...
TTree *	tree (const std::string &treeName, const std::string &tDir="", const std::string &stream="")
	Simplify the retrieval of registered TTrees. More...
TGraph *	graph (const std::string &graphName, const std::string &tDir="", const std::string &stream="")
	Simplify the retrieval of registered TGraphs. More...
TEfficiency *	efficiency (const std::string &effName, const std::string &tDir="", const std::string &stream="")
	Simplify the retrieval of registered TEfficiency. More...

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t
typedef uint32_t	hash_t
	typedef for the internal hash More...
typedef std::map< const hash_t, TH1 * >	HistMap_t
	Typedef for convenience. More...
typedef std::map< const hash_t, TEfficiency * >	EffMap_t
	Typedef for convenience. More...
typedef std::map< const hash_t, TTree * >	TreeMap_t
	Typedef for convenience. More...
typedef std::map< const hash_t, TGraph * >	GraphMap_t
	Typedef for convenience. More...

Private Member Functions
StatusCode do_execute	ATLAS_NOT_THREAD_SAFE ()
StatusCode	dumpTrigPassBits ()
StatusCode	dumpLVL1_ROI ()
StatusCode	dumpTrackParticleContainer ()
StatusCode dumpTrigMissingET	ATLAS_NOT_THREAD_SAFE ()
StatusCode	dumpxAODTrigMissingET ()
StatusCode	dumpxAODJetContainer ()
StatusCode	dumpTrigL2BphysContainer ()
StatusCode	dumpTrigEFBphysContainer ()
StatusCode dumpTrigEFBjetContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigL2BjetContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigTauClusterContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigEMCluster	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigEMClusterContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpxAODTrigEMCluster	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpxAODTrigEMClusterContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpCombinedMuonFeature	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpCombinedMuonFeatureContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpMuonFeature	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTileMuFeatureContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTileTrackMuFeatureContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigPhotonContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigMuonEFContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigMuonEFInfoContainer	ATLAS_NOT_THREAD_SAFE ()
void	printMuonTrk (const TrigMuonEFTrack *muonTrack)
void	printMuonTrk (const TrigMuonEFCbTrack *muonTrack)
StatusCode	dumpxAODMuonContainer ()
StatusCode dumpTrigMuonEFIsolationContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigElectronContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode	dumpxAODTrigElectronContainer ()
StatusCode	dumpxAODTrigPhotonContainer ()
StatusCode	dumpxAODElectronContainer ()
StatusCode	dumpxAODPhotonContainer ()
StatusCode dumpTrigTauContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTrigTauTracksInfo	ATLAS_NOT_THREAD_SAFE ()
StatusCode	dumpHLTResult ()
StatusCode	dumpTrigInDetTrackCollection ()
StatusCode dumpTrigVertexCollection	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpxAODTauJetContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode dumpTauJetContainer	ATLAS_NOT_THREAD_SAFE ()
StatusCode	dumpxAODTrackParticle ()
StatusCode	dumpxAODVertex ()
StatusCode	dumpStoreGate ()
StatusCode	dumpTDT ()
StatusCode	dumpxAODTrigMinBias ()
void	dumpTrigSpacePointCounts ()
void	dumpTrigT2MBTSBits ()
void	dumpTrigVertexCounts ()
void	dumpTrigTrackCounts ()
StatusCode	dumpNavigation ()
StatusCode	dumpTrigComposite ()
	Dump information on TrigComposite collections. More...
StatusCode	checkTrigCompositeElementLink (const xAOD::TrigComposite *tc, size_t element)
	Dump details on element links within TrigComposites. More...
StatusCode	TrigCompositeNavigationToDot (std::string &returnValue, bool &pass)
	Construct graph of HLT navigation in Run-3. More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
void	buildBookingString (std::string &bookingString, std::string &histName, std::string &tDir, std::string &stream, bool usePrefixPostfix=false)
	Method to build individual booking string. More...
void	myReplace (std::string &str, const std::string &oldStr, const std::string &newStr)
	Helper method to replace sub-string. More...
hash_t	hash (const std::string &histName) const
	Method to calculate a 32-bit hash from a string. More...

Private Attributes
bool	m_doDumpAll
	a handle on Store Gate for access to the Event Store More...
bool	m_doDumpTrigPassBits
bool	m_doDumpLVL1_ROI
bool	m_doDumpTrackParticleContainer
bool	m_doDumpTrigMissingET
bool	m_doDumpxAODTrigMissingET
bool	m_doDumpxAODJetContainer
bool	m_doDumpTrigL2BphysContainer
bool	m_doDumpTrigEFBphysContainer
bool	m_doDumpTrigEFBjetContainer
bool	m_doDumpTrigL2BjetContainer
bool	m_doDumpTrigTauClusterContainer
bool	m_doDumpTrigEMCluster
bool	m_doDumpTrigEMClusterContainer
bool	m_doDumpxAODTrigEMCluster
bool	m_doDumpxAODTrigEMClusterContainer
bool	m_doDumpCombinedMuonFeature
bool	m_doDumpMuonFeature
bool	m_doDumpTileMuFeature
bool	m_doDumpTileTrackMuFeature
bool	m_doDumpTrigPhotonContainer
bool	m_doDumpTrigMuonEFContainer
bool	m_doDumpTrigMuonEFInfoContainer
bool	m_doDumpxAODMuonContainer
bool	m_doDumpTrigMuonEFIsolationContainer
bool	m_doDumpTrigElectronContainer
bool	m_doDumpxAODTrigElectronContainer
bool	m_doDumpxAODTrigPhotonContainer
bool	m_doDumpxAODElectronContainer
bool	m_doDumpxAODPhotonContainer
bool	m_doDumpTrigTauContainer
bool	m_doDumpTrigTauTracksInfo
bool	m_doDumpHLTResult
bool	m_doDumpTrigInDetTrackCollection
bool	m_doDumpTrigVertexCollection
bool	m_doDumpxAODTauJetContainer
bool	m_doDumpTauJetContainer
bool	m_doDumpxAODTrackParticle
bool	m_doDumpxAODVertex
bool	m_doDumpStoreGate
bool	m_doTDTCheck
bool	m_doDumpxAODTrigMinBias
bool	m_doDumpAllTrigComposite
std::vector< std::string >	m_dumpTrigCompositeContainers
bool	m_doDumpNavigation
Gaudi::Property< std::string >	m_dumpNavForChain {this, "DumpNavigationForChain", "", "Optional chain to restrict navigation dump info."}
Gaudi::Property< bool >	m_excludeFailedHypoNodes
bool	m_doDumpTrigCompsiteNavigation
ToolHandle< Rec::IMuonPrintingTool >	m_muonPrinter {this, "MuonPrinter", "Rec::MuonPrintingTool/MuonPrintingTool"}
ServiceHandle< ::IClassIDSvc >	m_clidSvc
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_muonTracksKey { this, "MuonTracksKey", "HLT_IDTrack_Muon_FTF"}
SG::ReadHandleKey< xAOD::TrigNavigation >	m_navigationHandleKey { this, "TrigNavigation", "TrigNavigation", "" }
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer >	m_decisionsKey { this, "Decisions", "RoIDecisions", "Decisions created from TEs" }
ToolHandle< HLT::Navigation >	m_navigationTool { this, "NavigationTool", "HLT::Navigation/Navigation", "" }
PublicToolHandle< Trig::TrigDecisionTool >	m_trigDec { this, "TriggerDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool", ""}
int	m_trackWarningNum {0}
int	m_vertexWarningNum {0}
ServiceHandle< StoreGateSvc >	m_inputMetaStore
	Object accessing the input metadata store. More...
ServiceHandle< StoreGateSvc >	m_outputMetaStore
	Object accessing the output metadata store. More...
TFile *	m_currentFile {nullptr}
bool	m_doneFirstEvent {false}
ServiceHandle< ITHistSvc >	m_histSvc
	Default constructor: AthHistogramAlgorithm();. More...
std::string	m_prefix
	Name of the ROOT output stream (file) More...
std::string	m_rootDir
	Name of the ROOT directory. More...
std::string	m_histNamePrefix
	The prefix for the histogram THx name. More...
std::string	m_histNamePostfix
	The postfix for the histogram THx name. More...
std::string	m_histTitlePrefix
	The prefix for the histogram THx title. More...
std::string	m_histTitlePostfix
	The postfix for the histogram THx title. More...
DataObjIDColl	m_extendedExtraObjects
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared
HistMap_t	m_histMap
	The map of histogram names to their pointers. More...
EffMap_t	m_effMap
	The map of histogram names to their pointers. More...
TreeMap_t	m_treeMap
	The map of TTree names to their pointers. More...
GraphMap_t	m_graphMap
	The map of TGraph names to their pointers. More...
std::string	m_streamName
	Name of the ROOT output stream (file) More...
std::string	m_name
	Instance name. More...
MsgStream	m_msg
	Cached Message Stream. More...

Detailed Description

Definition at line 34 of file TrigEDMChecker.h.

Member Typedef Documentation

EffMap_t

typedef std::map< const hash_t, TEfficiency* > AthHistogramming::EffMap_t

privateinherited

Typedef for convenience.

Definition at line 205 of file AthHistogramming.h.

GraphMap_t

typedef std::map< const hash_t, TGraph* > AthHistogramming::GraphMap_t

privateinherited

Typedef for convenience.

Definition at line 219 of file AthHistogramming.h.

hash_t

typedef uint32_t AthHistogramming::hash_t

privateinherited

typedef for the internal hash

Definition at line 169 of file AthHistogramming.h.

HistMap_t

typedef std::map< const hash_t, TH1* > AthHistogramming::HistMap_t

privateinherited

Typedef for convenience.

Definition at line 198 of file AthHistogramming.h.

StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

TreeMap_t

typedef std::map< const hash_t, TTree* > AthHistogramming::TreeMap_t

privateinherited

Typedef for convenience.

Definition at line 212 of file AthHistogramming.h.

Constructor & Destructor Documentation

TrigEDMChecker()

TrigEDMChecker::TrigEDMChecker	(	const std::string &	name,
		ISvcLocator *	pSvcLocator
	)

switches to control the analysis through job options

Definition at line 112 of file TrigEDMChecker.cxx.

  : AthAnalysisAlgorithm(name, pSvcLocator),
    m_clidSvc( "ClassIDSvc", name )
{
  declareProperty("doDumpAll", m_doDumpAll = true);
  declareProperty("doDumpTrigPassBits", m_doDumpTrigPassBits = false);
  declareProperty("doDumpLVL1_ROI", m_doDumpLVL1_ROI = false);
  declareProperty("doDumpTrigMissingET", m_doDumpTrigMissingET = false);
  declareProperty("doDumpxAODTrigMissingET", m_doDumpxAODTrigMissingET = false);
  declareProperty("doDumpMuonFeature", m_doDumpMuonFeature = false);
  declareProperty("doDumpCombinedMuonFeature", m_doDumpCombinedMuonFeature = false);
  declareProperty("doDumpTileMuFeature",      m_doDumpTileMuFeature = false);
  declareProperty("doDumpTileTrackMuFeature", m_doDumpTileTrackMuFeature = false);
  declareProperty("doDumpTrigPhotonContainer", m_doDumpTrigPhotonContainer = false);
  declareProperty("doDumpTrigL2BphysContainer", m_doDumpTrigL2BphysContainer = false);
  declareProperty("doDumpTrigEFBphysContainer", m_doDumpTrigEFBphysContainer = false);
  declareProperty("doDumpTrigEFBjetContainer", m_doDumpTrigEFBjetContainer = false);
  declareProperty("doDumpTrigL2BjetContainer", m_doDumpTrigL2BjetContainer = false);
  declareProperty("doDumpxAODJetContainer", m_doDumpxAODJetContainer = false);
  declareProperty("doDumpTrigMuonEFContainer", m_doDumpTrigMuonEFContainer = false);
  declareProperty("doDumpTrigMuonEFInfoContainer", m_doDumpTrigMuonEFInfoContainer = false);
  declareProperty("doDumpTrigMuonEFIsolationContainer", m_doDumpTrigMuonEFIsolationContainer = false);
  declareProperty("doDumpxAODMuonContainer", m_doDumpxAODMuonContainer = false);
  declareProperty("doDumpTrigElectronContainer", m_doDumpTrigElectronContainer = false);
  declareProperty("doDumpxAODTrigElectronContainer", m_doDumpxAODTrigElectronContainer = false);
  declareProperty("doDumpxAODTrigPhotonContainer", m_doDumpxAODTrigPhotonContainer = false);
  declareProperty("doDumpxAODElectronContainer", m_doDumpxAODElectronContainer = false);
  declareProperty("doDumpxAODPhotonContainer", m_doDumpxAODPhotonContainer = false);
  declareProperty("doDumpHLTResult", m_doDumpHLTResult = false);
  declareProperty("doDumpTrigTauContainer", m_doDumpTrigTauContainer = false);
  declareProperty("doDumpTrigTauTracksInfo", m_doDumpTrigTauTracksInfo = false);
  declareProperty("doDumpTrigInDetTrackCollection", m_doDumpTrigInDetTrackCollection = false);
  declareProperty("doDumpTrigVertexCollection", m_doDumpTrigVertexCollection = false);
  declareProperty("doDumpTrigEMCluster", m_doDumpTrigEMCluster = false);
  declareProperty("doDumpTrigEMClusterContainer", m_doDumpTrigEMClusterContainer = false);
  declareProperty("doDumpxAODTrigEMCluster", m_doDumpxAODTrigEMCluster = false);
  declareProperty("doDumpxAODTrigEMClusterContainer", m_doDumpxAODTrigEMClusterContainer = false);
  declareProperty("doDumpTrigTauClusterContainer", m_doDumpTrigTauClusterContainer = false);
  declareProperty("doDumpTrackParticleContainer", m_doDumpTrackParticleContainer = false);
  declareProperty("doDumpTauJetContainer", m_doDumpTauJetContainer = false);
  declareProperty("doDumpxAODTrackParticle", m_doDumpxAODTrackParticle = false);
  declareProperty("doDumpxAODVertex", m_doDumpxAODVertex = false);
  declareProperty("doDumpxAODTauJetContainer", m_doDumpxAODTauJetContainer = false);
  declareProperty("doDumpxAODTrigMinBias", m_doDumpxAODTrigMinBias = false);
  declareProperty("doDumpStoreGate", m_doDumpStoreGate = false );
  declareProperty("doDumpAllTrigComposite", m_doDumpAllTrigComposite = false );
  declareProperty("dumpTrigCompositeContainers", m_dumpTrigCompositeContainers, "List of TC to dump" );
  declareProperty("doDumpTrigCompsiteNavigation", m_doDumpTrigCompsiteNavigation = false );
  declareProperty("doDumpNavigation", m_doDumpNavigation = false );
  declareProperty("doTDTCheck", m_doTDTCheck = false );
  declareProperty( "ClassIDSvc", m_clidSvc, "Service providing CLID info" );
}

~TrigEDMChecker()

TrigEDMChecker::~TrigEDMChecker ( )

virtual

Definition at line 169 of file TrigEDMChecker.cxx.

{}

Member Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/24]

StatusCode do_execute TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [2/24]

StatusCode dumpTrigMissingET TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [3/24]

StatusCode dumpTrigEFBjetContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [4/24]

StatusCode dumpTrigL2BjetContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [5/24]

StatusCode dumpTrigTauClusterContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [6/24]

StatusCode dumpTrigEMCluster TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [7/24]

StatusCode dumpTrigEMClusterContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [8/24]

StatusCode dumpxAODTrigEMCluster TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [9/24]

StatusCode dumpxAODTrigEMClusterContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [10/24]

StatusCode dumpCombinedMuonFeature TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [11/24]

StatusCode dumpCombinedMuonFeatureContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [12/24]

StatusCode dumpMuonFeature TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [13/24]

StatusCode dumpTileMuFeatureContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [14/24]

StatusCode dumpTileTrackMuFeatureContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [15/24]

StatusCode dumpTrigPhotonContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [16/24]

StatusCode dumpTrigMuonEFContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [17/24]

StatusCode dumpTrigMuonEFInfoContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [18/24]

StatusCode dumpTrigMuonEFIsolationContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [19/24]

StatusCode dumpTrigElectronContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [20/24]

StatusCode dumpTrigTauContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [21/24]

StatusCode dumpTrigTauTracksInfo TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [22/24]

StatusCode dumpTrigVertexCollection TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [23/24]

StatusCode dumpxAODTauJetContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

ATLAS_NOT_THREAD_SAFE() [24/24]

StatusCode dumpTauJetContainer TrigEDMChecker::ATLAS_NOT_THREAD_SAFE ( )

private

beginInputFile()

StatusCode AthAnalysisAlgorithm::beginInputFile ( )

protectedvirtualinherited

Function called when a new input file is opened user can read input metadata from inputMetaStore()

Dummy implementation that can be overridden by the derived tool.

Reimplemented in MuonVal::MetaDataAlg.

Definition at line 114 of file AthAnalysisAlgorithm.cxx.

                                                {
 
   // Return gracefully:
   return StatusCode::SUCCESS;
}

book() [1/8]

StatusCode AthHistogramming::book ( const TEfficiency &  eff, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 335 of file AthHistogramming.h.

{
  // We need to create a non-const clone
  TEfficiency* effClone = dynamic_cast< TEfficiency* >( eff.Clone() );
  if ( !effClone ) {
    m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *effClone, tDir, stream );
}

book() [2/8]

StatusCode AthHistogramming::book ( const TGraph &  graphRef, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TGraphs.

book() [3/8]

StatusCode AthHistogramming::book ( const TH1 &  hist, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 303 of file AthHistogramming.h.

{
  // We need to create a non-const clone
  TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
  if ( !histClone ) {
    m_msg << MSG::ERROR << "Couldn't create a TH1 clone" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *histClone, tDir, stream );
}

book() [4/8]

StatusCode AthHistogramming::book ( const TTree &  treeRef, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TTrees.

Definition at line 403 of file AthHistogramming.h.

{
  // Call the other Book method and see if it returns a valid pointer
  TTree* treePointer = this->bookGetPointer( treeRef, tDir, stream );
  if ( treePointer )
    {
      return StatusCode::SUCCESS;
    }
  else
    {
      return StatusCode::FAILURE;
    }
}

book() [5/8]

StatusCode AthHistogramming::book ( TEfficiency &  effRef, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 356 of file AthHistogramming.h.

{
  // Call the other Book method and see if it returns a valid pointer
  TEfficiency* effPointer = this->bookGetPointer( effRef, tDir, stream );
  if ( !effPointer ) {
    m_msg << MSG::ERROR << "Couldn't book a TEfficiency" << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

book() [6/8]

StatusCode AthHistogramming::book ( TEfficiency *  eff, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 346 of file AthHistogramming.h.

{
  if ( !eff ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *eff, tDir, stream );
}

book() [7/8]

StatusCode AthHistogramming::book ( TH1 &  histRef, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 324 of file AthHistogramming.h.

{
  // Call the other Book method and see if it returns a valid pointer
  TH1* histPointer = this->bookGetPointer( histRef, tDir, stream );
  if ( !histPointer ) {
    m_msg << MSG::ERROR << "Couldn't book a TH1" << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

book() [8/8]

StatusCode AthHistogramming::book ( TH1 *  hist, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 314 of file AthHistogramming.h.

{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TH1" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *hist, tDir, stream );
}

bookGetPointer() [1/8]

TEfficiency * AthHistogramming::bookGetPointer ( const TEfficiency &  eff, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 281 of file AthHistogramming.h.

{
  // We need to create a non-const clone
  TEfficiency* histClone = dynamic_cast< TEfficiency* >( hist.Clone() );
  if ( !histClone ) {
    m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *histClone, tDir, stream );
 
}

bookGetPointer() [2/8]

TGraph * AthHistogramming::bookGetPointer ( const TGraph &  graphRef, std::string  tDir = "", std::string  stream = ""  )

protectedinherited

Simplify the booking and registering (into THistSvc) of TGraphs.

Definition at line 427 of file AthHistogramming.cxx.

{
  // Get a pointer
  const TGraph* graphPointer = &graphRef;
 
  // Check that we got a valid pointer
  if ( !graphPointer )
    {
      m_msg << MSG::WARNING
            << "We got an invalid TGraph pointer in the BookGetPointer(TGraph*) method of the class" << m_name
            << "!" << endmsg;
      return NULL;
    }
 
  // Modify the name and title according to the prefixes of this classes instance
  std::string graphName  = graphPointer->GetName();
  const std::string graphTitle = graphPointer->GetTitle();
 
  // Check if the hash for this graphName already exists, i.e., if we have a hash collision
  const hash_t graphHash = this->hash(graphName);
  GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
  if ( it != m_graphMap.end() ) // It does exist!
    {
      m_msg << MSG::WARNING
            << "Detected a hash collision. The hash for the TGraph with name=" << graphName
            << " already exists and points to a TGraph with name=" << it->second->GetName()
            << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
      return NULL;
    }
 
  // Create a clone that has the new name
  TGraph* graphClone = dynamic_cast< TGraph* >( graphPointer->Clone((m_histNamePrefix+graphName+m_histNamePostfix).c_str()) );
  if( !graphClone )
    {
      m_msg << MSG::WARNING
            << "We couldn't clone the TGraph in the BookGetPointer(TGraph&) method of the class" << m_name
            << "!" << endmsg;
      return NULL;
    }
  graphClone->SetTitle ((m_histTitlePrefix+graphTitle+m_histTitlePostfix).c_str());
 
  // Massage the final string to book things
  std::string bookingString("");
  this->buildBookingString( bookingString, graphName, tDir, stream );
 
  // Register the TGraph into the THistSvc
  if ( !((histSvc()->regGraph(bookingString, graphClone)).isSuccess()) )
    {
      m_msg << MSG::WARNING
            << "Problem registering TGraph with name " << graphName
            << ", title " << graphTitle
            << " in " << m_name << "!" << endmsg;
      return NULL;
    }
 
  // Also register it in the local map of string to pointer
  m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphClone ) );
 
  return graphClone;
}

bookGetPointer() [3/8]

TH1 * AthHistogramming::bookGetPointer ( const TH1 &  hist, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 260 of file AthHistogramming.h.

{
  // We need to create a non-const clone
  TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
  if ( !histClone ) {
    m_msg << MSG::ERROR << "Couldn't create a TH1 clone in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *histClone, tDir, stream );
 
}

bookGetPointer() [4/8]

TTree * AthHistogramming::bookGetPointer ( const TTree &  treeRef, std::string  tDir = "", std::string  stream = ""  )

protectedinherited

Simplify the booking and registering (into THistSvc) of TTrees.

Definition at line 312 of file AthHistogramming.cxx.

{
  // Get a pointer
  const TTree* treePointer = &treeRef;
 
  // Check that we got a valid pointer
  if ( !treePointer )
    {
      m_msg << MSG::WARNING
            << "We got an invalid TTree pointer in the BookGetPointer(TTree*) method of the class" << m_name
            << "!" << endmsg;
      return NULL;
    }
 
  // Modify the name and title according to the prefixes of this classes instance
  std::string treeName  = treePointer->GetName();
  const std::string treeTitle = treePointer->GetTitle();
 
  // Check if the hash for this treeName already exists, i.e., if we have a hash collision
  const hash_t treeHash = this->hash(treeName);
  TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
  if ( it != m_treeMap.end() ) // It does exist!
    {
      m_msg << MSG::WARNING
            << "Detected a hash collision. The hash for the TTree with name=" << treeName
            << " already exists and points to a TTree with name=" << it->second->GetName()
            << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
      return NULL;
    }
 
  // Create a clone that has the new name
  TTree* treeClone = dynamic_cast< TTree* >( treePointer->Clone(treeName.c_str()) );
  if( !treeClone )
    {
      m_msg << MSG::WARNING
            << "We couldn't clone the TTree in the BookGetPointer(TTree&) method of the class" << m_name
            << "!" << endmsg;
      return NULL;
    }
  treeClone->SetTitle (treeTitle.c_str());
 
  // Massage the final string to book things
  std::string bookingString("");
  this->buildBookingString( bookingString, treeName, tDir, stream );
 
  // Register the TTree into the THistSvc
  if ( !((histSvc()->regTree(bookingString, treeClone)).isSuccess()) )
    {
      m_msg << MSG::WARNING
            << "Problem registering TTree with name " << treeName
            << ", title " << treeTitle
            << " in " << m_name << "!" << endmsg;
      return NULL;
    }
 
  // Also register it in the local map of string to pointer
  m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treeClone ) );
 
  return treeClone;
}

bookGetPointer() [5/8]

TEfficiency * AthHistogramming::bookGetPointer ( TEfficiency &  effRef, std::string  tDir = "", std::string  stream = ""  )

protectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 146 of file AthHistogramming.cxx.

{
  // Modify the name and title according to the prefixes of this classes instance
  std::string effName(effRef.GetName());
  const std::string effTitle(effRef.GetTitle());
  std::string bookingString("");
 
  this->buildBookingString( bookingString, effName, tDir, stream );
  effRef.SetTitle((m_histTitlePrefix+effTitle+m_histTitlePostfix).c_str() );
  effRef.SetName(effName.c_str());
 
  // Check if the hash for this effName already exists, i.e., if we have a hash collision
  const hash_t effHash = this->hash(effName);
  EffMap_t::const_iterator it = m_effMap.find( effHash );
  if ( it != m_effMap.end() ) // It does exist!
    {
      m_msg << MSG::WARNING
            << "Detected a hash collision. The hash for the TEfficiency with name=" << effName
            << " already exists and points to a TEfficiency with name=" << it->second->GetName()
            << " NOT going to book the new TEfficiency and returning a NULL pointer!" << endmsg;
      return NULL;
    }
 
  // Set the new name and title for the TEfficiency, based on the prefixes that the user set for this class instance
  // Create a clone that has the new name
 
  // Massage the final string to book things
 
  // Register the TEfficiency into the THistSvc
  if ( !((histSvc()->regEfficiency(bookingString, &effRef)).isSuccess()) )
    {
      m_msg << MSG::WARNING
            << "Problem registering TEfficiency with name " << effName
            << ", name prefix " << m_histNamePrefix
            << ", title " << effTitle
            << ", tile prefix " << m_histTitlePrefix
            << ", and tile postfix " << m_histTitlePostfix
            << " in " << m_name << "!" << endmsg;
      return NULL;
    }
 
  // Also register it in the local map of string to pointer
  m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, &effRef ) );
 
  return &effRef;
}

bookGetPointer() [6/8]

TEfficiency * AthHistogramming::bookGetPointer ( TEfficiency *  eff, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 293 of file AthHistogramming.h.

{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *hist, tDir, stream );
}

bookGetPointer() [7/8]

TH1 * AthHistogramming::bookGetPointer ( TH1 &  histRef, std::string  tDir = "", std::string  stream = ""  )

protectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 98 of file AthHistogramming.cxx.

{
  // Modify the name and title according to the prefixes of this classes instance
  std::string histName(histRef.GetName());
  const std::string histTitle(histRef.GetTitle());
  std::string bookingString("");
 
  this->buildBookingString( bookingString, histName, tDir, stream );
  histRef.SetTitle((m_histTitlePrefix+histTitle+m_histTitlePostfix).c_str() );
  histRef.SetName(histName.c_str());
 
  // Check if the hash for this histName already exists, i.e., if we have a hash collision
  const hash_t histHash = this->hash(histName);
  HistMap_t::const_iterator it = m_histMap.find( histHash );
  if ( it != m_histMap.end() ) // It does exist!
    {
      m_msg << MSG::WARNING
            << "Detected a hash collision. The hash for the histogram with name=" << histName
            << " already exists and points to a histogram with name=" << it->second->GetName()
            << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
      return NULL;
    }
 
  // Set the new name and title for the histogram, based on the prefixes that the user set for this class instance
  // Create a clone that has the new name
 
  // Massage the final string to book things
 
  // Register the histogram into the THistSvc
  if ( !((histSvc()->regHist(bookingString, &histRef)).isSuccess()) )
    {
      m_msg << MSG::WARNING
            << "Problem registering histogram with name " << histName
            << ", name prefix " << m_histNamePrefix
            << ", title " << histTitle
            << ", tile prefix " << m_histTitlePrefix
            << ", and tile postfix " << m_histTitlePostfix
            << " in " << m_name << "!" << endmsg;
      return NULL;
    }
 
  // Also register it in the local map of string to pointer
  m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, &histRef ) );
 
  return &histRef;
}

bookGetPointer() [8/8]

TH1 * AthHistogramming::bookGetPointer ( TH1 *  hist, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 272 of file AthHistogramming.h.

{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TH1 in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *hist, tDir, stream );
}

buildBookingString()

void AthHistogramming::buildBookingString ( std::string &  bookingString, std::string &  histName, std::string &  tDir, std::string &  stream, bool  usePrefixPostfix = false  )

privateinherited

Method to build individual booking string.

Definition at line 560 of file AthHistogramming.cxx.

{
  // Massage the final string to book things
  if(tDir.empty()) tDir = m_rootDir;
  size_t pos = histName.rfind('/');
  if(pos != std::string::npos){
    tDir+='/';
    tDir.append(histName, 0,pos);
    histName.erase(0,pos+1);
  };
  if(stream.empty()) stream = m_streamName;
 
  if(usePrefixPostfix){
    bookingString = "/"+stream+"/"+tDir+"/"+m_histNamePrefix+histName+m_histNamePostfix;
  } else {
    bookingString = "/"+stream+"/"+tDir+"/"+histName;
  }
  while(bookingString.find("//") != std::string::npos){
    this->myReplace(bookingString,"//","/");
  }
 
  return;
}

checkTrigCompositeElementLink()

StatusCode TrigEDMChecker::checkTrigCompositeElementLink ( const xAOD::TrigComposite *  tc, size_t  element  )

private

Dump details on element links within TrigComposites.

With specific checking of the Run-3 relationships

Definition at line 4154 of file TrigEDMChecker.cxx.

                                                                                                    { 
 
  const std::string name = tc->linkColNames().at(element);
  const CLID clid = static_cast<CLID>(tc->linkColClids().at(element));
 
  if (clid == ClassID_traits< TrigRoiDescriptorCollection >::ID()) { 
 
    const ElementLink<TrigRoiDescriptorCollection> elementLink = tc->objectLink<TrigRoiDescriptorCollection>(name);
    if (!elementLink.isValid()) ATH_MSG_WARNING("  Invalid element link to TrigRoiDescriptorCollection, link name:'" << name << "'");
    else ATH_MSG_DEBUG("  Dereferenced link '" << name << "'' to TrigRoiDescriptor:" << *elementLink);
 
  } else if (clid == ClassID_traits< DataVector< LVL1::RecEmTauRoI > >::ID()) { // There could be a few ROI types....
    // CLASS_DEF( DataVector< LVL1::RecEmTauRoI >, 6256, 1 )
 
    const ElementLink<DataVector< LVL1::RecEmTauRoI >> elementLink = tc->objectLink<DataVector< LVL1::RecEmTauRoI >>(name);
    if (!elementLink.isValid()) ATH_MSG_WARNING("  Invalid element link to LVL1::RecEmTauRoI, link name:'" << name << "'");
    else ATH_MSG_DEBUG("  Dereferenced link '" << name << "' to LVL1::RecEmTauRoI:" << *elementLink);
 
   } else if (clid == ClassID_traits< xAOD::TrigCompositeContainer >::ID()) {
    
    const ElementLink<xAOD::TrigCompositeContainer> elementLink = tc->objectLink<xAOD::TrigCompositeContainer>(name);
    if (!elementLink.isValid()) ATH_MSG_WARNING("  Invalid element link to TrigComposite, link name:'" << name << "'");
    else ATH_MSG_DEBUG("  Dereferenced link '" << name << "' to TrigComposite, TC name:'" << (*elementLink)->name() << "'");
 
   } else if (clid == ClassID_traits< ViewContainer >::ID()) {
    
    const ElementLink<ViewContainer> elementLink = tc->objectLink<ViewContainer>(name);
    if (!elementLink.isValid()) ATH_MSG_WARNING("  Invalid element link to View, link name:'" << name << "'");
    else ATH_MSG_DEBUG("  Dereferenced link '" << name << "' to View:'" << *elementLink);
 
   } else if (name == "feature") {
 
    if (clid == ClassID_traits< xAOD::TrigEMClusterContainer >::ID()) {
 
      const ElementLink<xAOD::TrigEMClusterContainer> elementLink = tc->objectLink<xAOD::TrigEMClusterContainer>(name);
      if (!elementLink.isValid()) ATH_MSG_WARNING("  Invalid element link to xAOD::TrigEMClusterContainer 'feature'");
      else ATH_MSG_DEBUG("  Dereferenced xAOD::TrigEMClusterContainer link 'feature', Energy:" << (*elementLink)->energy());
 
    } else if (clid == ClassID_traits< xAOD::TrigMissingETContainer >::ID()) {
 
      const ElementLink<xAOD::TrigMissingETContainer> elementLink = tc->objectLink<xAOD::TrigMissingETContainer>(name);
      if (!elementLink.isValid()) ATH_MSG_WARNING("  Invalid element link to xAOD::TrigMissingETContainer 'feature'");
      else ATH_MSG_DEBUG("  Dereferenced xAOD::TrigMissingETContainer link 'feature', ex:" << (*elementLink)->ex() << " ey:" << (*elementLink)->ey());
 
    } else {
 
      try {
        const ElementLink<xAOD::IParticleContainer> elementLink = tc->objectLink<xAOD::IParticleContainer>(name);
        if (!elementLink.isValid()) ATH_MSG_WARNING("  Invalid element link to 'feature'");
        else ATH_MSG_DEBUG("  Dereferenced IParticle link 'feature', pt:" << (*elementLink)->pt() << " eta:" << (*elementLink)->eta() << " phi:" <<  (*elementLink)->phi());
      } catch(std::runtime_error& e) {
        ATH_MSG_WARNING("  Cannot dereference 'feature' as IParticle: '" << e.what() << "'");
      }
 
    }
 
  } else {
    ATH_MSG_DEBUG("  Ignoring link to '" << name << "' with link CLID " << clid);
  }
 
  return StatusCode::SUCCESS;
 
}

configAthHistogramming()

StatusCode AthHistogramming::configAthHistogramming ( const ServiceHandle< ITHistSvc > &  histSvc, const std::string &  prefix, const std::string &  rootDir, const std::string &  histNamePrefix, const std::string &  histNamePostfix, const std::string &  histTitlePrefix, const std::string &  histTitlePostfix  )

protectedinherited

To be called by the derived classes to fill the internal configuration.

Definition at line 66 of file AthHistogramming.cxx.

{
  m_histSvc          = histSvc;
  m_streamName       = prefix;
  m_rootDir          = rootDir;
  m_histNamePrefix   = histNamePrefix;
  m_histNamePostfix  = histNamePostfix;
  m_histTitlePrefix  = histTitlePrefix;
  m_histTitlePostfix = histTitlePostfix;
 
  return StatusCode::SUCCESS;
}

currentFile()

TFile * AthAnalysisAlgorithm::currentFile ( const char *  evtSelName = "EventSelector" )

finalprotectedvirtualinherited

Function returning the TFile pointer of the currently open file of the given EventSelector (in athena jobs this defaults to "EventSelector")

Definition at line 147 of file AthAnalysisAlgorithm.cxx.

                                                               {
   if(m_currentFile) return m_currentFile;
 
   //get the EventSelector so we can get it's list of input files
   //dont get it with a ServiceHandle, because that invokes initialize, can get into init loop
 
   SmartIF<IProperty> evtSelector{service(evtSelName, false)};
   if(!evtSelector) {
     ATH_MSG_ERROR("currentFile(): Couldn't find the service: " << evtSelName);return 0;
   }
 
   try {
      //get the list of input files - use this to determine which open file is the current input file
      const StringArrayProperty& inputCollectionsName = dynamic_cast<const StringArrayProperty&>(evtSelector->getProperty("InputCollections"));
 
      ATH_MSG_VERBOSE("nOpenFile=" << gROOT->GetListOfFiles()->GetSize() << ". nFilesInInputCollection=" << inputCollectionsName.value().size());
      if(msgLvl(MSG::VERBOSE)) {
          for(int i=0;i<gROOT->GetListOfFiles()->GetSize();i++) {
            ATH_MSG_VERBOSE("Open file: " << gROOT->GetListOfFiles()->At(i)->GetName());
          }
      }
 
      //look through list of files and find the one from the input collection that is currently open
 
      for(int i=0;i<gROOT->GetListOfFiles()->GetSize();i++) {
            TFile *g = (TFile*)gROOT->GetListOfFiles()->At(i);
            //see if this file is in the input file list
            //strip everything except stuff either side of last /
            TString s(g->GetName());
            TObjArray* tokens = s.Tokenize("/");
            TObjString* lastToken = static_cast<TObjString*>(tokens->Last());
            TString sToCompare("");
            bool shortComparison(false);
            if(tokens->GetEntries()>1) {
                TString beforeSlash((static_cast<TObjString*>(tokens->At(tokens->GetEntries()-2)))->GetString());
                if(beforeSlash.Length()>0) sToCompare += beforeSlash;
                sToCompare += "/";
            } else {
                shortComparison=true;
            }
            sToCompare += lastToken->GetString();
            TString sToCompare_short(lastToken->GetString()); //short versions search
            delete tokens;
 
            for(unsigned int j=0;j<inputCollectionsName.value().size();j++) {
                TString t(inputCollectionsName.value()[j].c_str());
                //try perfect match first
                if(s.EqualTo(t)) {
                  ATH_MSG_VERBOSE("Current File is: " << inputCollectionsName.value()[j]);
                  m_currentFile = g;
                  return g;
                }
                TObjArray* tokens = t.Tokenize("/");
                TObjString* lastToken = dynamic_cast<TObjString*>(tokens->Last());
                if (!lastToken) {
                  ATH_MSG_ERROR("Cannot cast token string to TObjString");
                  return nullptr;
                }
                TString tToCompare = "";
                bool shortComparison2(false);
                if(tokens->GetEntries()>1) {
                  TObjString* beforeSlashStr = dynamic_cast<TObjString*>(tokens->At(tokens->GetEntries()-2));
                  if (!beforeSlashStr) {
                    ATH_MSG_ERROR("Cannot cast token string to TObjString");
                    return nullptr;
                  }
                  TString beforeSlash(beforeSlashStr->GetString());
                  if(beforeSlash.Length()>0) tToCompare += beforeSlash;
                  tToCompare += "/";
                } else {
                  shortComparison2=true;
                }
                tToCompare += lastToken->GetString();
                TString tToCompare_short(lastToken->GetString());
                delete tokens;
 
                if(shortComparison || shortComparison2) { //doing short version search, no directories to distinguish files!
                  if(sToCompare_short.EqualTo(tToCompare_short)) {
                      ATH_MSG_VERBOSE("Current File is: " << inputCollectionsName.value()[j]);
                      m_currentFile = g;
                      return g;
                  }
                } else
                if(sToCompare.EqualTo(tToCompare)) {
                  ATH_MSG_VERBOSE("Current File is: " << inputCollectionsName.value()[j]);
                  m_currentFile=g;
                  return g;
                }
            }
      }
 
   } catch(...) {
     ATH_MSG_ERROR("currentFile(): Couldn't load InputCollections property of " << evtSelName); return 0;
   }
 
   ATH_MSG_ERROR("currentFile(): Could not find the current file!");
   return 0; //something went wrong :-(
 
}

declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::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());
 
  }

declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  t, const SG::NotHandleType &    )

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

  {
    return PBASE::declareProperty(t);
  }

declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 245 of file AthCommonDataStore.h.

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

declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 221 of file AthCommonDataStore.h.

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

declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 333 of file AthCommonDataStore.h.

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

declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

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

Definition at line 352 of file AthCommonDataStore.h.

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

declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::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());
  }

detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::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; }

dumpHLTResult()

StatusCode TrigEDMChecker::dumpHLTResult ( )

private

Definition at line 2108 of file TrigEDMChecker.cxx.

                                         {
 
  ATH_MSG_DEBUG("in dumpHLTResult()");
 
  ATH_MSG_INFO("REGTEST ==========START of HLTResult DUMP===========");
 
  const HLT::HLTResult* hltResult = 0;
  StatusCode sc=evtStore()->retrieve( hltResult, "HLTResult_L2");
  if( sc.isFailure()  ||  !hltResult ) {
    ATH_MSG_INFO("No HLTResult_L2 found in TDS");
    return StatusCode::SUCCESS;
  }
  ATH_MSG_INFO("REGTEST HLTResult_L2 Successfully Retrieved");
 
  ATH_MSG_INFO("REGTEST HLTResult_L2->isEmpty() returns " << hltResult->isEmpty());
  ATH_MSG_INFO("REGTEST HLTResult_L2->size() returns " << hltResult->size());
  ATH_MSG_INFO("REGTEST HLTResult_L2->isPassThrough() returns " << hltResult->isPassThrough());
  ATH_MSG_INFO("REGTEST HLTResult_L2->isAccepted() returns " << hltResult->isAccepted());
 
  ATH_MSG_INFO("REGTEST ==========END of HLTResult DUMP===========");
 
  ATH_MSG_DEBUG("dumpHLTResult() succeeded");
 
  return StatusCode::SUCCESS;
}

dumpLVL1_ROI()

StatusCode TrigEDMChecker::dumpLVL1_ROI ( )

private

Definition at line 1171 of file TrigEDMChecker.cxx.

                                        {
 
  ATH_MSG_DEBUG("in dumpLVL1_ROI()");
 
  ATH_MSG_INFO("REGTEST ==========START of LVL1_ROI DUMP===========");
 
  const LVL1_ROI * lvl1ROI;
  StatusCode sc = evtStore()->retrieve(lvl1ROI);
  if (sc.isFailure() ) {
    ATH_MSG_INFO("REGTEST No LVL1_ROI found");
    return  StatusCode::SUCCESS;
  }
 
  ATH_MSG_INFO("REGTEST LVL1_ROI retrieved");
 
  LVL1_ROI::emtaus_type::const_iterator itEMTau   =
    (lvl1ROI->getEmTauROIs()).begin();
  LVL1_ROI::emtaus_type::const_iterator itEMTau_e =
    (lvl1ROI->getEmTauROIs()).end();
  int j = 0;
  for( ; itEMTau != itEMTau_e; ++itEMTau, ++j) {
    ATH_MSG_INFO("REGTEST Looking at LVL1_ROI " << j);
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI Eta     is " << itEMTau->getEta());
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI Phi     is " << itEMTau->getPhi());
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI EMClus  is " << itEMTau->getEMClus());
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI TauClus is " << itEMTau->getTauClus());
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI EMIsol  is " << itEMTau->getEMIsol());
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI HadIsol is " << itEMTau->getHadIsol());
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI Core    is " << itEMTau->getCore());
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI HadCore is " << itEMTau->getHadCore());
    ATH_MSG_INFO("REGTEST LVL1 EmTauROI roiWord is " << itEMTau->getROIWord());
  }
 
  ATH_MSG_INFO("REGTEST ==========END of LVL1_ROI DUMP===========");
  ATH_MSG_DEBUG("dumpLVL1_ROI() succeeded");
  return StatusCode::SUCCESS;
}

dumpNavigation()

StatusCode TrigEDMChecker::dumpNavigation ( )

private

Definition at line 4445 of file TrigEDMChecker.cxx.

{
  // Get object from store
  const xAOD::TrigNavigation * navigationHandle = nullptr;
  ATH_CHECK( evtStore()->retrieve( navigationHandle, m_navigationHandleKey.key() ) );
  // Proper version doesn't work - conversion issue?
  //SG::ReadHandle< xAOD::TrigNavigation > navigationHandle = SG::ReadHandle< xAOD::TrigNavigation >( m_navigationHandleKey );
  //if ( !navigationHandle.isValid() ) ATH_MSG_FATAL( "Could not retrieve navigation" );
 
  // Get serialised navigation info
  const std::vector< unsigned int > serialisedNavigation = navigationHandle->serialized();
  ATH_MSG_INFO( "Serialised navigation size: " << serialisedNavigation.size() );
 
  // Convert the input
  HLT::Navigation* testNav = m_navigationTool.get();
  testNav->deserialize( serialisedNavigation );
 
  // Make a map of TE name hashes
  const xAOD::TriggerMenuContainer * testMenu = nullptr;
  ATH_CHECK( inputMetaStore()->retrieve( testMenu, "TriggerMenu" ) );
  std::map< int, std::string > hash2string;
  for ( auto const& sequence : testMenu->front()->sequenceInputTEs() ) {
    for ( auto const& name : sequence ) {
      int hash = TrigConf::HLTUtils::string2hash( name );
      hash2string[ hash ] = name;
    }
  }
 
  // Map TE names to chain names
  unsigned int chainCounter = 0;
  std::map< int, std::string > hash2chain;
  for ( auto const& chain : testMenu->front()->chainSignatureOutputTEs() ) {
 
    // Find the chain name
    std::string chainName = testMenu->front()->chainNames()[ chainCounter ];
    ++chainCounter;
 
    // Find all associated TEs
    for ( auto const& signature : chain ) {
      for ( auto const& name : signature ) {
        int hash = TrigConf::HLTUtils::string2hash( name );
        hash2string[ hash ] = name; // for decoding
        hash2chain[ hash ] = chainName;
      }
    }
  }
 
  // Define a map of TE features, to the TEs that use them. Needs a custom sort lambda
  auto cmpLambda = []( const HLT::TriggerElement::FeatureAccessHelper &lhs, const HLT::TriggerElement::FeatureAccessHelper &rhs) { 
 
    // Compare indices if CLID matches
    if ( lhs.getCLID() == rhs.getCLID() ) return ( lhs.getIndex() < rhs.getIndex() );
 
    // Compare CLIDs
    else return ( lhs.getCLID() < rhs.getCLID() );
  };
  std::map< HLT::TriggerElement::FeatureAccessHelper, std::vector< HLT::TriggerElement* >, decltype(cmpLambda) > feature2element(cmpLambda);
 
  // Retrieve all TE features and add them to the map
  std::vector< HLT::TriggerElement* > allTEs;
  testNav->getAll( allTEs, false );
  for ( auto element : allTEs ) {
 
    // Add TE features to the big map 
    for ( auto helper : element->getFeatureAccessHelpers() ) {
      feature2element[ helper ].push_back( element );
    }
  }
 
  // Debug - output all TEs and their ancestors
  // No duplication - only print terminal nodes
  for ( auto element : allTEs ) {
    if ( testNav->isTerminalNode( element ) ) {
      ATH_MSG_INFO( "+++++++++++ " << hash2string[ element->getId() ] << " is terminal node" );
      ATH_MSG_INFO( "ptr: " << element );
      std::queue< HLT::TriggerElement* > allAncestors;
      allAncestors.push( element );
      while ( allAncestors.size() ) {
 
        HLT::TriggerElement * thisElement = allAncestors.front();
        allAncestors.pop();
        auto theseAncestors = thisElement->getRelated( HLT::TriggerElement::Relation::seededByRelation );
 
        // Dump TE
        ATH_MSG_INFO( "te: " << thisElement->getId() << " " << hash2string[ thisElement->getId() ] );
        ATH_MSG_INFO( "  chain: " << hash2chain[ thisElement->getId() ] );
        for ( const auto& helper : thisElement->getFeatureAccessHelpers() ) {
          ATH_MSG_INFO( "   feat: " << helper );
        }
        ATH_MSG_INFO( theseAncestors.size() << " ancestors" );
 
        // Examine ancestors
        for ( auto ancestor : theseAncestors ) {
          allAncestors.push( ancestor );
        }
      }
    }
  }
 
  // Make the decision container
  SG::WriteHandle< TrigCompositeUtils::DecisionContainer > outputNavigation = TrigCompositeUtils::createAndStore( m_decisionsKey, getContext() ); 
  auto decisionOutput = outputNavigation.ptr();
 
  // Find unique chains associated with a feature
  std::map< HLT::TriggerElement const*, std::vector< int > > element2decisions;
  for ( const auto& pair : feature2element ) {
 
    // Get the feature info
    std::string featureName = testNav->label( pair.first.getCLID(), pair.first.getIndex().subTypeIndex() );
    auto sgKey = evtStore()->stringToKey( featureName, pair.first.getCLID() );
 
    // Store RoIs with appropriate label ?
    std::string storeFeatureName = "feature";
/*    if ( pair.first.getCLID() == ClassID_traits< TrigRoiDescriptor >::ID() ) {
      storeFeatureName = "roi";
    }*/
 
    // Make a decision object for the feature
    auto decision = TrigCompositeUtils::newDecisionIn( decisionOutput );
    decision->typelessSetObjectLink( storeFeatureName, sgKey, pair.first.getCLID(), pair.first.getIndex().objectsBegin(), pair.first.getIndex().objectsEnd() );
 
    // Examine associated TEs, look for chains
    std::set< std::string > passedChains;
    for ( HLT::TriggerElement const* element : pair.second ) {
 
      // TODO - find out what chains actually passed!
      passedChains.insert( hash2chain[ element->getId() ] );
 
      // Index the TE
      int decisionNumber = decisionOutput->size() - 1;
      element2decisions[ element ].push_back( decisionNumber );
    }
 
    // Store unique chains in the decision
    for ( auto& chain : passedChains ) {
      TrigCompositeUtils::addDecisionID( TrigConf::HLTUtils::string2hash( chain ), decision );
    }
  }
 
  // Store decision ancestry (had to go through once before to ensure indices populated)
  unsigned int decisionCounter = 0;
  for ( const auto& pair : feature2element ) {
 
    // Get current decision
    auto decision = decisionOutput->at( decisionCounter );
    ++decisionCounter;
 
    // Find ancestor TEs
    for ( auto element : pair.second ) {
      auto theseAncestors = element->getRelated( HLT::TriggerElement::Relation::seededByRelation );
      for ( auto ancestor : theseAncestors ) {
        for ( int decisionIndex : element2decisions[ ancestor ] ) {
          TrigCompositeUtils::linkToPrevious( decision, m_decisionsKey.key(), decisionIndex );
        }
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

dumpStoreGate()

StatusCode TrigEDMChecker::dumpStoreGate ( )

private

dumpTDT()

StatusCode TrigEDMChecker::dumpTDT ( )

private

Definition at line 4022 of file TrigEDMChecker.cxx.

                                   {
  using namespace TrigCompositeUtils; // LinkInfo
  ATH_MSG_INFO( "REGTEST ==========START of TDT DUMP===========" );
  // Note: This minimal TDT dumper is for use during run-3 dev
  std::string chain = m_dumpNavForChain;
  if (chain.empty()) {
    chain = "HLT_.*";
  }
  std::vector<std::string> confChains = m_trigDec->getListOfTriggers(chain);
  for (const auto& item : confChains) {
    bool passed = m_trigDec->isPassed(item);
    ATH_MSG_INFO("  HLT Item " << item << " (numeric ID " << TrigConf::HLTUtils::string2hash(item, "Identifier") << ") passed raw? " << passed);
    if (m_trigDec->getNavigationFormat() == "TriggerElement") {
      ATH_MSG_DEBUG("    Skipping Run 2 features in this dumper");
      continue;
    }
    std::vector< LinkInfo<xAOD::IParticleContainer> > passFeatures = m_trigDec->features<xAOD::IParticleContainer>(item);
    if (passFeatures.size()) {
      ATH_MSG_INFO("    " << item << " Passed Final IParticle features size: " << passFeatures.size());
      for (const LinkInfo<xAOD::IParticleContainer>& li : passFeatures) {
        if (!li.isValid()) {
          ATH_MSG_WARNING("      Unable to access feature - link invalid.");
        } else {
          try {
            std::string state = "ACTIVE";
            if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
            else if (li.state == ActiveState::UNSET) state = "UNSET";
            ATH_MSG_INFO("      IParticle Feature from " << li.link.dataID() << " index:" << li.link.index() << " pt:" << (*li.link)->pt() << " eta:" << (*li.link)->eta() << " phi:" << (*li.link)->phi() << " state:" << state);
          } catch (const std::exception& e) {
            ATH_MSG_WARNING("      Unable to dereference feature {" << e.what() << "}");
          }
        }
      }
    }
    std::vector< LinkInfo<xAOD::IParticleContainer> > passAndFailFeatures = m_trigDec->features<xAOD::IParticleContainer>(item, TrigDefs::includeFailedDecisions);
    if (passAndFailFeatures.size()) {
      ATH_MSG_INFO("    " << item << " Passed+Failed Final IParticle features size: " << passAndFailFeatures.size());
      for (const LinkInfo<xAOD::IParticleContainer>& li : passAndFailFeatures) {
        if (!li.isValid()) {
          ATH_MSG_WARNING("      Unable to access feature - link invalid.");
        } else {
          try {
            std::string state = "ACTIVE";
            if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
            else if (li.state == ActiveState::UNSET) state = "UNSET";
            ATH_MSG_INFO("      IParticle Feature from " << li.link.dataID() << " index:" << li.link.index() << " pt:" << (*li.link)->pt() << " eta:" << (*li.link)->eta() << " phi:" << (*li.link)->phi() << " state:" << state);
          } catch (const std::exception& e) {
            ATH_MSG_WARNING("      Unable to dereference feature {" << e.what() << "}");
          }
        }
      }
    }
    std::vector< LinkInfo<xAOD::IParticleContainer> > allFeatures = m_trigDec->features<xAOD::IParticleContainer>(item, TrigDefs::includeFailedDecisions, "", TrigDefs::allFeaturesOfType);
    if (allFeatures.size()) {
      ATH_MSG_INFO("    " << item << " Passed+Failed ALL IParticle features size: " << allFeatures.size());
      for (const LinkInfo<xAOD::IParticleContainer>& li : allFeatures) {
        if (!li.isValid()) {
          ATH_MSG_WARNING("      Unable to access feature - link invalid.");
        } else {
          try {
            std::string state = "ACTIVE";
            if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
            else if (li.state == ActiveState::UNSET) state = "UNSET";
            ATH_MSG_INFO("      IParticle Feature from " << li.link.dataID() << " index:" << li.link.index() << " pt:" << (*li.link)->pt() << " eta:" << (*li.link)->eta() << " phi:" << (*li.link)->phi() << " state:" << state);
          } catch (const std::exception& e) {
            ATH_MSG_WARNING("      Unable to dereference feature {" << e.what() << "}");
          }
        }
      }
    }
  }
 
  if (m_trigDec->getNavigationFormat() == "TrigComposite") {
    // Check associateToEventView helper function
    std::vector< LinkInfo<xAOD::IParticleContainer> > muons = m_trigDec->features<xAOD::IParticleContainer>("HLT_mu24_idperf_L1MU20", TrigDefs::Physics, "HLT_MuonL2CBInfo");
    SG::ReadHandle<xAOD::TrackParticleContainer> muonTracksReadHandle(m_muonTracksKey, Gaudi::Hive::currentContext());
    for (const LinkInfo<xAOD::IParticleContainer>& mu : muons) {
      // Note: auto here refers to type std::pair< xAOD::TrackParticleContainer::const_iterator, xAOD::TrackParticleContainer::const_iterator>
      const auto roiTrackItPair = m_trigDec->associateToEventView<xAOD::TrackParticleContainer>(muonTracksReadHandle, mu, "roi");
      const xAOD::TrackParticleContainer::const_iterator startIt = roiTrackItPair.first;
      const xAOD::TrackParticleContainer::const_iterator stopIt  = roiTrackItPair.second;
      ATH_MSG_INFO("Muon pT: " << (*mu.link)->pt() << " is from the same ROI as tracks with index " 
        << std::distance(muonTracksReadHandle->begin(), startIt) << "-" << std::distance(muonTracksReadHandle->begin(), stopIt) 
        << ", which is " << std::distance(startIt, stopIt) << " tracks, out of " << muonTracksReadHandle->size() << " total tracks.");
      for (xAOD::TrackParticleContainer::const_iterator it = startIt; it != stopIt; ++it) {
        ATH_MSG_VERBOSE(" -- Track " << std::distance(startIt, it) << " in this ROI, pT: " << (*it)->pt() );
      }
    }
  }
 
  ATH_MSG_INFO( "REGTEST ==========END of TDT DUMP===========" );
  return StatusCode::SUCCESS;
}

dumpTrackParticleContainer()

StatusCode TrigEDMChecker::dumpTrackParticleContainer ( )

private

track

track vertex position

access to TrackSummary information

Definition at line 1064 of file TrigEDMChecker.cxx.

                                                      {
 
  ATH_MSG_DEBUG("in dumpTrackParticleContainer()");
 
  ATH_MSG_INFO("REGTEST ==========START of TrackParticleContainer DUMP===========");
 
    std::string trackPtags[]={"HLT_InDetTrigParticleCreation_Bjet_EFID",
            "HLT_InDetTrigParticleCreation_Bphysics_EFID",
            "HLT_InDetTrigParticleCreation_Electron_EFID",
            "HLT_InDetTrigParticleCreation_FullScan_EFID",
            "HLT_InDetTrigParticleCreation_Muon_EFID",
            "HLT_InDetTrigParticleCreation_Photon_EFID",
            "HLT_InDetTrigParticleCreation_Tau_EFID"};
 
    int ntag=7;
 
    StatusCode returnsc=StatusCode::SUCCESS;
 
    for (int itag=0; itag<ntag; itag++){
        const Rec::TrackParticleContainer*  pTrackParticleC = nullptr;
        StatusCode sc = evtStore()->retrieve(pTrackParticleC, trackPtags[itag]);
        if (sc.isFailure()) {
          ATH_MSG_INFO("REGTEST No TrackParticleContainer found with tag " << trackPtags[itag]);
            continue;
        }
        ATH_MSG_INFO("TrackParticleContainer found with tag " << trackPtags[itag]
                     << " and size " << pTrackParticleC->size());
 
        Rec::TrackParticleContainer::const_iterator trackItr  = pTrackParticleC->begin();
        Rec::TrackParticleContainer::const_iterator trackItrE = pTrackParticleC->end();
        for (int ind=1; trackItr != trackItrE; ++trackItr, ind++) {
            const Rec::TrackParticle * trackParticle = (*trackItr);
            ATH_MSG_INFO(" TrackParticle " << ind << " charge "
                         << trackParticle->charge() << " p "
                         << trackParticle->p()<< " eta " << trackParticle->eta()
                         << " phi " <<  trackParticle->phi());            
 
            const Trk::Track * track = trackParticle->originalTrack();
            if ( track ) {
              ATH_MSG_INFO(" Got attached track");
                const Trk::TrackParameters* perigee = track->perigeeParameters();
                if (perigee) {
                    const auto& parameterVector = perigee->parameters();
                    ATH_MSG_INFO(" q/P " << parameterVector[Trk::qOverP] <<
                                 " theta " << parameterVector[Trk::theta] <<
                                 " phi   " <<parameterVector[Trk::phi]);
                } else {
                  ATH_MSG_INFO(" No perigee attached to track");
                }
 
            } else {
              if(   m_trackWarningNum <= maxRepWarnings ) {
                ATH_MSG_DEBUG(" No attached track");
                if(  m_trackWarningNum == maxRepWarnings) {
                  ATH_MSG_WARNING(" Max attached track warning reached, no further warnings given");
                }
                m_trackWarningNum++;
              }
            }
 
            const Trk::VxCandidate * vertex = trackParticle->reconstructedVertex();
            if ( vertex ) {
                const Trk::RecVertex& vtx = vertex->recVertex();
                const Amg::Vector3D& position = vtx.position();
                ATH_MSG_INFO(" vertex position (" << position[0] << ", " <<
                             position[1] << ", " << position[2] << ") ");
            } else {
              if(   m_vertexWarningNum <= maxRepWarnings ) {
                ATH_MSG_DEBUG(" No attached vertex");
                if(  m_vertexWarningNum == maxRepWarnings) {
                  ATH_MSG_WARNING(" Max attached vertex warning reached, no further warnings given");
                }
                m_vertexWarningNum++;
              }
            }
 
            const Trk::Perigee* perigee = trackParticle->measuredPerigee();
            if (perigee) {
                const auto& parameters = perigee->parameters();
                ATH_MSG_INFO("Trk::Perigee parameters:");
                ATH_MSG_INFO(" * d_0   : "<< parameters[Trk::d0]      );
                ATH_MSG_INFO(" * z_0   : "<< parameters[Trk::z0]      );
                ATH_MSG_INFO(" * phi   : "<< parameters[Trk::phi]     );
                ATH_MSG_INFO(" * Theta : "<< parameters[Trk::theta]   );
                ATH_MSG_INFO(" * q/p   : "<< parameters[Trk::qOverP]  );
            } else {
              ATH_MSG_WARNING(" No attached perigee");
            }
            const Trk::TrackSummary* summary = trackParticle->trackSummary();
            if (summary) {
              ATH_MSG_DEBUG("Track summary information:");
              ATH_MSG_DEBUG(" * Number of B layer hits : "<<summary->get(Trk::numberOfBLayerHits));
              ATH_MSG_DEBUG(" * Number of pixel hits : "<<summary->get(Trk::numberOfPixelHits));
              ATH_MSG_DEBUG(" * Number of SCT hits : "<<summary->get(Trk::numberOfSCTHits));
              ATH_MSG_DEBUG(" * Number of TRT hits : "<<summary->get(Trk::numberOfTRTHits));
            }
        }
    }
    return returnsc;
}

dumpTrigComposite()

StatusCode TrigEDMChecker::dumpTrigComposite ( )

private

Dump information on TrigComposite collections.

Only dumpTrigCompositeContainers are dumped unless doDumpAllTrigComposite is set

Definition at line 4116 of file TrigEDMChecker.cxx.

                                             {
  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigCompositeContainer DUMP===========" );
 
  if (m_doDumpAllTrigComposite) {
    m_dumpTrigCompositeContainers.clear();
    const CLID TrigCompositeCLID = static_cast<CLID>( ClassID_traits< xAOD::TrigCompositeContainer >::ID() );
    evtStore()->keys(TrigCompositeCLID, m_dumpTrigCompositeContainers);
    std::string typeNameTC;
    ATH_CHECK(m_clidSvc->getTypeNameOfID(TrigCompositeCLID, typeNameTC));
    ATH_MSG_DEBUG("dumpTrigComposite got " <<  m_dumpTrigCompositeContainers.size() << " keys for " << typeNameTC);
  } else {
    ATH_MSG_DEBUG("Using supplied " <<  m_dumpTrigCompositeContainers.size() << " keys");
  }
 
  for ( const std::string & key: m_dumpTrigCompositeContainers ) {
    // get the collection
    if ( not evtStore()->contains<xAOD::TrigCompositeContainer>(key) ) {    
      ATH_MSG_WARNING("Absent TrigCompositeContainer: " << key );
      continue;
    }
    ATH_MSG_DEBUG( "#################### Dumping container of : " << key );
    const xAOD::TrigCompositeContainer* cont= nullptr;
    ATH_CHECK( evtStore()->retrieve( cont, key ) );
    
    size_t count = 0;
    for ( auto tc: *cont ) {
      ATH_MSG_DEBUG("########## ELEMENT " << count++);
      ATH_MSG_DEBUG(*tc);
      // Get the objects we know of
      for (size_t i = 0; i < tc->linkColNames().size(); ++i) ATH_CHECK(checkTrigCompositeElementLink(tc, i));
    }
  }
  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigCompositeContainer DUMP===========" );
  return StatusCode::SUCCESS;
}

dumpTrigEFBphysContainer()

StatusCode TrigEDMChecker::dumpTrigEFBphysContainer ( )

private

Definition at line 2343 of file TrigEDMChecker.cxx.

                                                    {
 
  ATH_MSG_DEBUG("in dumpTrigEFBphysContainer()");
 
  ATH_MSG_INFO("REGTEST ==========START of TrigEFBphysContainer DUMP===========");
 
  std::string EFBphysTags[]={"HLT_xAOD__TrigBphysContainer_EFBMuMuFex",
                             "HLT_xAOD__TrigBphysContainer_EFBMuMuXFex",
                             "HLT_xAOD__TrigBphysContainer_EFDsPhiPiFex",
                             "HLT_xAOD__TrigBphysContainer_EFMuPairs",
                             "HLT_xAOD__TrigBphysContainer_EFMultiMuFex",
                             "HLT_xAOD__TrigBphysContainer_EFTrackMass"
  };
 
  int ntag= (int) sizeof(EFBphysTags) / sizeof(EFBphysTags[0]);
 
 
  for (int itag=0; itag<ntag; itag++){
    const xAOD::TrigBphysContainer*  trigEFBphys;
    StatusCode sc = evtStore()->retrieve(trigEFBphys, EFBphysTags[itag]);
    if (sc.isFailure()) {
      ATH_MSG_INFO("REGTEST No TrigEFBphysContainer found with tag " << EFBphysTags[itag]);
      continue;
    }
 
    ATH_MSG_INFO("REGTEST TrigEFBphysContainer found with tag " << EFBphysTags[itag]
                 << " and size " << trigEFBphys->size());
 
    //  for (int i=0; trigEFBphys != lastTrigEFBphys; ++trigEFBphys, ++i) {
 
    //mLog << MSG::INFO << "REGTEST Looking at TrigEFBphysContainer " << i << endmsg;
 
    xAOD::TrigBphysContainer::const_iterator EFBphysItr  = trigEFBphys->begin();
    xAOD::TrigBphysContainer::const_iterator EFBphysItrE = trigEFBphys->end();
 
    for (int j=0; EFBphysItr != EFBphysItrE; ++EFBphysItr, ++j ) {
 
      ATH_MSG_INFO("REGTEST Looking at TrigEFBphys " << j);
 
      ATH_MSG_INFO("REGTEST TrigEFBphys->eta() returns " << (*EFBphysItr)->eta());
      ATH_MSG_INFO("REGTEST TrigEFBphys->phi() returns " << (*EFBphysItr)->phi());
      ATH_MSG_INFO("REGTEST TrigEFBphys->mass() returns " << (*EFBphysItr)->mass());
      ATH_MSG_INFO("REGTEST TrigEFBphys->fitmass() returns " << (*EFBphysItr)->fitmass());
      // ATH_MSG_INFO("REGTEST TrigEFBphys->isValid() returns " << (*EFBphysItr)->isValid());
      ATH_MSG_INFO("REGTEST TrigEFBphys->roiId() returns " << (*EFBphysItr)->roiId());
      ATH_MSG_INFO("REGTEST TrigEFBphys->particleType() returns " << (*EFBphysItr)->particleType());
 
      if( (*EFBphysItr)->secondaryDecay() != NULL){
        const xAOD::TrigBphys * psecond =(*EFBphysItr)->secondaryDecay();
        ATH_MSG_INFO("REGTEST Secondary decay info: ");
        ATH_MSG_INFO("REGTEST pSecondDecay->eta() returns " << psecond->eta());
        ATH_MSG_INFO("REGTEST pSecondDecay->phi() returns " << psecond->phi());
        ATH_MSG_INFO("REGTEST pSecondDecay->mass() returns " << psecond->mass());
        ATH_MSG_INFO("REGTEST pSecondDecay->fitmass() returns " << psecond->fitmass());
        // ATH_MSG_INFO("REGTEST pSecondDecay->isValid() returns " << (*EFBphysItr)->secondaryDecayLink()->isValid());
        ATH_MSG_INFO("REGTEST pSecondDecay->roiId() returns " << psecond->roiId());
        ATH_MSG_INFO("REGTEST pSecondDecay->particleType() returns " << psecond->particleType());
 
      } // end if secondary exists
 
 
 
      const std::vector<ElementLink<xAOD::TrackParticleContainer> > trackVector = (*EFBphysItr)->trackParticleLinks();
      if (trackVector.size() != 0) {
        ATH_MSG_INFO(" REGTEST got track vector size: " << trackVector.size());
      } else {
        ATH_MSG_INFO(" REGTEST no track vector!!! " );
      }
      std::vector<ElementLink<xAOD::TrackParticleContainer> >::const_iterator trkIt=trackVector.begin();
      for (int itrk=0 ; trkIt!= trackVector.end(); ++itrk, ++trkIt) {
        if (!(trkIt->isValid())) {
          ATH_MSG_WARNING("TrackParticleContainer::Invalid ElementLink to track ");
          continue;
        }
        //const Trk::Perigee* trackPerigee=(*(*trkIt))->measuredPerigee();
        const Trk::Perigee* trackPerigee=&((*(*trkIt))->perigeeParameters());
 
        //      msg() << MSG::VERBOSE << "track, iterator, pointer " << itrk << " " << *trkIt << " " << *(*trkIt) << endmsg;
        double phi = trackPerigee->parameters()[Trk::phi];
        double theta = trackPerigee->parameters()[Trk::theta];
        double px = trackPerigee->momentum()[Trk::px];
        double py = trackPerigee->momentum()[Trk::py];
        double pt = sqrt(px*px + py*py);
        double eta = -std::log(tan(theta/2));
 
        ATH_MSG_INFO("track " << itrk << " pt phi eta " << pt << " " <<
                     phi << " " << eta);
      }
 
    }
  }
  ATH_MSG_INFO("REGTEST ==========END of TrigEFBphysContainer DUMP===========");
  ATH_MSG_DEBUG("dumpTrigEFBphysContainer() succeeded");
 
  return StatusCode::SUCCESS;
}

dumpTrigInDetTrackCollection()

StatusCode TrigEDMChecker::dumpTrigInDetTrackCollection ( )

private

Definition at line 2139 of file TrigEDMChecker.cxx.

                                                        {
 
  std::string TrigInDetTrackTags[]={ "HLT_TrigIDSCAN_Jet",
                                     "HLT_TrigIDSCAN_Tau",
                                     "HLT_TrigIDSCAN_eGamma",
                                     "HLT_TrigIDSCAN_Muon",
                                     "HLT_TrigIDSCAN_muonIso",
                                     "HLT_TrigIDSCAN_Bphysics",
                                     "HLT_TrigIDSCAN_FullScan",
                                     "HLT_TrigIDSCAN_Cosmics",
                                     "HLT_TrigIDSCAN_eGamma_Brem",
                                     "HLT_TrigIDSCAN_Tile",
                                     "HLT_TrigSiTrack_eGamma",
                                     "HLT_TrigSiTrack_Muon",
                                     "HLT_TrigSiTrack_muonIso",
                                     "HLT_TrigSiTrack_Tau",
                                     "HLT_TrigSiTrack_Jet",
                                     "HLT_TrigSiTrack_Bphysics",
                                     "HLT_TrigSiTrack_FullScan",
                                     "HLT_TrigSiTrack_Cosmics",
                                     "HLT_TRTSegmentFinder",
                                     "HLT_TRTxK"};
  int ntag=20;
 
  ATH_MSG_DEBUG("in dumpTrigInDetTrackCollection()");
 
  const TrigInDetTrackTruthMap* pTruthMap(nullptr);
  bool gotTruthMap = false;
 
  if (evtStore()->contains<TrigInDetTrackTruthMap>("TrigInDetTrackTruthMap")) {
    StatusCode sc=evtStore()->retrieve(pTruthMap,"TrigInDetTrackTruthMap");
    if (sc.isFailure())
      {
        ATH_MSG_WARNING(" could not retrieve TrackTruthMap with key TrigInDetTruthMap");
      } else {
      gotTruthMap=true;
      //      pTruthMap->print();
    }
  }
  else ATH_MSG_DEBUG(" didn't find any TrackTruthMap objects with key TrigInDetTruthMap");
 
  ATH_MSG_INFO("REGTEST ==========START of TrigInDetTrackCollection DUMP===========");
 
  for (int iTag=0; iTag < ntag; iTag++) {
    const TrigInDetTrackCollection* trigInDetTrackCollection = nullptr;
    StatusCode sc = evtStore()->retrieve(trigInDetTrackCollection,TrigInDetTrackTags[iTag] );
    if (sc.isFailure()) {
      ATH_MSG_DEBUG("REGTEST No TrigInDetTrackCollection found with key " << TrigInDetTrackTags[iTag]);
      continue;
    }
    ATH_MSG_INFO("REGTEST TrigInDetTrackCollections retrieved with key "
                 << TrigInDetTrackTags[iTag]);
 
    ATH_MSG_INFO("REGTEST TrigInDetTrackCollection->size() returns " << trigInDetTrackCollection->size());
 
    TrigInDetTrackCollection::const_iterator trkItr  = trigInDetTrackCollection->begin();
    TrigInDetTrackCollection::const_iterator trkItrE = trigInDetTrackCollection->end();
 
    for (int j=0; trkItr != trkItrE; ++trkItr, ++j ) {
 
      ATH_MSG_INFO("REGTEST Looking at TrigInDetTrack " << j);
 
      ATH_MSG_INFO("REGTEST TrigInDetTrack->algorithmId() returns " << (*trkItr)->algorithmId());
      ATH_MSG_INFO("REGTEST TrigInDetTrack->chi2() returns " << (*trkItr)->chi2());
      ATH_MSG_INFO("REGTEST TrigInDetTrack->NStrawHits() returns " << (*trkItr)->NStrawHits());
 
      ATH_MSG_INFO("REGTEST TrigInDetTrack->NStraw() returns " << (*trkItr)->NStraw());
      ATH_MSG_INFO("REGTEST TrigInDetTrack->NStrawTime() returns " << (*trkItr)->NStrawTime());
      ATH_MSG_INFO("REGTEST TrigInDetTrack->NTRHits() returns " << (*trkItr)->NTRHits());
 
      ATH_MSG_INFO("REGTEST Looking at TrigInDetFitTrack->param()");
      const TrigInDetTrackFitPar* my_param = (*trkItr)->param();
 
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->a0() returns " << my_param->a0());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->z0() returns " << my_param->z0());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->phi0() returns " << my_param->phi0());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->eta() returns " << my_param->eta());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->pT() returns " << my_param->pT());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ea0() returns " << my_param->ea0());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ez0() returns " << my_param->ez0());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ephi0() returns " << my_param->ephi0());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->eeta() returns " << my_param->eeta());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->epT() returns " << my_param->epT());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->surfaceType() returns " << my_param->surfaceType());
      ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->surfaceCoordinate() returns " << my_param->surfaceCoordinate());
      ATH_MSG_INFO("REGTEST Looking at covarience matrix: ");
 
      const std::vector<double>* const my_cov = my_param->cov();
      if (!my_cov) {
        ATH_MSG_INFO("REGTEST covarience matrix NULL (not stored)");
      } else {
        std::vector<double> tempcov = *my_cov;
        std::vector<double>::iterator iter;
        int k;
        for(iter = tempcov.begin(), k=0; iter != tempcov.end(); ++iter, ++k){
          ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->cov() element " << k << " is " << (*iter));
        }
      }
      if (gotTruthMap) {
        if (!(pTruthMap->hasTruth((*trkItr)))) {
          ATH_MSG_DEBUG(" REGTEST Track has no truth info  ");
        } else {
          ATH_MSG_DEBUG(" Track has truth info:  ");
          const TrigInDetTrackTruth* pTRTtruth = pTruthMap->truth((*trkItr));
          int nMatches = pTRTtruth->nrMatches() ;
          if (nMatches==0) {
            ATH_MSG_INFO(" REGTEST Track has no truth matches");
          } else {
            ATH_MSG_INFO("REGTEST number of matched truth hits: Si: " <<  pTruthMap->bestMatchSiHits((*trkItr))
                         << " TRT: " <<   pTruthMap->bestMatchTRTHits((*trkItr)));
            if (pTruthMap->bestMatchSiHits((*trkItr)) > 0) {
 
              const HepMcParticleLink* pSiTruth = pTruthMap->bestMatchSi((*trkItr));
 
              ATH_MSG_INFO("REGTEST Si match to kine ref " <<  pSiTruth->barcode());
              if (pSiTruth->cptr() != 0) {
                ATH_MSG_INFO("REGTEST Si PDG id " << pSiTruth->cptr()->pdg_id());
              }
            }
 
            if (pTruthMap->bestMatchTRTHits((*trkItr)) > 0) {
              const HepMcParticleLink* pTRTtruth = pTruthMap->bestMatchTRT((*trkItr));
 
              ATH_MSG_INFO("REGTEST TRT match to kine ref " <<  pTRTtruth->barcode());
              if (pTRTtruth->cptr() != 0) {
                ATH_MSG_INFO("REGTEST TRT PDG id " << pTRTtruth->cptr()->pdg_id());
              }
            }
          }
        }
      } // if (gotTruthMap)
    }
  }
 
  ATH_MSG_INFO("REGTEST ==========END of TrigInDetTrackCollection DUMP===========");
  ATH_MSG_DEBUG("dumpTrigInDetTrackCollection() succeeded");
 
  return StatusCode::SUCCESS;
}

dumpTrigL2BphysContainer()

StatusCode TrigEDMChecker::dumpTrigL2BphysContainer ( )

private

Definition at line 2441 of file TrigEDMChecker.cxx.

                                                    {
 
  ATH_MSG_DEBUG("in dumpTrigL2BphysContainer()");
  ATH_MSG_INFO("REGTEST ==========START of TrigL2BphysContainer DUMP===========");
 
  std::string L2BphysTags[]={"HLT_xAOD__TrigBphysContainer_L2BMuMuFex",
                             "HLT_xAOD__TrigBphysContainer_L2BMuMuXFex",
                             "HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexDs",
                             "HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexPhi",
                             "HLT_xAOD__TrigBphysContainer_L2JpsieeFex",
                             "HLT_xAOD__TrigBphysContainer_L2MultiMuFex",
                             "HLT_xAOD__TrigBphysContainer_L2TrackMass",
  };
  const int ntag = (int) sizeof(L2BphysTags) / sizeof(L2BphysTags[0]);
 
 
  for (int itag=0; itag<ntag; itag++){
    const xAOD::TrigBphysContainer*  trigL2Bphys;
    StatusCode sc = evtStore()->retrieve(trigL2Bphys, L2BphysTags[itag]);
    if (sc.isFailure()) {
      ATH_MSG_INFO("REGTEST No TrigL2BphysContainer found with tag " << L2BphysTags[itag]);
      continue;
    }
 
    ATH_MSG_INFO("REGTEST TrigL2BphysContainer found with tag " << L2BphysTags[itag]
                 << " and size " << trigL2Bphys->size());
 
    //  for (int i=0; trigL2Bphys != lastTrigL2Bphys; ++trigL2Bphys, ++i) {
 
    // mLog << MSG::INFO << "REGTEST Looking at TrigL2BphysContainer " << i << endmsg;
 
    xAOD::TrigBphysContainer::const_iterator L2BphysItr  = trigL2Bphys->begin();
    xAOD::TrigBphysContainer::const_iterator L2BphysItrE = trigL2Bphys->end();
 
    for (int j=0; L2BphysItr != L2BphysItrE; ++L2BphysItr, ++j ) {
 
      ATH_MSG_INFO("REGTEST Looking at TrigL2Bphys " << j);
 
      ATH_MSG_INFO("REGTEST TrigL2Bphys->eta() returns " << (*L2BphysItr)->eta());
      ATH_MSG_INFO("REGTEST TrigL2Bphys->phi() returns " << (*L2BphysItr)->phi());
      ATH_MSG_INFO("REGTEST TrigL2Bphys->mass() returns " << (*L2BphysItr)->mass());
      ATH_MSG_INFO("REGTEST TrigL2Bphys->fitmass() returns " << (*L2BphysItr)->fitmass());
      // ATH_MSG_INFO("REGTEST TrigL2Bphys->isValid() returns " << (*L2BphysItr)->isValid());
      ATH_MSG_INFO("REGTEST TrigL2Bphys->roiId() returns " << (*L2BphysItr)->roiId());
      ATH_MSG_INFO("REGTEST TrigL2Bphys->particleType() returns " << (*L2BphysItr)->particleType());
 
      if( (*L2BphysItr)->secondaryDecay() != NULL){
        const xAOD::TrigBphys * psecond =(*L2BphysItr)->secondaryDecay();
        ATH_MSG_INFO("REGTEST Secondary decay info: ");
        ATH_MSG_INFO("REGTEST pSecondDecay->eta() returns " << psecond->eta());
        ATH_MSG_INFO("REGTEST pSecondDecay->phi() returns " << psecond->phi());
        ATH_MSG_INFO("REGTEST pSecondDecay->mass() returns " << psecond->mass());
        ATH_MSG_INFO("REGTEST pSecondDecay->fitmass() returns " << psecond->fitmass());
        // ATH_MSG_INFO("REGTEST pSecondDecay->isValid() returns " << (*L2BphysItr)->secondaryDecayLink()->isValid());
        ATH_MSG_INFO("REGTEST pSecondDecay->roiId() returns " << psecond->roiId());
        ATH_MSG_INFO("REGTEST pSecondDecay->particleType() returns " << psecond->particleType());
      } // end if secondary exists
 
      const std::vector<ElementLink<xAOD::TrackParticleContainer> > trackVector = (*L2BphysItr)->trackParticleLinks();
      if (trackVector.size() != 0) {
        ATH_MSG_INFO(" REGTEST got track vector size: " << trackVector.size());
      } else {
        ATH_MSG_INFO(" REGTEST no track vector!!! " );
      }
      std::vector<ElementLink<xAOD::TrackParticleContainer> >::const_iterator trkIt=trackVector.begin();
      for (int itrk=0 ; trkIt!= trackVector.end(); ++itrk, ++trkIt) {
        if (!(trkIt->isValid())) {
          ATH_MSG_WARNING("TrackParticleContainer::Invalid ElementLink to track ");
          continue;
        }
        //const Trk::Perigee* trackPerigee=(*(*trkIt))->measuredPerigee();
        const Trk::Perigee* trackPerigee=&((*(*trkIt))->perigeeParameters());
 
        //      msg() << MSG::VERBOSE << "track, iterator, pointer " << itrk << " " << *trkIt << " " << *(*trkIt) << endmsg;
        double phi = trackPerigee->parameters()[Trk::phi];
        double theta = trackPerigee->parameters()[Trk::theta];
        double px = trackPerigee->momentum()[Trk::px];
        double py = trackPerigee->momentum()[Trk::py];
        double pt = sqrt(px*px + py*py);
        double eta = -std::log(tan(theta/2));
        
        ATH_MSG_INFO("track " << itrk << " pt phi eta " << pt << " " <<
                     phi << " " << eta);
      }
    }
  }
 
  ATH_MSG_INFO("REGTEST ==========END of TrigL2BphysContainer DUMP===========");
  ATH_MSG_DEBUG("dumpTrigL2BphysContainer() succeeded");
 
  return StatusCode::SUCCESS;
}

dumpTrigPassBits()

StatusCode TrigEDMChecker::dumpTrigPassBits ( )

private

Definition at line 582 of file TrigEDMChecker.cxx.

                                           {
    const std::string name="HLT_xAOD__TrigPassBitsContainer_passbits";
    const xAOD::TrigPassBitsContainer *xbitscont=nullptr;
    StatusCode sc = evtStore()->retrieve(xbitscont,name);
    if (sc.isFailure() ){
        ATH_MSG_INFO("Cannot retrieve TrigPassBits");
    }
    else {
        ATH_MSG_INFO("Size of PassBits container : " << xbitscont->size());
        for(const auto bits:*xbitscont){
            if(bits==nullptr){
                ATH_MSG_INFO("TrigPassBits point nullptr ");
                continue;
            }
            ATH_MSG_DEBUG("Analyzing bits for " << bits->containerClid() << " of size " << bits->size() << " with bit size " << bits->passBits().size());
        }
        xAOD::TrigPassBitsContainer::const_iterator itr  = xbitscont->begin();
        xAOD::TrigPassBitsContainer::const_iterator itrE = xbitscont->end();
 
        for (int j=0; itr != itrE; ++itr, ++j ) {
            const xAOD::TrigPassBits * bits = (*itr);
            if(bits==nullptr){
                ATH_MSG_INFO("TrigPassBits point nullptr ");
                continue;
            }
            ATH_MSG_DEBUG("Analyzing bits for " << bits->containerClid() << " of size " << bits->size() << " with bit size " << bits->passBits().size());
        }
    }
    return StatusCode::SUCCESS;
}

dumpTrigSpacePointCounts()

void TrigEDMChecker::dumpTrigSpacePointCounts ( )

private

Definition at line 613 of file TrigEDMChecker.cxx.

{
    ATH_MSG_INFO("MinBias in dumpTrigSpacePointCounts()");
 
    std::string METTag="HLT_xAOD__TrigSpacePointCountsContainer_spacepoints";
 
    const xAOD::TrigSpacePointCountsContainer* SpacePointCountsCont=0;
    StatusCode sc = evtStore()->retrieve(SpacePointCountsCont,METTag);
 
    if (sc.isFailure())
      ATH_MSG_INFO("failed to retrieve " << METTag);
    else {
      ATH_MSG_INFO("Accessing " << METTag << " with " << SpacePointCountsCont->size() << " elements");
      
      std::string s; char buff[128];
      std::vector<float> getVec;
      float sum;
      
      // Loop over container content
      for(uint i = 0; i < SpacePointCountsCont->size(); i++) {
        getVec = SpacePointCountsCont->at(i)->contentsPixelClusEndcapC();
        sum = 0.;
        for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
        snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusEndcapC() =         %10.2f ", s.c_str(), sum );
        ATH_MSG_INFO(buff);
        
        getVec = SpacePointCountsCont->at(i)->contentsPixelClusBarrel();
        sum = 0.;
        for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
        snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusBarrel() =         %10.2f ", s.c_str(), sum );
        ATH_MSG_INFO(buff);
        
        getVec = SpacePointCountsCont->at(i)->contentsPixelClusEndcapA();
        sum = 0.;
        for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
        snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusEndcapA() =         %10.2f ", s.c_str(), sum );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotBins() =        %u ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotBins() );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotMin() =        %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotMin() );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotMax() =        %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotMax() );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeBins() =        %u ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeBins() );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeMin()  =        %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeMin() );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeMax() =        %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeMax() );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s sctSpEndcapC() =        %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpEndcapC() );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s sctSpBarrel() =        %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpBarrel() );
        ATH_MSG_INFO(buff);
        
        snprintf(buff, sizeof(buff), "REGTEST %s sctSpEndcapA() =        %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpEndcapA() );
        ATH_MSG_INFO(buff);
      }
    }
}

dumpTrigT2MBTSBits()

void TrigEDMChecker::dumpTrigT2MBTSBits ( )

private

Definition at line 681 of file TrigEDMChecker.cxx.

                                       {
  ATH_MSG_INFO("MinBias in dumpTrigT2MBTSBits()");
 
  std::string METTag="HLT_xAOD__TrigT2MbtsBitsContainer_T2Mbts";
 
  const xAOD::TrigT2MbtsBitsContainer* T2MbtsBitsCont=0;
  StatusCode sc = evtStore()->retrieve(T2MbtsBitsCont,METTag);
 
  if (sc.isFailure())
    ATH_MSG_INFO("failed to retrieve " << METTag);
  else {
    ATH_MSG_INFO("Accessing " << METTag << " with " << T2MbtsBitsCont->size() << " elements");
 
    std::string s; char buff[380];
    std::vector<float> getVec;
    float sum;
 
    // Loop over container content
    for(uint i = 0; i < T2MbtsBitsCont->size(); i++) {
      getVec = T2MbtsBitsCont->at(i)->triggerEnergies();
      sum = 0.;
      for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
      snprintf(buff, sizeof(buff), "REGTEST %s SUM of triggerEnergies() =         %10.2f ", s.c_str(), sum );
      ATH_MSG_INFO(buff);
 
      getVec = T2MbtsBitsCont->at(i)->triggerTimes();
      sum = 0.;
      for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
      snprintf(buff, sizeof(buff), "REGTEST %s SUM of triggerTimes() =         %10.2f ", s.c_str(), sum );
      ATH_MSG_INFO(buff);
    }
  }
}

dumpTrigTrackCounts()

void TrigEDMChecker::dumpTrigTrackCounts ( )

private

Definition at line 749 of file TrigEDMChecker.cxx.

                                        {
  ATH_MSG_INFO("MinBias in dumpTrigTrackCounts()");
 
  std::string METTag="HLT_xAOD__TrigTrackCountsContainer_trackcounts";
 
  const xAOD::TrigTrackCountsContainer* T2TrackCountsCont=0;
  StatusCode sc = evtStore()->retrieve(T2TrackCountsCont,METTag);
 
  if (sc.isFailure())
    ATH_MSG_INFO("failed to retrieve " << METTag);
  else {
    ATH_MSG_INFO("Accessing " << METTag << " with " << T2TrackCountsCont->size() << " elements");
 
    std::string s; char buff[380];
    std::vector<float> getVec;
    float sum;
 
    // Loop over container content
    for(uint i = 0; i < T2TrackCountsCont->size(); i++) {
      getVec = T2TrackCountsCont->at(i)->z0_pt();
      sum = 0.;
      for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
      snprintf(buff, sizeof(buff), "REGTEST %s SUM of z0_pt =         %10.2f ", s.c_str(), sum );
      ATH_MSG_INFO(buff);
 
      getVec = T2TrackCountsCont->at(i)->eta_phi();
      sum = 0.;
      for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
      snprintf(buff, sizeof(buff), "REGTEST %s SUM of eta_phi() =         %10.2f ", s.c_str(), sum );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s z0Bins() =        %u ", s.c_str(), T2TrackCountsCont->at(i)->z0Bins() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s z0Min() =        %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->z0Min() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s z0Max() =        %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->z0Max() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s ptBins() =        %u ", s.c_str(), T2TrackCountsCont->at(i)->ptBins() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s ptMin() =        %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->ptMin() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s ptMax() =        %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->ptMax() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s etaBins() =        %u ", s.c_str(), T2TrackCountsCont->at(i)->etaBins() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s etaMin() =        %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->etaMin() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s etaMax() =        %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->etaMax() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s phiBins() =        %u ", s.c_str(), T2TrackCountsCont->at(i)->phiBins() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s phiMin() =        %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->phiMin() );
      ATH_MSG_INFO(buff);
 
      snprintf(buff, sizeof(buff), "REGTEST %s phiMax() =        %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->phiMax() );
      ATH_MSG_INFO(buff);
    }
  }
}

dumpTrigVertexCounts()

void TrigEDMChecker::dumpTrigVertexCounts ( )

private

Definition at line 715 of file TrigEDMChecker.cxx.

                                         {
  ATH_MSG_INFO("MinBias in dumpTrigVertexCounts()");
 
  std::string METTag="HLT_xAOD__TrigVertexCountsContainer_vertexcounts";
 
  const xAOD::TrigVertexCountsContainer* T2VertexCountsCont=0;
  StatusCode sc = evtStore()->retrieve(T2VertexCountsCont,METTag);
 
  if (sc.isFailure())
    ATH_MSG_INFO("failed to retrieve " << METTag);
  else {
    ATH_MSG_INFO("Accessing " << METTag << " with " << T2VertexCountsCont->size() << " elements");
 
    std::string s; char buff[380];
    std::vector<float> fgetVec;
    float fsum(0.);
    std::vector<unsigned int> ugetVec;
    unsigned int usum(0);
 
    // Loop over container content
    for(uint i = 0; i < T2VertexCountsCont->size(); i++) {
      ugetVec = T2VertexCountsCont->at(i)->vtxNtrks();
      for (uint j = 0; j < ugetVec.size(); ++j) usum += ugetVec[j];
      snprintf(buff, sizeof(buff), "REGTEST %s SUM of vtxNtrks() =         %u ", s.c_str(), usum );
      ATH_MSG_INFO(buff);
 
      fgetVec = T2VertexCountsCont->at(i)->vtxTrkPtSqSum();
      for (uint j = 0; j < fgetVec.size(); ++j) fsum += fgetVec[j];
      snprintf(buff, sizeof(buff), "REGTEST %s SUM of vtxTrkPtSqSum() =         %10.2f ", s.c_str(), fsum );
      ATH_MSG_INFO(buff);
    }
  }
}

dumpxAODElectronContainer()

StatusCode TrigEDMChecker::dumpxAODElectronContainer ( )

private

Definition at line 1769 of file TrigEDMChecker.cxx.

                                                     {
 
  ATH_MSG_DEBUG("In dumpxAODElectronContainer");
 
  ATH_MSG_INFO( "REGTEST ==========START of xAOD::ElectronContainer DUMP===========" );
 
  const xAOD::ElectronContainer* elCont=0;
  StatusCode sc = evtStore()->retrieve(elCont,"HLT_xAOD__ElectronContainer_egamma_Electrons");
  if (sc.isFailure()) {
    ATH_MSG_INFO("REGTEST No Electron container HLT_xAOD__ElectronContainer_egamma_Electrons");
    return StatusCode::SUCCESS;
  }
  float val_float=-99;
  unsigned int isEMbit=0;
  bool pid=false;
  //DEBUG output for Egamma container
  ATH_MSG_INFO(" REGTEST: xAOD Reconstruction variables: ");
  //                //Cluster and ShowerShape info
  //
  static const SG::AuxElement::Accessor< float > accLH("LHValue");
  static const SG::AuxElement::Accessor< float > accLHCalo("LHCaloValue");
  for (const auto eg : *elCont){
      //REGTEST printout
      if (eg) {
          ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
          ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
          ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
          if(eg->selectionisEM(isEMbit,"isEMVLoose"))
              ATH_MSG_INFO(" REGTEST: isEMVLoose " << std::hex << isEMbit << std::dec);
          else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
          if(eg->selectionisEM(isEMbit,"isEMLoose"))
              ATH_MSG_INFO(" REGTEST: isEMLoose " << std::hex << isEMbit << std::dec);
          else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
          if(eg->selectionisEM(isEMbit,"isEMMedium"))
              ATH_MSG_INFO(" REGTEST: isEMMedium " << std::hex << isEMbit << std::dec);
          else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
          if(eg->selectionisEM(isEMbit,"isEMTight"))
              ATH_MSG_INFO(" REGTEST: isEMTight " << std::hex << isEMbit << std::dec);
          else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
          if(eg->selectionisEM(isEMbit,"isEMLHVLoose"))
              ATH_MSG_INFO(" REGTEST: isEMLHVLoose " << std::hex << isEMbit << std::dec);
          else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
          if(eg->selectionisEM(isEMbit,"isEMLHLoose"))
              ATH_MSG_INFO(" REGTEST: isEMLHLoose " << std::hex << isEMbit << std::dec);
          else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
          if(eg->selectionisEM(isEMbit,"isEMLHMedium"))
              ATH_MSG_INFO(" REGTEST: isEMLHMedium " << std::hex << isEMbit << std::dec);
          else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
          if(eg->selectionisEM(isEMbit,"isEMLHTight"))
              ATH_MSG_INFO(" REGTEST: isEMLHTight " << std::hex << isEMbit << std::dec);
          else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
          if(accLH.isAvailable(*eg))
              ATH_MSG_INFO(" REGTEST: LHValue " << accLH(*eg));
          else
              ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
          if(accLHCalo.isAvailable(*eg))
              ATH_MSG_INFO(" REGTEST: LHValue " << accLHCalo(*eg));
          else
              ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
          if(eg->passSelection(pid,"LHVLoose"))
              ATH_MSG_INFO(" REGTEST: LHVLoose " << pid); 
          else
              ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
          if(eg->passSelection(pid,"LHLoose"))
              ATH_MSG_INFO(" REGTEST: LHLoose " << pid); 
          else
              ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
          if(eg->passSelection(pid,"LHMedium"))
              ATH_MSG_INFO(" REGTEST: LHMedium " << pid); 
          else
              ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
          if(eg->passSelection(pid,"LHTight"))
              ATH_MSG_INFO(" REGTEST: LHTight " << pid); 
          else
              ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
      } else{
          ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
          return StatusCode::SUCCESS;
      }
      ATH_MSG_INFO(" REGTEST: caloCluster variables ");
      if (eg->caloCluster()) {
          ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
          ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
          ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
          double tmpeta = -999.;
          double tmpphi = -999.;
          eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
          eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi); 
          ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta); 
          ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
      } else{
          ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
      }
      ATH_MSG_INFO("REGTEST: Check the original (uncalibrated)");
      static const SG::AuxElement::Accessor<ElementLink<xAOD::CaloClusterContainer> > orig ("originalCaloCluster");
      if (!orig.isAvailable(*eg->caloCluster()) || !orig(*eg->caloCluster()).isValid()){
          ATH_MSG_INFO("Problem with original cluster link");
      }
      else {
          const xAOD::CaloCluster *origClus = *orig(*eg->caloCluster());
          ATH_MSG_INFO("REGTEST:: Compare new and old clusters");
          ATH_MSG_INFO("REGTEST:: Original Cluster e,eta,phi" << origClus->e() << " " <<  origClus->eta() << " " << origClus->phi());
          ATH_MSG_INFO("REGTEST:: MVA      Cluster e,eta,phi" << eg->caloCluster()->e() << " " <<  eg->caloCluster()->eta() << " " << eg->caloCluster()->phi());
      }
      ATH_MSG_INFO(" REGTEST: trackmatch variables ");
      if(eg->trackParticle()){
          ATH_MSG_INFO(" REGTEST: pt=  " << eg->trackParticle()->pt());
          ATH_MSG_INFO(" REGTEST: charge=  " << eg->trackParticle()->charge());
          ATH_MSG_INFO(" REGTEST: E/p=  " << eg->caloCluster()->et() / eg->trackParticle()->pt() );
          eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaEta1);
          ATH_MSG_INFO(" REGTEST: Delta eta 1st sampling=  " << val_float);
          eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaPhi2);
          ATH_MSG_INFO(" REGTEST: Delta phi 2nd sampling=  " << val_float);
      } else{
          ATH_MSG_INFO(" REGTEST: no electron eg->trackParticle() pointer");
      }
 
      //msg() << MSG::VERBOSE << " REGTEST: cluster variables " << endmsg;
      //clus = eg->caloCluster();
      ATH_MSG_INFO(" REGTEST: EMShower variables ");
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::ethad);
      ATH_MSG_INFO(" REGTEST: ethad    =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e011);
      ATH_MSG_INFO(" REGTEST: e011     =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e132);
      ATH_MSG_INFO(" REGTEST: e132     =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e237);
      ATH_MSG_INFO(" REGTEST: e237     =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e335);
      ATH_MSG_INFO(" REGTEST: e335     =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2ts1);
      ATH_MSG_INFO(" REGTEST: e2ts1    =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2tsts1);
      ATH_MSG_INFO(" REGTEST: e2tsts1  =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::ptcone20);
      ATH_MSG_INFO(" REGTEST: ptcone20   =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::ptcone30);
      ATH_MSG_INFO(" REGTEST: ptcone30   =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::ptcone40);
      ATH_MSG_INFO(" REGTEST: ptcone40   =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::etcone20);
      ATH_MSG_INFO(" REGTEST: etcone20   =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::etcone30);
      ATH_MSG_INFO(" REGTEST: etcone30   =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::etcone40);
      ATH_MSG_INFO(" REGTEST: etcone40   =  " << val_float);
      //DEBUG info for Electrons which by definition have a track match
 
  }
  ATH_MSG_INFO( "REGTEST ==========END of xAOD::ElectronContainer DUMP===========" );
 
  return StatusCode::SUCCESS;
 
}

dumpxAODJetContainer()

StatusCode TrigEDMChecker::dumpxAODJetContainer ( )

private

Definition at line 2538 of file TrigEDMChecker.cxx.

                                                {
    
    ATH_MSG_DEBUG("in dumpxAODJetContainer()");
    
    ATH_MSG_INFO("REGTEST ==========START of xAOD::JetContainer DUMP===========");
    
    std::string containerName[30] = {"HLT_xAOD__JetContainer_a4tcemjesFS",
                                     "HLT_xAOD__JetContainer_a4tcemsubFS",
                                     "HLT_xAOD__JetContainer_a4tcemsubjesFS",
                                     "HLT_xAOD__JetContainer_a4tcemnojcalibFS",
                                     "HLT_xAOD__JetContainer_a4tcemjesPS",
                                     "HLT_xAOD__JetContainer_a4tcemnojcalibPS",
                                     "HLT_xAOD__JetContainer_a4tclcwjesFS",
                                     "HLT_xAOD__JetContainer_a4tclcwsubFS",
                                     "HLT_xAOD__JetContainer_a4tclcwsubjesFS",
                                     "HLT_xAOD__JetContainer_a4tclcwnojcalibFS",
                                     "HLT_xAOD__JetContainer_a4tclcwjesPS",
                                     "HLT_xAOD__JetContainer_a4tclcwnojcalibPS",
                                     "HLT_xAOD__JetContainer_a4TTemnojcalibFS",
                                     "HLT_xAOD__JetContainer_a4TThadnojcalibFS",
                                     "HLT_xAOD__JetContainer_a10tcemjesFS",
                                     "HLT_xAOD__JetContainer_a10tcemsubFS",
                                     "HLT_xAOD__JetContainer_a10tcemsubjesFS",
                                     "HLT_xAOD__JetContainer_a10tcemnojcalibFS",
                                     "HLT_xAOD__JetContainer_a10tcemjesPS",
                                     "HLT_xAOD__JetContainer_a10tcemnojcalibPS",
                                     "HLT_xAOD__JetContainer_a10tclcwjesFS",
                                     "HLT_xAOD__JetContainer_a10tclcwsubFS",
                                     "HLT_xAOD__JetContainer_a10tclcwsubjesFS",
                                     "HLT_xAOD__JetContainer_a10tclcwnojcalibFS",
                                     "HLT_xAOD__JetContainer_a10tclcwjesPS",
                                     "HLT_xAOD__JetContainer_a10tclcwnojcalibPS",
                                     "HLT_xAOD__JetContainer_a10TTemnojcalibFS",
                                     "HLT_xAOD__JetContainer_a10TThadnojcalibFS",
                                     "HLT_xAOD__JetContainer_a10r_tcemsubjesFS",
                                     "HLT_xAOD__JetContainer_TrigHLTJetDSSelectorCollection"};
    float containerSizeParameter[30] = {0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4, 0.4,
        1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.4};
    int containerInputType[30] = {1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2,
        1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2, 1, 1};
    int containerSignalState[30] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1,
        0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0};
    bool onefilled = false;
    
    for (int icont=0; icont<30; ++icont) {
        //retrieve jet collection
        const xAOD::JetContainer* jetCont = 0;
        StatusCode sc = evtStore()->retrieve(jetCont, containerName[icont]) ;
        
        if (sc.isFailure()) {
            ATH_MSG_WARNING("REGTEST Cannot retrieve jet container");
            continue;
        }
        
        int jetContsize = jetCont->size();
        ATH_MSG_INFO("REGTEST Got jet container " << containerName[icont] << ", size: " << jetContsize);
        if (jetContsize != 0) {
            onefilled = true;
            int i = 0;
            for(const auto thisjet : *jetCont) {
                ++i;
                ATH_MSG_INFO( "REGTEST Looking at jet " << i);
                if (thisjet) {
                    //checks jet variables
                    ATH_MSG_DEBUG("REGTEST    Checking jet variables");
                    ATH_MSG_INFO( "REGTEST    pt: " << thisjet->pt() );
                    ATH_MSG_INFO( "REGTEST    eta: " << thisjet->eta() );
                    ATH_MSG_INFO( "REGTEST    phi: " << thisjet->phi() );
                    ATH_MSG_INFO( "REGTEST    m: " << thisjet->m() );
                    ATH_MSG_INFO( "REGTEST    e: " << thisjet->e() );
                    ATH_MSG_INFO( "REGTEST    rapidity: " << thisjet->rapidity() );
                    ATH_MSG_INFO( "REGTEST    px: " << thisjet->px() );
                    ATH_MSG_INFO( "REGTEST    py: " << thisjet->py() );
                    ATH_MSG_INFO( "REGTEST    pz: " << thisjet->pz() );
                    ATH_MSG_INFO( "REGTEST    type: " << thisjet->type() );
                    ATH_MSG_INFO( "REGTEST    algorithm (kt: 0, cam: 1, antikt: 2, ...): " << thisjet->getAlgorithmType() << "; should be 2");
                    if(thisjet->getAlgorithmType() != 2) ATH_MSG_WARNING("Jet algorithm different from container");
                    ATH_MSG_INFO( "REGTEST    size parameter: " << thisjet->getSizeParameter() << "; should be " << containerSizeParameter[icont]);
                    if(thisjet->getSizeParameter() != containerSizeParameter[icont]) ATH_MSG_WARNING("Jet size different from container");
                    ATH_MSG_INFO( "REGTEST    input (LCTopo: 0, EMTopo: 1, TopoTower: 2, ...): " << thisjet->getInputType() << "; should be " << containerInputType[icont]);
                    if(thisjet->getInputType() != containerInputType[icont]) ATH_MSG_WARNING("Jet input different from container");
                    ATH_MSG_INFO( "REGTEST    constituents signal state (uncalibrated: 0, calibrated: 1): " << thisjet->getConstituentsSignalState() << "; should be " << containerSignalState[icont]);
                    if(thisjet->getConstituentsSignalState() != containerSignalState[icont]) ATH_MSG_WARNING("Jet constituents' signal state different from container");
                    ATH_MSG_INFO( "REGTEST    number of constituents: " << thisjet->numConstituents() );
                    
                    
                    //checks the constituents
                    ATH_MSG_DEBUG("REGTEST    Checking jet constituents");
                    
                    xAOD::JetConstituentVector constitCont = thisjet->getConstituents();
                    unsigned int constitContsize = constitCont.size();
                    ATH_MSG_INFO("REGTEST    Got constituent vector, size: " << constitContsize << "; should be " << thisjet->numConstituents());
                    if(constitContsize != thisjet->numConstituents()) ATH_MSG_WARNING("Constituents container size different from number of constituents");
                    
                    if (constitContsize != 0) {
//                        int j = 0;
                        //                        for (const auto thisconstit : constitCont) {
                        //                            ++j;
                        //                            ATH_MSG_INFO( "REGTEST    Looking at constituent " << j);
                        //                            if(thisconstit){
                        //                                ATH_MSG_INFO( "REGTEST        constituent pt: " << thisconstit->pt() );
                        //                                ATH_MSG_INFO( "REGTEST        constituent eta: " << thisconstit->eta() );
                        //                                ATH_MSG_INFO( "REGTEST        constituent phi: " << thisconstit->phi() );
                        //                                ATH_MSG_INFO( "REGTEST        constituent m: " << thisconstit->m() );
                        //                                ATH_MSG_INFO( "REGTEST        constituent e: " << thisconstit->e() );
                        //                                ATH_MSG_INFO( "REGTEST        constituent type (CaloCluster: 1, Jet: 2, ...): " << thisconstit->type() );
                        //                            }
                        //                            else{
                        //                                ATH_MSG_WARNING("REGTEST Problem with constituent pointer");
                        //                                return StatusCode::SUCCESS;
                        //                            }
                        //                        }
                        //                        ATH_MSG_INFO("REGTEST        size of constituent vector == number of displayed constituents: "<< (constitContsize == j) );
                        //                        if (constitContsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                    }
                    //                    else ATH_MSG_WARNING("REGTEST    This jet has 0 constituents!");
                    
                    //checks int attributes
                    ATH_MSG_DEBUG("REGTEST    Checking int attributes");
                    int valueint;
                    if( thisjet->getAttribute(xAOD::JetAttribute::GhostMuonSegmentCount, valueint))    ATH_MSG_INFO("REGTEST    GhostMuonSegmentCount: " << valueint);
                    if( thisjet->getAttribute(xAOD::JetAttribute::GhostTrackCount, valueint))          ATH_MSG_INFO("REGTEST    GhostTrackCount: " << valueint);
                    if( thisjet->getAttribute(xAOD::JetAttribute::GhostTruthParticleCount, valueint))  ATH_MSG_INFO("REGTEST    GhostTruthParticleCount: " << valueint);
                    if( thisjet->getAttribute(xAOD::JetAttribute::FracSamplingMaxIndex, valueint))   ATH_MSG_INFO( "REGTEST    FracSamplingMaxIndex: " << valueint);
                    
                    
                    //checks float attributes
                    ATH_MSG_DEBUG("REGTEST    Checking float attributes");
                    float value;
                    if( thisjet->getAttribute(xAOD::JetAttribute::ActiveArea, value))        ATH_MSG_INFO( "REGTEST    ActiveArea: " << value );
                    // Four-vector type                   if( thisjet->getAttribute(xAOD::JetAttribute::ActiveArea4vec, value))        ATH_MSG_INFO( "REGTEST    ActiveArea4vec: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::AverageLArQF, value))      ATH_MSG_INFO( "REGTEST    AverageLArQF: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrCell, value))       ATH_MSG_INFO( "REGTEST    BchCorrCell: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrDotx, value))       ATH_MSG_INFO( "REGTEST    BchCorrDotx: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrJet, value))        ATH_MSG_INFO( "REGTEST    BchCorrJet: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrJetForCell, value)) ATH_MSG_INFO( "REGTEST    BchCorrJetForCell: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::CentroidR, value))         ATH_MSG_INFO( "REGTEST    CentroidR: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::HECQuality, value))        ATH_MSG_INFO( "REGTEST    HECQuality: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::IsoKR20Par, value))        ATH_MSG_INFO( "REGTEST    IsoKR20Par: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::IsoKR20Perp, value))       ATH_MSG_INFO( "REGTEST    IsoKR20Perp: " << value );
                    // ElementLink<DataVector<xAOD::Vertex> > type                    if( thisjet->getAttribute(xAOD::JetAttribute::HighestJVFVtx, value))       ATH_MSG_INFO( "REGTEST    HighestJVFVtx: " << value );
                    // ??? type                    if( thisjet->getAttribute(xAOD::JetAttribute::JetLabel, value))       ATH_MSG_INFO( "REGTEST    JetLabel: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::KtDR, value))              ATH_MSG_INFO( "REGTEST    KtDR: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::LArBadHVEnergy, value))    ATH_MSG_INFO( "REGTEST    LArBadHVEnergy: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::LArBadHVRatio, value))     ATH_MSG_INFO( "REGTEST    LArBadHVRatio: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::LArQuality, value))        ATH_MSG_INFO( "REGTEST    LArQuality: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::NegativeE, value))         ATH_MSG_INFO( "REGTEST    NegativeE: " << value );
                    // no tools available yet                    if( thisjet->getAttribute(xAOD::JetAttribute::NumTowers, value))         ATH_MSG_INFO( "REGTEST    NumTowers: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::SamplingMax, value))       ATH_MSG_INFO( "REGTEST    SamplingMax: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Timing, value))            ATH_MSG_INFO( "REGTEST    Timing: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiArea, value))       ATH_MSG_INFO( "REGTEST    VoronoiArea: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaE, value))      ATH_MSG_INFO( "REGTEST    VoronoiAreaE: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPx, value))     ATH_MSG_INFO( "REGTEST    VoronoiAreaPx: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPy, value))     ATH_MSG_INFO( "REGTEST    VoronoiAreaPy: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPz, value))     ATH_MSG_INFO( "REGTEST    VoronoiAreaPz: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Width, value))             ATH_MSG_INFO( "REGTEST    WIDTH: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::FracSamplingMax, value))   ATH_MSG_INFO( "REGTEST    FracSamplingMax: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::EMFrac, value))            ATH_MSG_INFO( "REGTEST    EMFrac: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::HECFrac, value))           ATH_MSG_INFO( "REGTEST    HECFrac: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::isBadLoose, value))        ATH_MSG_INFO( "REGTEST    isBadLoose: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::isBadMedium, value))       ATH_MSG_INFO( "REGTEST    isBadMedium: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::isBadTight, value))        ATH_MSG_INFO( "REGTEST    isBadTight: " << value );
                    // unknown attribute                   if( thisjet->getAttribute(xAOD::JetAttribute::isUgly, value))            ATH_MSG_INFO( "REGTEST    isUgly: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::N90Constituents, value))   ATH_MSG_INFO( "REGTEST    N90Constituents: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::N90Cells, value))          ATH_MSG_INFO( "REGTEST    N90Cells: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::OotFracClusters10, value)) ATH_MSG_INFO( "REGTEST    OotFracClusters10: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::OotFracClusters5, value))  ATH_MSG_INFO( "REGTEST    OotFracClusters5: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::OotFracCells5, value))     ATH_MSG_INFO( "REGTEST    OotFracCells5: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::OotFracCells10, value))    ATH_MSG_INFO( "REGTEST    OotFracCells10: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::PtTruth, value))    ATH_MSG_INFO( "REGTEST    PtTruth: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Tau1, value))              ATH_MSG_INFO( "REGTEST    Tau1: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Tau2, value))              ATH_MSG_INFO( "REGTEST    Tau2: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Tau3, value))              ATH_MSG_INFO( "REGTEST    Tau3: " << value );
                    // unknown attribute                  if( thisjet->getAttribute(xAOD::JetAttribute::Split12, value))           ATH_MSG_INFO( "REGTEST    Split12: " << value );
                    // unknown attribute                   if( thisjet->getAttribute(xAOD::JetAttribute::Split23, value))           ATH_MSG_INFO( "REGTEST    Split23: " << value );
                    // unknown attribute                   if( thisjet->getAttribute(xAOD::JetAttribute::Split34, value))           ATH_MSG_INFO( "REGTEST    Split34: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Dip12, value))             ATH_MSG_INFO( "REGTEST    Dip12: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Dip13, value))             ATH_MSG_INFO( "REGTEST    Dip13: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Dip23, value))             ATH_MSG_INFO( "REGTEST    Dip23: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::DipExcl12, value))         ATH_MSG_INFO( "REGTEST    DipExcl12: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::ThrustMin, value))         ATH_MSG_INFO( "REGTEST    ThrustMin: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::ThrustMaj, value))         ATH_MSG_INFO( "REGTEST    ThrustMaj: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram0, value))       ATH_MSG_INFO( "REGTEST    FoxWolfram0: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram1, value))       ATH_MSG_INFO( "REGTEST    FoxWolfram1: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram2, value))       ATH_MSG_INFO( "REGTEST    FoxWolfram2: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram3, value))       ATH_MSG_INFO( "REGTEST    FoxWolfram3: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram4, value))       ATH_MSG_INFO( "REGTEST    FoxWolfram4: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Sphericity, value))        ATH_MSG_INFO( "REGTEST    Sphericity: " << value );
                    if( thisjet->getAttribute(xAOD::JetAttribute::Aplanarity, value))        ATH_MSG_INFO( "REGTEST    Aplanarity: " << value );
                    
                    //checks vector<int> attributes
                    ATH_MSG_DEBUG("REGTEST    Checking vector<int> attributes");
                    std::vector<int> vecvalueint;
                    if (thisjet->getAttribute(xAOD::JetAttribute::NumTrkPt1000, vecvalueint)) {
                        int vecsize = vecvalueint.size();
                        ATH_MSG_INFO("REGTEST    Got NumTrkPt1000 vector, size: " << vecsize);
                        if (vecsize != 0) {
                            int j = 0;
                            for(const auto & thisvalue : vecvalueint){
                                ++j;
                                ATH_MSG_INFO("REGTEST        NumTrkPt1000 #" << j << ": " << thisvalue);
                            }
                            ATH_MSG_INFO("REGTEST        size of attribute vector == number of displayed attributes: " << (vecsize == j) );
                            if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                        }
                    }
                    if (thisjet->getAttribute(xAOD::JetAttribute::NumTrkPt500, vecvalueint)) {
                        int vecsize = vecvalueint.size();
                        ATH_MSG_INFO("REGTEST    Got Got NumTrkPt500 vector, size: " << vecsize);
                        if (vecsize != 0) {
                            int j = 0;
                            for(const auto & thisvalue : vecvalueint){
                                ++j;
                                ATH_MSG_INFO("REGTEST        NumTrkPt500 #" << j << ": " << thisvalue);
                            }
                            ATH_MSG_INFO("REGTEST        size of attribute vector == number of displayed attributes: " << (vecsize == j) );
                            if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                        }
                    }
                    
                    //checks vector<float> attributes
                    ATH_MSG_DEBUG("REGTEST    Checking vector<float> attributes");
                    std::vector<float> vecvalue;
                    if (thisjet->getAttribute(xAOD::JetAttribute::JVF, vecvalue)) {
                        int vecsize = vecvalue.size();
                        ATH_MSG_INFO("REGTEST    Got JVF vector, size: " << vecsize);
                        if (vecsize != 0) {
                            int j = 0;
                            for(const auto & thisvalue : vecvalue){
                                ++j;
                                ATH_MSG_INFO("REGTEST        JVF #" << j << ": " << thisvalue);
                            }
                            ATH_MSG_INFO("REGTEST        size of attribute vector == number of displayed attributes: " << (vecsize == j) );
                            if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                        }
                    }
                    if (thisjet->getAttribute(xAOD::JetAttribute::SumPtTrkPt1000, vecvalue)) {
                        int vecsize = vecvalue.size();
                        ATH_MSG_INFO("REGTEST    Got SumPtTrkPt1000 vector, size: " << vecsize);
                        if (vecsize != 0) {
                            int j = 0;
                            for(const auto & thisvalue : vecvalue){
                                ++j;
                                ATH_MSG_INFO("REGTEST        SumPtTrkPt1000 #" << j << ": " << thisvalue);
                            }
                            ATH_MSG_INFO("REGTEST        size of attribute vector == number of displayed attributes: " << (vecsize == j) );
                            if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                        }
                    }
                    if (thisjet->getAttribute(xAOD::JetAttribute::SumPtTrkPt500, vecvalue)) {
                        int vecsize = vecvalue.size();
                        ATH_MSG_INFO("REGTEST    Got SumPtTrkPt500 vector, size: " << vecsize);
                        if (vecsize != 0) {
                            int j = 0;
                            for(const auto & thisvalue : vecvalue){
                                ++j;
                                ATH_MSG_INFO("REGTEST        SumPtTrkPt500 #" << j << ": " << thisvalue);
                            }
                            ATH_MSG_INFO("REGTEST        size of attribute vector == number of displayed attributes: " << (vecsize == j) );
                            if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                        }
                    }
                    if (thisjet->getAttribute(xAOD::JetAttribute::TrackWidthPt1000, vecvalue)) {
                        int vecsize = vecvalue.size();
                        ATH_MSG_INFO("REGTEST    Got TrackWidthPt1000 vector, size: " << vecsize);
                        if (vecsize != 0) {
                            int j = 0;
                            for(const auto & thisvalue : vecvalue){
                                ++j;
                                ATH_MSG_INFO("REGTEST        TrackWidthPt1000 #" << j << ": " << thisvalue);
                            }
                            ATH_MSG_INFO("REGTEST        size of attribute vector == number of displayed attributes: " << (vecsize == j) );
                            if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                        }
                    }
                    if (thisjet->getAttribute(xAOD::JetAttribute::TrackWidthPt500, vecvalue)) {
                        int vecsize = vecvalue.size();
                        ATH_MSG_INFO("REGTEST    Got TrackWidthPt500 vector, size: " << vecsize);
                        if (vecsize != 0) {
                            int j = 0;
                            for(const auto & thisvalue : vecvalue){
                                ++j;
                                ATH_MSG_INFO("REGTEST        TrackWidthPt500 #" << j << ": " << thisvalue);
                            }
                            ATH_MSG_INFO("REGTEST        size of attribute vector == number of displayed attributes: " << (vecsize == j) );
                            if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                        }
                    }
                    if (thisjet->getAttribute(xAOD::JetAttribute::EnergyPerSampling, vecvalue)) {
                        int vecsize = vecvalue.size();
                        ATH_MSG_INFO("REGTEST    Got EnergyPerSampling vector, size: " << vecsize);
                        if (vecsize != 0) {
                            int j = 0;
                            for(const auto & thisvalue : vecvalue){
                                ++j;
                                ATH_MSG_INFO("REGTEST        EnergyPerSampling #" << j << ": " << thisvalue);
                            }
                            ATH_MSG_INFO("REGTEST        size of attribute vector == number of displayed attributes: " << (vecsize == j) );
                            if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
                        }
                    }
                    
                    
                    //checks associated objects
                    //                    ATH_MSG_DEBUG("REGTEST    Checking associated objects");
                    //                                std::vector<const xAOD::TrackParticle*> track;
                    //                                if( thisjet->getAssociatedObjects(xAOD::JetAttribute::GhostTrack, track) ){
                    //                                    int vecsize = track.size();
                    //                                    ATH_MSG_INFO("REGTEST    Got GhostTrack vector, size: " << vecsize);
                    //                                    if (vecsize != 0) {
                    //                                        int j = 0;
                    //                                        for(const auto & thistrack : track){
                    //                                            ++j;
                    //                                            //checks only one associated variable, just making sure getting the object worked
                    //                                            if (thistrack) ATH_MSG_INFO("REGTEST        z0 for GhostTrack #" << j << ": " << thistrack->z0());
                    //                                            else{
                    //                                                ATH_MSG_WARNING("REGTEST Problem with attribute pointer");
                    //                                                return StatusCode::SUCCESS;
                    //                                            }
                    //                                        }
                    //                                        ATH_MSG_INFO("REGTEST        size of associated object vector == number of displayed attributes: " << (vecsize == j) );
                    //                                        if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this associated object");
                    //                                    }
                    //                                }
                }
                else{
                    ATH_MSG_WARNING("REGTEST Problem with jet pointer");
                    return StatusCode::SUCCESS;
                }
            }
            
            if (jetContsize == i) ATH_MSG_INFO("REGTEST size of jet container == number of displayed jets: " << (jetContsize == i) );
            else ATH_MSG_WARNING("REGTEST Problem with displaying jets");
        }
    }
    
    if (!onefilled) ATH_MSG_DEBUG("There was no filled jet containers");
    
    ATH_MSG_INFO("REGTEST ==========END of xAOD::JetContainer DUMP===========");
    
    ATH_MSG_DEBUG("leaving dumpxAODJetContainer()");
    
    return StatusCode::SUCCESS;
}

dumpxAODMuonContainer()

StatusCode TrigEDMChecker::dumpxAODMuonContainer ( )

private

Definition at line 1345 of file TrigEDMChecker.cxx.

                                                 {
 
  ATH_MSG_DEBUG("In dumpxAODMuonContainer");
 
  ATH_MSG_INFO( "REGTEST ==========START of xAOD::MuonContainer DUMP===========" );
 
  const xAOD::MuonContainer* muonCont=0;
  StatusCode sc = evtStore()->retrieve(muonCont,"HLT_xAOD__MuonContainer_MuonEFInfo");
  if (sc.isFailure()) {
    ATH_MSG_INFO("REGTEST No muon container HLT_xAOD__MuonContainer_MuonEFInfo");
    return StatusCode::SUCCESS;
  }
 
  std::string output = m_muonPrinter->print( *muonCont );
  msg(MSG::INFO) << output << endmsg;
 
  ATH_MSG_INFO( "REGTEST ==========END of xAOD::MuonContainer DUMP===========" );
 
  return StatusCode::SUCCESS;
 
}

dumpxAODPhotonContainer()

StatusCode TrigEDMChecker::dumpxAODPhotonContainer ( )

private

Definition at line 1925 of file TrigEDMChecker.cxx.

                                                   {
 
  ATH_MSG_DEBUG("In dumpxAODPhotonContainer");
 
  ATH_MSG_INFO( "REGTEST ==========START of xAOD::PhotonContainer DUMP===========" );
 
  const xAOD::PhotonContainer* phCont=0;
  StatusCode sc = evtStore()->retrieve(phCont,"HLT_xAOD__PhotonContainer_egamma_Photons");
  if (sc.isFailure()) {
    ATH_MSG_INFO("REGTEST No Photon container HLT_xAOD__PhotonContainer_egamma_Photons");
    return StatusCode::SUCCESS;
  }
 
  float val_float=-99;
  unsigned int isEMbit=0;
  //DEBUG output for xAOD::PhotonContainer
  ATH_MSG_INFO(" REGTEST: xAOD Reconstruction variables: ");
  //                //Cluster and ShowerShape info
  for (const auto eg : *phCont){
      //REGTEST printout
      if (eg) {
          ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
          ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
          ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
          ATH_MSG_INFO(" REGTEST: isEMLoose " << eg->selectionisEM(isEMbit,"isEMLoose"));
          ATH_MSG_INFO(" REGTEST: isEMLoose bit " << std::hex << isEMbit << std::dec);
          ATH_MSG_INFO(" REGTEST: isEMMedium " << eg->selectionisEM(isEMbit,"isEMMedium"));
          ATH_MSG_INFO(" REGTEST: isEMMedium bit " << std::hex << isEMbit << std::dec);
          ATH_MSG_INFO(" REGTEST: isEMTight " << eg->selectionisEM(isEMbit,"isEMTight"));
          ATH_MSG_INFO(" REGTEST: isEMTight bit " << std::hex << isEMbit << std::dec);
      } else{
          ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
          return StatusCode::SUCCESS;
      }
      ATH_MSG_INFO(" REGTEST: caloCluster variables ");
      if (eg->caloCluster()) {
          ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
          ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
          ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
          double tmpeta = -999.;
          double tmpphi = -999.;
          eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
          eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi); 
          ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta); 
          ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
      } else{
          ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
      }
      ATH_MSG_INFO("REGTEST: Check the original (uncalibrated)");
      static const SG::AuxElement::Accessor<ElementLink<xAOD::CaloClusterContainer> > orig ("originalCaloCluster");
      if (!orig.isAvailable(*eg->caloCluster()) || !orig(*eg->caloCluster()).isValid()){
          ATH_MSG_INFO("Problem with original cluster link");
      }
      else {
          const xAOD::CaloCluster *origClus = *orig(*eg->caloCluster());
          ATH_MSG_INFO("REGTEST:: Compare new and old clusters");
          ATH_MSG_INFO("REGTEST:: Original Cluster e,eta,phi" << origClus->e() << " " <<  origClus->eta() << " " << origClus->phi());
          ATH_MSG_INFO("REGTEST:: MVA      Cluster e,eta,phi" << eg->caloCluster()->e() << " " <<  eg->caloCluster()->eta() << " " << eg->caloCluster()->phi());
      }
      //msg() << MSG::VERBOSE << " REGTEST: cluster variables " << endmsg;
      //clus = eg->caloCluster();
      ATH_MSG_INFO(" REGTEST: EMShower variables ");
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::ethad);
      ATH_MSG_INFO(" REGTEST: ethad    =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e011);
      ATH_MSG_INFO(" REGTEST: e011     =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e132);
      ATH_MSG_INFO(" REGTEST: e132     =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e237);
      ATH_MSG_INFO(" REGTEST: e237     =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e335);
      ATH_MSG_INFO(" REGTEST: e335     =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2ts1);
      ATH_MSG_INFO(" REGTEST: e2ts1    =  " << val_float);
      eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2tsts1);
      ATH_MSG_INFO(" REGTEST: e2tsts1  =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::etcone20);
      ATH_MSG_INFO(" REGTEST: etcone20   =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::etcone30);
      ATH_MSG_INFO(" REGTEST: etcone30   =  " << val_float);
      eg->isolationValue(val_float,xAOD::Iso::etcone40);
      ATH_MSG_INFO(" REGTEST: etcone40   =  " << val_float);
      //DEBUG info for Electrons which by definition have a track match
 
  }
  ATH_MSG_INFO( "REGTEST ==========END of xAOD::PhotonContainer DUMP===========" );
 
  return StatusCode::SUCCESS;
 
}

dumpxAODTrackParticle()

StatusCode TrigEDMChecker::dumpxAODTrackParticle ( )

private

Definition at line 3866 of file TrigEDMChecker.cxx.

                                                 {
 
  ATH_MSG_DEBUG("In dumpxAODTrackParticle()");
 
  ATH_MSG_INFO("REGTEST ==========START of xAOD::TrackParticle DUMP===========");
 
    std::vector<std::string> SGkeys;
    SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_EFID");
    SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_EFID");
    SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_EFID");
    SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_FullScan_EFID");
    SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_EFID");
    SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Photon_EFID");
    SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_EFID");
 
    StatusCode returnsc = StatusCode::SUCCESS;
 
    for (unsigned int SGkey = 0; SGkey < SGkeys.size(); ++SGkey) {
        const xAOD::TrackParticleContainer* trackParticleContainer=0;
        StatusCode sc = evtStore()->retrieve(trackParticleContainer,SGkeys.at(SGkey));
        if (sc.isFailure()) {
          ATH_MSG_INFO("REGTEST No track particle container found with key " << SGkeys.at(SGkey));
            continue;
        }
        ATH_MSG_INFO("REGTEST TrackParticleContainer retrieved with key " << SGkeys.at(SGkey)
                     << " and size " << trackParticleContainer->size());
        
        xAOD::TrackParticleContainer::const_iterator trackParticleItr = trackParticleContainer->begin();
        xAOD::TrackParticleContainer::const_iterator trackParticleLast = trackParticleContainer->end();
 
        for (int index = 0; trackParticleItr != trackParticleLast; ++trackParticleItr, ++index) {
          ATH_MSG_INFO("REGTEST Looking at Track Particle " << index);
 
          ATH_MSG_INFO("REGTEST IParticle functions:");
          ATH_MSG_INFO("REGTEST pt: " << (*trackParticleItr)->pt()
                       << "/eta: " << (*trackParticleItr)->eta()
                       << "/phi: " << (*trackParticleItr)->phi()
                       << "/m: " << (*trackParticleItr)->m()
                       << "/e: " << (*trackParticleItr)->e()
                       << "/rapidity: " << (*trackParticleItr)->rapidity());
 
          ATH_MSG_INFO("REGTEST Defining parameters functions:");
          ATH_MSG_INFO("REGTEST charge: " << (*trackParticleItr)->charge()
                       << "/d0: " << (*trackParticleItr)->d0()
                       << "/z0: " << (*trackParticleItr)->z0()
                       << "/phi0: " << (*trackParticleItr)->phi0()
                       << "/theta: " << (*trackParticleItr)->theta()
                       << "/qOverP: " << (*trackParticleItr)->qOverP()
                       << "/vx: " << (*trackParticleItr)->vx()
                       << "/vy: " << (*trackParticleItr)->vy()
                       << "/vz: " << (*trackParticleItr)->vz());
 
            // Curvilinear functions skipped
 
          ATH_MSG_INFO("REGTEST Fit quality functions:");
          ATH_MSG_INFO("REGTEST chiSquared: " << (*trackParticleItr)->chiSquared()
                       << "/numberDoF: " << (*trackParticleItr)->numberDoF());
 
            // TrackInfo functions skipped
 
          ATH_MSG_INFO("REGTEST summaryValue variables:");
          msg() << MSG::INFO << "REGTEST ";
            uint8_t numberOfBLayerHits = 0;
            if ( (*trackParticleItr)->summaryValue(numberOfBLayerHits, xAOD::numberOfBLayerHits) ) {
                msg() << "/numberOfBLayerHits: " << static_cast<int>(numberOfBLayerHits);
            } else {
                msg() << "/numberOfBLayerHits not found";
            }
 
            uint8_t numberOfPixelHits = 0;
            if ( (*trackParticleItr)->summaryValue(numberOfPixelHits, xAOD::numberOfPixelHits) ) {
                msg() << "/numberOfPixelHits: " << static_cast<int>(numberOfPixelHits);
            } else {
                msg() << "/numberOfPixelHits not found";
            }
 
            uint8_t numberOfPixelHoles = 0;
            if ( (*trackParticleItr)->summaryValue(numberOfPixelHoles, xAOD::numberOfPixelHoles) ) {
                msg() << "/numberOfPixelHoles: " << static_cast<int>(numberOfPixelHoles);
            } else {
                msg() << "/numberOfPixelHoles not found";
            }
 
            uint8_t numberOfSCTHits = 0;
            if ( (*trackParticleItr)->summaryValue(numberOfSCTHits, xAOD::numberOfSCTHits) ) {
                msg() << "/numberOfSCTHits: " << static_cast<int>(numberOfSCTHits);
            } else {
                msg() << "/numberOfSCTHits not found";
            }
 
            uint8_t numberOfSCTHoles = 0;
            if ( (*trackParticleItr)->summaryValue(numberOfSCTHoles, xAOD::numberOfSCTHoles) ) {
                msg() << "/numberOfSCTHoles: " << static_cast<int>(numberOfSCTHoles);
            } else {
                msg() << "/numberOfSCTHoles not found";
            }
 
            uint8_t numberOfTRTHits = 0;
            if ( (*trackParticleItr)->summaryValue(numberOfTRTHits, xAOD::numberOfTRTHits) ) {
                msg() << "/numberOfTRTHits: " << static_cast<int>(numberOfTRTHits);
            } else {
                msg() << "/numberOfTRTHits not found";
            }
 
            uint8_t numberOfTRTHoles = 0;
            if ( (*trackParticleItr)->summaryValue(numberOfTRTHoles, xAOD::numberOfTRTHoles) ) {
                msg() << "/numberOfTRTHoles: " << static_cast<int>(numberOfTRTHoles);
            } else {
                msg() << "/numberOfTRTHoles not found";
            }
            msg() << endmsg;
        }
    }
 
    ATH_MSG_INFO("REGTEST ==========END of xAOD::TrackParticle DUMP===========");
    ATH_MSG_DEBUG("dumpxAODTrackParticles() succeeded");
 
    return returnsc;
}

dumpxAODTrigElectronContainer()

StatusCode TrigEDMChecker::dumpxAODTrigElectronContainer ( )

private

Definition at line 1668 of file TrigEDMChecker.cxx.

                                                         {
 
  ATH_MSG_DEBUG("In dumpxAODElectronContainer");
 
  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigElectronContainer DUMP===========" );
 
  const xAOD::TrigElectronContainer* elCont=0;
  StatusCode sc = evtStore()->retrieve(elCont,"HLT_xAOD__TrigElectronContainer_L2ElectronFex");
  if (sc.isFailure()) {
    ATH_MSG_INFO("REGTEST No TrigElectron container HLT_xAOD__TrigElectronContainer_L2ElectronFex");
    return StatusCode::SUCCESS;
  }
 
  for (const auto eg : *elCont){
      ATH_MSG_INFO("REGTEST TrigElectron->Phi() returns " << eg->phi());
      ATH_MSG_INFO("REGTEST TrigElectron->Eta() returns " << eg->eta());
      ATH_MSG_INFO("REGTEST TrigElectron->rEta returns " << eg->rcore());
      ATH_MSG_INFO("REGTEST TrigElectron->eratio() returns " << eg->eratio());
      ATH_MSG_INFO("REGTEST TrigElectron->pt() returns " << eg->pt());
      ATH_MSG_INFO("REGTEST TrigElectron->etHad() returns " << eg->etHad());
      ATH_MSG_INFO("REGTEST TrigElectron->f1() returns " << eg->f1());
      ATH_MSG_INFO("REGTEST TrigElectron caloEta = " << eg->caloEta());
      ATH_MSG_INFO("REGTEST TrigElectron dPhiCalo" << eg->trkClusDphi());
      ATH_MSG_INFO("REGTEST TrigElectron dEtaCalo" << eg->trkClusDeta());
      ATH_MSG_INFO("REGTEST TrigElectron pTcalo" << eg->pt());
      ATH_MSG_INFO("REGTEST TrigElectron eTOverPt" << eg->etOverPt());
      ATH_MSG_INFO("REGTEST TrigElectron nTRTHits" << eg->nTRTHits());
      ATH_MSG_INFO("REGTEST TrigElectron nStrawHits" << eg->nTRTHiThresholdHits());
      ATH_MSG_INFO("REGTEST TrigElectron Check EMCluster");
      if(eg->emCluster()){
          ATH_MSG_INFO("REGTEST TrigElectron EMCluster retrieved");
          ATH_MSG_INFO("REGTEST TrigElectron emCluster->energy() returns " << eg->emCluster()->energy());
          ATH_MSG_INFO("REGTEST TrigElectron emCluster->phi() returns " << eg->emCluster()->phi());
          ATH_MSG_INFO("REGTEST TrigElectron emCluster->eta() returns " << eg->emCluster()->eta());
          ATH_MSG_INFO("REGTEST TrigElectron emCluster check Element Link");
          ATH_MSG_INFO("REGTEST TrigElectron emCluster energy = " << eg->emCluster()->energy());
          ATH_MSG_INFO("REGTEST TrigElectron ElementLink emCluster energy = " << (*eg->emClusterLink())->energy());
      }
      else  ATH_MSG_INFO("REGTEST TrigElectron No EMCluster retrieved!");
      ATH_MSG_INFO("REGTEST TrigElectron Check TrackParticle");
      if(eg->trackParticle()){
          ATH_MSG_INFO("REGTEST TrigElectron TrackParticle retrieved");
          ATH_MSG_INFO("REGTEST TrigElectron trackParticle->pt() returns " << eg->trackParticle()->pt());
          ATH_MSG_INFO("REGTEST TrigElectron trackParticle->phi() returns " << eg->trackParticle()->phi());
          ATH_MSG_INFO("REGTEST TrigElectron trackParticle->eta() returns " << eg->trackParticle()->eta());
          ATH_MSG_INFO("REGTEST TrigElectron check TrackParticle Element Link");
          ATH_MSG_INFO("REGTEST TrigElectron TrackParticle pt = " << eg->trackParticle()->pt());
          ATH_MSG_INFO("REGTEST TrigElectron ElementLink TrackParticle pt = " << (*eg->trackParticleLink())->pt());
      }
      else  ATH_MSG_INFO("REGTEST TrigElectron No TrackParticle retrieved!");
  }
  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigElectronContainer DUMP===========" );
 
  return StatusCode::SUCCESS;
 
}

dumpxAODTrigMinBias()

StatusCode TrigEDMChecker::dumpxAODTrigMinBias ( )

private

Definition at line 819 of file TrigEDMChecker.cxx.

                                               {
 
    dumpTrigSpacePointCounts();
    dumpTrigT2MBTSBits();
    dumpTrigVertexCounts();
    dumpTrigTrackCounts();
 
    return StatusCode::SUCCESS;
}

dumpxAODTrigMissingET()

StatusCode TrigEDMChecker::dumpxAODTrigMissingET ( )

private

Definition at line 833 of file TrigEDMChecker.cxx.

                                                 {
 
  ATH_MSG_INFO("dumpxAODTrigMissingET()");
 
  int ntag=4;
  std::string METTags[]={"HLT_xAOD__TrigMissingETContainer_EFJetEtSum","HLT_xAOD__TrigMissingETContainer_TrigEFMissingET", "HLT_xAOD__TrigMissingETContainer_TrigL2MissingET_FEB","HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topocl"};
 
  for(int itag=0; itag <ntag; itag++) {
 
    const xAOD::TrigMissingETContainer* MissingETCont=0;
    StatusCode sc = evtStore()->retrieve(MissingETCont,METTags[itag]);
    if (sc.isFailure())
      ATH_MSG_INFO("failed to retrieve " << METTags[itag]);
    else {
      ATH_MSG_INFO("Accessing " << METTags[itag] << " with " << MissingETCont->size() << " elements");
 
      // Loop over container content
      for(uint i = 0; i < MissingETCont->size(); i++) {
 
        std::string s; char buff[3000];
             
        snprintf(buff, sizeof(buff), "REGTEST %s Ex =         %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ex() );
        ATH_MSG_INFO(buff);
        snprintf(buff, sizeof(buff), "REGTEST %s Ey =         %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ey() );
        ATH_MSG_INFO(buff);
        snprintf(buff, sizeof(buff), "REGTEST %s Ez =         %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ez() );
        ATH_MSG_INFO(buff);
        snprintf(buff, sizeof(buff), "REGTEST %s SumET =         %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->sumEt() );
        ATH_MSG_INFO(buff);
        snprintf(buff, sizeof(buff), "REGTEST %s SumE =       %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->sumE() );
        ATH_MSG_INFO(buff);
        snprintf(buff, sizeof(buff), "REGTEST %s Flag =       %d", s.c_str(), MissingETCont->at(i)->flag() );
        ATH_MSG_INFO(buff);
        snprintf(buff, sizeof(buff), "REGTEST %s Flag =       %d", s.c_str(), MissingETCont->at(i)->roiWord() );
        ATH_MSG_INFO(buff);
             
        unsigned int Nc = MissingETCont->at(i)->getNumberOfComponents();
        if (Nc > 0) { 
          s="REGTEST __name____status_usedChannels__sumOfSigns__calib1_calib0";
          s+="/MeV__ex/MeV_____ey/MeV_____ez/MeV___sumE/MeV__sumEt/CLHEP::MeV";
          ATH_MSG_INFO(s);
        }
             
        for(uint j = 0; j < Nc; j++) {
             
          std::string name =               MissingETCont->at(i)->nameOfComponent(j);
          const short status =             MissingETCont->at(i)->statusComponent(j);
          const unsigned short usedChan =  MissingETCont->at(i)->usedChannelsComponent(j);
          const short sumOfSigns =         MissingETCont->at(i)->sumOfSignsComponent(j);
          const float calib0 =             MissingETCont->at(i)->calib0Component(j);
          const float calib1 =             MissingETCont->at(i)->calib1Component(j);
          const float ex =                 MissingETCont->at(i)->exComponent(j);
          const float ey =                 MissingETCont->at(i)->eyComponent(j);
          const float ez =                 MissingETCont->at(i)->ezComponent(j);
          const float sumE =               MissingETCont->at(i)->sumEComponent(j);
          const float sumEt =              MissingETCont->at(i)->sumEtComponent(j);
 
          snprintf(buff, sizeof(buff),
                   "REGTEST   %s   %6d %12d %10d   %6.2f  %6.3f %10.2f %10.2f %10.2f %10.2f %10.2f",
                   name.c_str(), status, usedChan, sumOfSigns, calib1, calib0,
                   ex, ey, ez, sumE, sumEt);
          ATH_MSG_INFO(buff);       
        }              
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

dumpxAODTrigPhotonContainer()

StatusCode TrigEDMChecker::dumpxAODTrigPhotonContainer ( )

private

Definition at line 1726 of file TrigEDMChecker.cxx.

                                                       {
 
  ATH_MSG_DEBUG("In dumpxAODTrigPhotonContainer");
 
  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigPhotonContainer DUMP===========" );
 
  const xAOD::TrigPhotonContainer* phCont=0;
  StatusCode sc = evtStore()->retrieve(phCont,"HLT_xAOD__TrigPhotonContainer_L2PhotonFex");
  if (sc.isFailure()) {
    ATH_MSG_INFO("REGTEST No TrigPhoton container HLT_xAOD__TrigPhotonContainer_L2PhotonFex");
    return StatusCode::SUCCESS;
  }
 
  for (const auto eg : *phCont){
 
      ATH_MSG_INFO("REGTEST TrigPhoton->Phi() returns " << eg->phi());
      ATH_MSG_INFO("REGTEST TrigPhoton->Eta() returns " << eg->eta());
      ATH_MSG_INFO("REGTEST TrigPhoton->dPhi() returns " << eg->dPhi());
      ATH_MSG_INFO("REGTEST TrigPhoton->dEta() returns " << eg->dEta());
      ATH_MSG_INFO("REGTEST TrigPhoton->rEta returns " << eg->rcore());
      ATH_MSG_INFO("REGTEST TrigPhoton->eratio() returns " << eg->eratio());
      ATH_MSG_INFO("REGTEST TrigPhoton->pt() returns " << eg->pt());
      ATH_MSG_INFO("REGTEST TrigPhoton->etHad() returns " << eg->etHad());
      ATH_MSG_INFO("REGTEST TrigPhoton->f1() returns " << eg->f1());
      ATH_MSG_INFO("REGTEST TrigPhoton Check EMCluster");
      if(eg->emCluster()){
          ATH_MSG_INFO("REGTEST TrigPhoton EMCluster retrieved");
          ATH_MSG_INFO("REGTEST TrigPhoton emCluster->energy() returns " << eg->emCluster()->energy());
          ATH_MSG_INFO("REGTEST TrigPhoton emCluster->phi() returns " << eg->emCluster()->phi());
          ATH_MSG_INFO("REGTEST TrigPhoton emCluster->eta() returns " << eg->emCluster()->eta());
          ATH_MSG_INFO("REGTEST TrigPhoton emCluster check Element Link");
          ATH_MSG_INFO("REGTEST TrigPhoton emCluster energy = " << eg->emCluster()->energy());
          ATH_MSG_INFO("REGTEST TrigPhoton ElementLink emCluster energy = " << (*eg->emClusterLink())->energy());
      }
      else  ATH_MSG_INFO("REGTEST TrigPhoton No EMCluster retrieved!");
  }
  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigPhotonContainer DUMP===========" );
 
  return StatusCode::SUCCESS;
 
}

dumpxAODVertex()

StatusCode TrigEDMChecker::dumpxAODVertex ( )

private

Definition at line 3986 of file TrigEDMChecker.cxx.

                                          {
 
  ATH_MSG_DEBUG("In dumpxAODVertex()");
 
  ATH_MSG_INFO("REGTEST ==========START of xAOD::Vertex DUMP===========");
 
    const xAOD::VertexContainer* vertexContainer=0;
    StatusCode sc = evtStore()->retrieve(vertexContainer,"HLT_xAOD__VertexContainer_xPrimVx");
    if (sc.isFailure()) {
      ATH_MSG_INFO("REGTEST No vertex container");
        return StatusCode::FAILURE;
    }
    ATH_MSG_INFO("REGTEST VertexContainer retrieved");
 
    xAOD::VertexContainer::const_iterator vertexItr = vertexContainer->begin();
    xAOD::VertexContainer::const_iterator vertexLast = vertexContainer->end();
 
    for (int index = 0; vertexItr != vertexLast; ++vertexItr, ++index) {
      ATH_MSG_INFO("REGTEST Looking at Vertex " << index);
 
      ATH_MSG_INFO("REGTEST Public Member Functions:");
      ATH_MSG_INFO("REGTEST x: " << (*vertexItr)->x()
                   << "/y: " << (*vertexItr)->y()
                   << "/z: " << (*vertexItr)->z());
 
      ATH_MSG_INFO("REGTEST Public Member Functions:");
      ATH_MSG_INFO("REGTEST chiSquared: " << (*vertexItr)->chiSquared()
                   << "/numberDoF: " << (*vertexItr)->numberDoF());
    }
 
    ATH_MSG_INFO("REGTEST ==========END of xAOD::Vertex DUMP===========");
    ATH_MSG_DEBUG("dumpxAODVertex() succeeded");
 
    return StatusCode::SUCCESS;
}

efficiency()

TEfficiency * AthHistogramming::efficiency ( const std::string &  effName, const std::string &  tDir = "", const std::string &  stream = ""  )

protectedinherited

Simplify the retrieval of registered TEfficiency.

Definition at line 250 of file AthHistogramming.cxx.

{
  // Build a 32 bit hash out of the name
  const hash_t effHash = this->hash(effName);
 
  // See if this entry exists in the map
  EffMap_t::const_iterator it = m_effMap.find( effHash );
  if ( it == m_effMap.end() ) // It doesn't exist!
    { // Let's see into the THistSvc if somebody else has registered the TEfficiency...
 
      // Need to copy the strings as we will massage them from here on
      std::string effNameCopy = effName;
      std::string tDirCopy     = tDir;
      std::string streamCopy   = stream;
 
      // Massage the final string to book things
      std::string bookingString("");
      this->buildBookingString( bookingString, effNameCopy, tDirCopy, streamCopy ,false);
 
      TEfficiency* effPointer(NULL);
      if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
        {
          // Massage the final string to book things
          std::string bookingString("");
          this->buildBookingString( bookingString, effNameCopy, tDirCopy, streamCopy, true );
 
          if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
            {
              m_msg << MSG::WARNING
                    << "Problem retrieving the TEfficiency with name (including pre- and post-fixes) "
                    << m_histNamePrefix + effNameCopy + m_histNamePostfix
                    << " or with name " << effNameCopy
                    << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
                    << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
              return NULL;
            }
          // If we get to here, we actually found the TEfficiency in the THistSvc.
          // So let's add it to the local cache map and return its pointer
          m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
          return effPointer;
        }
      // If we get to here, we actually found the TEfficiency in the THistSvc.
      // So let's add it to the local cache map and return its pointer
      m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
      return effPointer;
    }
 
  // Return the pointer to the TEfficiency that we got from the local cache map
  return it->second;
}

endInputFile()

StatusCode AthAnalysisAlgorithm::endInputFile ( )

protectedvirtualinherited

Function called as an input file is being closed.

Dummy implementation that can be overridden by the derived tool.

Definition at line 122 of file AthAnalysisAlgorithm.cxx.

                                              {
 
   // Return gracefully:
   return StatusCode::SUCCESS;
}

evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::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; }

evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

{ return m_evtStore; }

execute()

StatusCode TrigEDMChecker::execute ( )

overridevirtual

Definition at line 243 of file TrigEDMChecker.cxx.

                                   {
 
  /* fwinkl, Mar 20222:
     Some attempt was made to make the code pass the thread-checker. Methods that
     are clearly not thread-safe (e.g. use of DataHandle) are marked as such. Calling
     these methods from within execute would still trigger a thread-checker warning.
     Since this algorithm is only ever used for validation and in single-threaded athena,
     we suppress these warnings by the following assignment. This has the advantage
     (as opposed to disabling the checking for the entire file) that new code is still
     being checked and will hopefully be written in a thread-safe manner, i.e. using
     ReadHandleKeys. If someone is very eager they could migrate all uses of DataHandles...
  */
  StatusCode sc ATLAS_THREAD_SAFE = do_execute();
  return sc;
}

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return Algorithm::extraOutputDeps();
}

firstExecute()

StatusCode AthAnalysisAlgorithm::firstExecute ( )

protectedvirtualinherited

Function called when first execute is encountered user can read event information with evtStore()

Dummy implementation that can be overridden by the derived tool.

Reimplemented in CP::JetTileCorrectionAlg.

Definition at line 139 of file AthAnalysisAlgorithm.cxx.

                                              {
 
   // Return gracefully:
   return StatusCode::SUCCESS;
}

graph()

TGraph * AthHistogramming::graph ( const std::string &  graphName, const std::string &  tDir = "", const std::string &  stream = ""  )

protectedinherited

Simplify the retrieval of registered TGraphs.

Definition at line 492 of file AthHistogramming.cxx.

{
  // Build a 32 bit hash out of the name
  const hash_t graphHash = this->hash(graphName);
 
  // See if this entry exists in the map
  GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
  if ( it == m_graphMap.end() ) // It doesn't exist!
    { // Let's see into the THistSvc if somebody else has registered the TGraph...
 
      // Need to copy the strings as we will massage them from here on
      std::string graphNameCopy = graphName;
      std::string tDirCopy      = tDir;
      std::string streamCopy    = stream;
 
      // Massage the final string to book things
      std::string bookingString("");
      this->buildBookingString( bookingString, graphNameCopy, tDirCopy, streamCopy, true);
 
      TGraph* graphPointer(NULL);
      if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
        {
          // Massage the final string to book things
          std::string bookingString("");
          this->buildBookingString( bookingString, graphNameCopy, tDirCopy, streamCopy, false );
 
          if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
            {
              m_msg << MSG::WARNING
                    << "Problem retrieving the TGraph with name (including pre- and post-fixes) "
                    << m_histNamePrefix + graphNameCopy + m_histNamePostfix
                    << " or with name " << graphNameCopy
                    << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
                    << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
              return NULL;
            }
          // If we get to here, we actually found the TGraph in the THistSvc.
          // So let's add it to the local cache map and return its pointer
          m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
          return graphPointer;
        }
      // If we get to here, we actually found the TGraph in the THistSvc.
      // So let's add it to the local cache map and return its pointer
      m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
      return graphPointer;
    }
 
 
  // Return the pointer to the TGraph that we got from the local cache map
  return it->second;
}

handle()

void AthAnalysisAlgorithm::handle ( const Incident &  inc )

overrideprotectedvirtualinherited

Function receiving incidents from IncidentSvc/TEvent Experts can override but they should ensure they add AthAnalysisAlgorithm::handle(); to the end of their own implementation.

Definition at line 83 of file AthAnalysisAlgorithm.cxx.

                                                       {
 
   // Tell the user what's happening:
   ATH_MSG_VERBOSE( "Callback received with incident: " << inc.type() );
 
   // Call the appropriate member function:
   if( inc.type() == IncidentType::BeginInputFile ) {
      m_currentFile=0;
      if( beginInputFile().isFailure() ) {
         ATH_MSG_FATAL( "Failed to call beginInputFile()" );
         throw std::runtime_error( "Couldn't call beginInputFile()" );
      }
   } else if(inc.type() == IncidentType::EndInputFile ) {
     if( endInputFile().isFailure() ) {
         ATH_MSG_FATAL( "Failed to call endInputFile()" );
         throw std::runtime_error( "Couldn't call endInputFile()" );
      }
   } else if(inc.type() == "MetaDataStop" ) {
     if( metaDataStop().isFailure() ) {
         ATH_MSG_FATAL( "Failed to call metaDataStop()" );
         throw std::runtime_error( "Couldn't call metaDataStop()" );
      }
   } else {
      ATH_MSG_WARNING( "Unknown incident type received: " << inc.type() );
   }
 
   return;
}

hash()

AthHistogramming::hash_t AthHistogramming::hash ( const std::string &  histName ) const

inlineprivateinherited

Method to calculate a 32-bit hash from a string.

Definition at line 428 of file AthHistogramming.h.

{
  const uint64_t hash64 = CxxUtils::crc64( histName );
  return (hash_t)(hash64 & 0xFFFFFFFF);
}

hist()

TH1 * AthHistogramming::hist ( const std::string &  histName, const std::string &  tDir = "", const std::string &  stream = ""  )

protectedinherited

Simplify the retrieval of registered histograms of any type.

Definition at line 198 of file AthHistogramming.cxx.

{
  // Build a 32 bit hash out of the name
  const hash_t histHash = this->hash(histName);
 
  // See if this entry exists in the map
  HistMap_t::const_iterator it = m_histMap.find( histHash );
  if ( it == m_histMap.end() ) // It doesn't exist!
    { // Let's see into the THistSvc if somebody else has registered the histogram...
 
      // Need to copy the strings as we will massage them from here on
      std::string histNameCopy = histName;
      std::string tDirCopy     = tDir;
      std::string streamCopy   = stream;
 
      // Massage the final string to book things
      std::string bookingString("");
      this->buildBookingString( bookingString, histNameCopy, tDirCopy, streamCopy ,false);
 
      TH1* histPointer(NULL);
      if ( !((histSvc()->getHist(bookingString, histPointer)).isSuccess()) )
        {
          // Massage the final string to book things
          std::string bookingString("");
          this->buildBookingString( bookingString, histNameCopy, tDirCopy, streamCopy, true );
 
          if ( !((histSvc()->getHist(bookingString, histPointer)).isSuccess()) )
            {
              m_msg << MSG::WARNING
                    << "Problem retrieving the histogram with name (including pre- and post-fixes) "
                    << m_histNamePrefix + histNameCopy + m_histNamePostfix
                    << " or with name " << histNameCopy
                    << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
                    << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
              return NULL;
            }
          // If we get to here, we actually found the histogram in the THistSvc.
          // So let's add it to the local cache map and return its pointer
          m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, histPointer ) );
          return histPointer;
        }
      // If we get to here, we actually found the histogram in the THistSvc.
      // So let's add it to the local cache map and return its pointer
      m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, histPointer ) );
      return histPointer;
    }
 
 
  // Return the pointer to the histogram that we got from the local cache map
  return it->second;
}

hist2d()

TH2 * AthHistogramming::hist2d ( const std::string &  histName, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the retrieval of registered 2-d histograms.

Definition at line 369 of file AthHistogramming.h.

{
  // Get the TH1 pointer
  TH1* th1Pointer = this->hist(histName, tDir, stream);
  if ( !th1Pointer )
    {
      m_msg << MSG::ERROR
            << "Cannot get a 2-d histogram with name " << histName
            << "... will probably seg-fault!" << endmsg;
      return NULL;
    }
  // If the TH1 pointer is valid, simply return the dynamic_cast
  return dynamic_cast<TH2*>( th1Pointer );
}

hist3d()

TH3 * AthHistogramming::hist3d ( const std::string &  histName, const std::string &  tDir = "", const std::string &  stream = ""  )

inlineprotectedinherited

Simplify the retrieval of registered 3-d histograms.

Definition at line 386 of file AthHistogramming.h.

{
  // Get the TH1 pointer
  TH1* th1Pointer = this->hist(histName, tDir, stream);
  if ( !th1Pointer )
    {
      m_msg << MSG::ERROR
            << "Cannot get a 3-d histogram with name " << histName
            << "... will probably seg-fault!" << endmsg;
      return NULL;
    }
  // If the TH1 pointer is valid, simply return the dynamic_cast
  return dynamic_cast<TH3*>( th1Pointer );
}

histSvc()

const ServiceHandle< ITHistSvc > & AthHistogramAlgorithm::histSvc ( ) const

inlineinherited

The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a pointer to the THistSvc.

Definition at line 113 of file AthHistogramAlgorithm.h.

{
  return m_histSvc;
}

initialize()

StatusCode TrigEDMChecker::initialize ( )

overridevirtual

Definition at line 171 of file TrigEDMChecker.cxx.

                                      {
 
  ATH_CHECK( m_navigationHandleKey.initialize() );
  ATH_CHECK( m_decisionsKey.initialize() );
  ATH_CHECK( m_navigationTool.retrieve() );
 
  ATH_MSG_DEBUG("Initializing TrigEDMChecker");
 
  ATH_MSG_INFO("REGTEST Initializing...");
  ATH_MSG_INFO("REGTEST m_doDumpAll                      = " << m_doDumpAll );
  ATH_MSG_INFO("REGTEST m_doDumpLVL1_ROI                 = " << m_doDumpLVL1_ROI);
  ATH_MSG_INFO("REGTEST m_doDumpTrigMissingET            = " << m_doDumpTrigMissingET );
  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigMissingET        = " << m_doDumpxAODTrigMissingET );
  ATH_MSG_INFO("REGTEST m_doDumpMuonFeature              = " << m_doDumpMuonFeature );
  ATH_MSG_INFO("REGTEST m_doDumpCombinedMuonFeature      = " << m_doDumpCombinedMuonFeature );
  ATH_MSG_INFO("REGTEST m_doDumpTileMuFeature            = " << m_doDumpTileMuFeature);
  ATH_MSG_INFO("REGTEST m_doDumpTileTrackMuFeature       = " << m_doDumpTileTrackMuFeature);
  ATH_MSG_INFO("REGTEST m_doDumpTrigPhotonContainer      = " << m_doDumpTrigPhotonContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigL2BphysContainer     = " << m_doDumpTrigL2BphysContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigEFBphysContainer     = " << m_doDumpTrigEFBphysContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigEFBjetContainer      = " << m_doDumpTrigEFBjetContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigL2BjetContainer      = " << m_doDumpTrigL2BjetContainer );
  ATH_MSG_INFO("REGTEST m_doDumpxAODJetContainer         = " << m_doDumpxAODJetContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigMuonEFContainer      = " << m_doDumpTrigMuonEFContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigMuonEFInfoContainer  = " << m_doDumpTrigMuonEFInfoContainer );
  ATH_MSG_INFO("REGTEST m_doDumpxAODMuonContainer        = " << m_doDumpxAODMuonContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigElectronContainer    = " << m_doDumpTrigElectronContainer );
  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigElectronContainer= " << m_doDumpxAODTrigElectronContainer );
  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigPhotonContainer  = " << m_doDumpxAODTrigPhotonContainer );
  ATH_MSG_INFO("REGTEST m_doDumpxAODElectronContainer    = " << m_doDumpxAODElectronContainer );
  ATH_MSG_INFO("REGTEST m_doDumpxAODPhotonContainer      = " << m_doDumpxAODPhotonContainer );
  ATH_MSG_INFO("REGTEST m_doDumpHLTResult                = " << m_doDumpHLTResult );
  ATH_MSG_INFO("REGTEST m_doDumpTrigTauContainer         = " << m_doDumpTrigTauContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigTauTracksInfo        = " << m_doDumpTrigTauTracksInfo );
  ATH_MSG_INFO("REGTEST m_doDumpTrigInDetTrackCollection = " << m_doDumpTrigInDetTrackCollection );
  ATH_MSG_INFO("REGTEST m_doDumpTrigVertexCollection     = " << m_doDumpTrigVertexCollection );
  ATH_MSG_INFO("REGTEST m_doDumpTrigEMCluster            = " << m_doDumpTrigEMCluster );
  ATH_MSG_INFO("REGTEST m_doDumpTrigEMClusterContainer   = " << m_doDumpTrigEMClusterContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrigTauClusterContainer  = " << m_doDumpTrigTauClusterContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTrackParticleContainer   = " << m_doDumpTrackParticleContainer );
  ATH_MSG_INFO("REGTEST m_doDumpTauJetContainer          = " << m_doDumpTauJetContainer );
  ATH_MSG_INFO("REGTEST m_doDumpxAODTrackParticle        = " << m_doDumpxAODTrackParticle );
  ATH_MSG_INFO("REGTEST m_doDumpxAODVertex               = " << m_doDumpxAODVertex );
  ATH_MSG_INFO("REGTEST m_doDumpxAODTauJetContainer      = " << m_doDumpxAODTauJetContainer );
  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigMinBias          = " << m_doDumpxAODTrigMinBias );
  ATH_MSG_INFO("REGTEST m_doDumpStoreGate                = " << m_doDumpStoreGate );
  ATH_MSG_INFO("REGTEST m_doDumpAllTrigComposite         = " << m_doDumpAllTrigComposite );
  ATH_MSG_INFO("REGTEST m_dumpTrigCompositeContainers    = " << m_dumpTrigCompositeContainers );
  ATH_MSG_INFO("REGTEST m_doDumpTrigCompsiteNavigation   = " << m_doDumpTrigCompsiteNavigation );
  ATH_MSG_INFO("REGTEST m_doTDTCheck                     = " << m_doTDTCheck );
 
  ATH_MSG_INFO("maxRepWarning      = " <<  maxRepWarnings );
 
  if(m_doDumpxAODMuonContainer || m_doDumpAll) {
    ATH_CHECK( m_muonPrinter.retrieve() );
  }
  else m_muonPrinter.disable();   // to avoid auto-retrieval
 
  if (m_doDumpTrigCompsiteNavigation) {
    ATH_CHECK( m_clidSvc.retrieve() );
  }
 
  if (m_doTDTCheck || m_doDumpTrigCompsiteNavigation) {
    ATH_CHECK( m_trigDec.retrieve() );
    ATH_MSG_INFO("TDT Executing with navigation format: " << m_trigDec->getNavigationFormat());
  }
  ATH_CHECK(m_muonTracksKey.initialize(m_doDumpAll || m_doTDTCheck));
 
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

inputMetaStore() [1/2]

ServiceHandle< StoreGateSvc >& AthAnalysisAlgorithm::inputMetaStore ( )

inlineinherited

Accessor for the input metadata store.

Definition at line 51 of file AthAnalysisAlgorithm.h.

{ return m_inputMetaStore; }

inputMetaStore() [2/2]

const ServiceHandle< StoreGateSvc >& AthAnalysisAlgorithm::inputMetaStore ( ) const

inlineinherited

Const accessor for the input metadata store.

Definition at line 49 of file AthAnalysisAlgorithm.h.

{ return m_inputMetaStore; }

metaDataStop()

StatusCode AthAnalysisAlgorithm::metaDataStop ( )

protectedvirtualinherited

Function called before finalize user can read output metadata from outputMetaStore()

Dummy implementation that can be overridden by the derived tool.

Definition at line 130 of file AthAnalysisAlgorithm.cxx.

                                              {
 
   // Return gracefully:
   return StatusCode::SUCCESS;
}

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

myReplace()

void AthHistogramming::myReplace ( std::string &  str, const std::string &  oldStr, const std::string &  newStr  )

privateinherited

Helper method to replace sub-string.

Definition at line 590 of file AthHistogramming.cxx.

{
  size_t pos = 0;
  while((pos = str.find(oldStr, pos)) != std::string::npos)
    {
      str.replace(pos, oldStr.length(), newStr);
      pos += newStr.length();
    }
}

outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

outputMetaStore() [1/2]

ServiceHandle< StoreGateSvc >& AthAnalysisAlgorithm::outputMetaStore ( )

inlineinherited

Accessor for the output metadata store.

Definition at line 55 of file AthAnalysisAlgorithm.h.

{ return m_outputMetaStore; }

outputMetaStore() [2/2]

const ServiceHandle< StoreGateSvc >& AthAnalysisAlgorithm::outputMetaStore ( ) const

inlineinherited

Const accessor for the output metadata store.

Definition at line 53 of file AthAnalysisAlgorithm.h.

{ return m_outputMetaStore; }

printMuonTrk() [1/2]

void TrigEDMChecker::printMuonTrk ( const TrigMuonEFCbTrack *  muonTrack )

private

Definition at line 1566 of file TrigEDMChecker.cxx.

                                                                    {
  ATH_MSG_INFO(" POINTER TrigMuonEFCbTrack: " << muonTrack);
    //if(muonTrack) mLog << MSG::INFO << "REGTEST TrigMuonEFCbTrack: " << *muonTrack << endmsg;
 
//  printMuonTrk(mLog,(TrigMuonEFTrack*)muonTrack);
//      mLog <<MSG::INFO << "REGTEST TrigMuonEFCbTrack " << muonTrack << endmsg;
//  mLog <<MSG::INFO << "REGTEST NIdPixelHits() returns " << muonTrack->NIdPixelHits() << endmsg;
//  mLog <<MSG::INFO << "REGTEST NIdSctHits() returns " << muonTrack->NIdSctHits() << endmsg;
//  mLog <<MSG::INFO << "REGTEST NTrtHits() returns " << muonTrack->NTrtHits() << endmsg;
//  mLog <<MSG::INFO << "REGTEST matchChi2() returns " << muonTrack->matchChi2() << endmsg;
}

printMuonTrk() [2/2]

void TrigEDMChecker::printMuonTrk ( const TrigMuonEFTrack *  muonTrack )

private

Definition at line 1540 of file TrigEDMChecker.cxx.

                                                                  {
  ATH_MSG_INFO("POINTER TrigMuonEFTrack: " << muonTrack);
    //if(muonTrack) mLog << MSG::INFO << "REGTEST TrigMuonEFTrack: " << *muonTrack << endmsg;
 
//  mLog <<MSG::INFO << "REGTEST TrigMuonEFTrack->charge() returns " << muonTrack->Charge() << endmsg;
//  mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->iPt() returns " << muonTrack->iPt() << endmsg;
//  mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->CotTh() returns " << muonTrack->cotTh() << endmsg;
//  mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->Phi() returns " << muonTrack->phi() << endmsg;
//  mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->m() returns " << muonTrack->m() << endmsg;
//  mLog <<MSG::INFO << "REGTEST chi2() returns " << muonTrack->chi2() << endmsg;
//  mLog <<MSG::INFO << "REGTEST chi2prob() returns " << muonTrack->chi2prob() << endmsg;
//  mLog <<MSG::INFO << "REGTEST posX() returns " << muonTrack->posX() << endmsg;
//  mLog <<MSG::INFO << "REGTEST posY() returns " << muonTrack->posY() << endmsg;
//  mLog <<MSG::INFO << "REGTEST posZ() returns " << muonTrack->posZ() << endmsg;
//  mLog <<MSG::INFO << "REGTEST NCscHitsEta() returns " << muonTrack->NCscHitsEta() << endmsg;
//  mLog <<MSG::INFO << "REGTEST NCscHitsPhi() returns " << muonTrack->NCscHitsPhi() << endmsg;
//  mLog <<MSG::INFO << "REGTEST NTgcHitsEta() returns " << muonTrack->NTgcHitsEta() << endmsg;
//  mLog <<MSG::INFO << "REGTEST NTgcHitsPhi() returns " << muonTrack->NTgcHitsPhi() << endmsg;
//      mLog <<MSG::INFO << "REGTEST NMdtHitsEta() returns " << muonTrack->NMdtHitsEta() << endmsg;
//      mLog <<MSG::INFO << "REGTEST NMdtHitsPhi() returns " << muonTrack->NMdtHitsPhi() << endmsg;
//  mLog <<MSG::INFO << "REGTEST NRpcHitsEta() returns " << muonTrack->NRpcHitsEta() << endmsg;
//  mLog <<MSG::INFO << "REGTEST NRpcHitsPhi() returns " << muonTrack->NRpcHitsPhi() << endmsg;
//  mLog <<MSG::INFO << "REGTEST d0() returns " << muonTrack->d0() << endmsg;
//  mLog <<MSG::INFO << "REGTEST z0() returns " << muonTrack->z0() << endmsg;
}

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< Algorithm > >::renounce ( T &  h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

retrieveMetadata() [1/2]

template<typename T >

StatusCode AthAnalysisAlgorithm::retrieveMetadata ( const std::string &  folder, const std::string &  key, T &  out  )

inlineinherited

Helper function to access IOVMetaDataContainer information helped in the MetaDataStore.

Definition at line 65 of file AthAnalysisAlgorithm.h.

                                                                                                            {
        try {
            return AthAnalysisHelper::retrieveMetadata(folder,key,out,inputMetaStore());
        } catch(std::exception& e) {
            ATH_MSG_WARNING(e.what());
            return StatusCode::FAILURE;
        }
    }

retrieveMetadata() [2/2]

template<typename T >

StatusCode AthAnalysisAlgorithm::retrieveMetadata ( const std::string &  folder, const std::string &  key, T &  out, const IOVTime &  time, int  channel = -1  )

inlineinherited

Helper function to access IOVMetaDataContainer information held in InputMetaDataStore, but will check IOVTime.

Also can give a channel (leave as -1 to take first available) IOVTime(runNumber, eventNumber) is a valid constructor for example

Definition at line 76 of file AthAnalysisAlgorithm.h.

                                                                                                                                                 {
        try {
            return AthAnalysisHelper::retrieveMetadata(folder,key,out,inputMetaStore(),time,channel);
        } catch(std::exception& e) {
            ATH_MSG_WARNING(e.what());
            return StatusCode::FAILURE;
        }
    }

sysExecute()

StatusCode AthAnalysisAlgorithm::sysExecute ( const EventContext &  ctx )

overridevirtualinherited

override to do firstEvent method

Definition at line 72 of file AthAnalysisAlgorithm.cxx.

                                                                   {
  if(!m_doneFirstEvent) {
    m_doneFirstEvent=true;
    if( firstExecute().isFailure() ) {
      ATH_MSG_FATAL("Failure in firstEvent method");
      return StatusCode::FAILURE;
    }
  }
  return AthHistogramAlgorithm::sysExecute(ctx);
}

sysInitialize()

StatusCode AthAnalysisAlgorithm::sysInitialize ( )

overridevirtualinherited

Function initialising the tool in the correct way in Athena.

Reimplemented from AthHistogramAlgorithm.

Definition at line 50 of file AthAnalysisAlgorithm.cxx.

                                               {
 
      // Connect to the IncidentSvc:
      ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
      ATH_CHECK( incSvc.retrieve() );
 
      // Set up the right callbacks: //but ensure we don't double-register if sysInitialize called twice (appears to be the case)
      incSvc->removeListener( this, IncidentType::BeginInputFile );
      incSvc->addListener( this, IncidentType::BeginInputFile, 0, true );
      incSvc->removeListener( this, IncidentType::EndInputFile );
      incSvc->addListener( this, IncidentType::EndInputFile, 0, true );
      incSvc->removeListener( this, "MetaDataStop" );
      incSvc->addListener( this, "MetaDataStop", 0, true );
 
 
      // Let the base class do its thing:
      ATH_CHECK( AthHistogramAlgorithm::sysInitialize() );
 
      // Return gracefully:
      return StatusCode::SUCCESS;
}

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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.

tree()

TTree * AthHistogramming::tree ( const std::string &  treeName, const std::string &  tDir = "", const std::string &  stream = ""  )

protectedinherited

Simplify the retrieval of registered TTrees.

Definition at line 378 of file AthHistogramming.cxx.

{
  // Build a 32 bit hash out of the name
  const hash_t treeHash = this->hash(treeName);
 
  // See if this entry exists in the map
  TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
  if ( it == m_treeMap.end() ) // It doesn't exist!
    { // Let's see into the THistSvc if somebody else has registered the TTree...
 
      // Need to copy the strings as we will massage them from here on
      std::string treeNameCopy = treeName;
      std::string tDirCopy     = tDir;
      std::string streamCopy   = stream;
 
      // Massage the final string to book things
      std::string bookingString("");
      this->buildBookingString( bookingString, treeNameCopy, tDirCopy, streamCopy );
 
      TTree* treePointer(NULL);
      if ( !((histSvc()->getTree(bookingString, treePointer)).isSuccess()) )
        {
          m_msg << MSG::WARNING
                << "Problem retrieving the TTree with name " << treeNameCopy
                << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
                << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
          return NULL;
        }
      // If we get to here, we actually found the TTree in the THistSvc.
      // So let's add it to the local cache map and return its pointer
      m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treePointer ) );
      return treePointer;
    }
 
  // Return the pointer to the TTree that we got from the local cache map
  return it->second;
}

TrigCompositeNavigationToDot()

StatusCode TrigEDMChecker::TrigCompositeNavigationToDot ( std::string &  returnValue, bool &  pass  )

private

Construct graph of HLT navigation in Run-3.

Parameters

returnValue	String to populate with dot graph.
pass	When using a chain filter, if the chain group passed raw.

Navigates all TrigComposite objects in store gate and forms a relational graph in the dot format

Definition at line 4219 of file TrigEDMChecker.cxx.

                                                                                          {
 
  using namespace TrigCompositeUtils;
 
  // This constexpr is evaluated at compile time
  const CLID TrigCompositeCLID = static_cast<CLID>( ClassID_traits< xAOD::TrigCompositeContainer >::ID() );
  std::vector<std::string> keys;
  if ( m_dumpTrigCompositeContainers.size() == 0 ) {
    evtStore()->keys(TrigCompositeCLID, keys);
  }
  else {
    keys = m_dumpTrigCompositeContainers;
  }
  std::string typeNameTC;
  ATH_CHECK(m_clidSvc->getTypeNameOfID(TrigCompositeCLID, typeNameTC));
  ATH_MSG_DEBUG("Got " <<  keys.size() << " keys for " << typeNameTC);
 
  HLT::Identifier chainID(m_dumpNavForChain);
  DecisionIDContainer chainIDs;
  chainIDs.insert( chainID.numeric() );
 
  std::set<int> converted;
 
  const Trig::ChainGroup* cg = m_trigDec->getChainGroup(m_dumpNavForChain);
  pass = cg->isPassed(TrigDefs::requireDecision);
  std::vector<std::string> chains = cg->getListOfTriggers();
  for (const std::string& chain : chains) {
    const TrigConf::HLTChain* hltChain = m_trigDec->ExperimentalAndExpertMethods().getChainConfigurationDetails(chain);
    const HLT::Identifier chainID_tmp( hltChain->chain_name() );
    chainIDs.insert( chainID_tmp.numeric() );
    const std::vector<size_t> legMultiplicites = hltChain->leg_multiplicities();
    if (legMultiplicites.size() == 0) {
      ATH_MSG_ERROR("chain " << chainID_tmp << " has invalid configuration, no multiplicity data.");
    } else if (legMultiplicites.size() > 1) {
      // For multi-leg chains, the DecisionIDs are handled per leg.
      // We don't care here exactly how many objects are required per leg, just that there are two-or-more legs
      for (size_t legNumeral = 0; legNumeral < legMultiplicites.size(); ++legNumeral) {
        const HLT::Identifier legID = TrigCompositeUtils::createLegName(chainID_tmp, legNumeral);
        chainIDs.insert( legID.numeric() );
      }
    }
  }
 
  // First retrieve them all (this should not be needed in future)
  const DecisionContainer* container = nullptr;
  for (const std::string& key : keys) ATH_CHECK( evtStore()->retrieve( container, key ) );
 
  std::stringstream ss;
  ss << "digraph {" << std::endl;
  ss << "  node [shape=rectangle]" << std::endl;
  ss << "  rankdir = BT" << std::endl;
 
  // Now process them
  for (const std::string& key : keys) {
    if ( not m_doDumpAllTrigComposite ) {
      if ( not key.starts_with( "HLTNav_") ) { // Nav containers should always start with HLTNav_
        continue;
      }
    }
    ATH_CHECK( evtStore()->retrieve( container, key ) );
    ATH_MSG_DEBUG("Processing collection " << key << " to be added to the navigation graph");
    // ss << "    rank=same" << std::endl; // dot cannot handle this is seems
    bool writtenHeader = false;
    for (const Decision* tc : *container ) {
      // Output my ID in the graph. 
      const DecisionContainer* container = dynamic_cast<const DecisionContainer*>( tc->container() );
      const ElementLink<DecisionContainer> selfEL = ElementLink<DecisionContainer>(*container, tc->index());
      std::vector<ElementLink<DecisionContainer>> seedELs = tc->objectCollectionLinks<DecisionContainer>("seed");
      const bool isHypoAlgNode = tc->name() == "H";
      const bool isComboHypoAlgNode = tc->name() == "CH";
      const std::vector<DecisionID>& decisions = tc->decisions();
      const uint32_t selfKey = selfEL.key();
      const uint32_t selfIndex = selfEL.index();
      if (m_dumpNavForChain != "") {
        bool doDump = false;
        // Check me
        for (DecisionID id : decisions) {
          if (chainIDs.count(id) == 1) {
            doDump = true;
            break;
          }
        }
        // Check my seeds
        if (!doDump and (isHypoAlgNode or isComboHypoAlgNode) and not m_excludeFailedHypoNodes) {
          for (const ElementLink<DecisionContainer>& s : seedELs) {
            const std::vector<DecisionID>& seedDecisions = (*s)->decisions();
            for (DecisionID id : seedDecisions) {
              if (chainIDs.count(id) == 1) {
                doDump = true;
                break;
              }
            }
          }
        }
        if (!doDump) {
          continue;
        }
      }
      if (!writtenHeader) {
        writtenHeader = true;
        ss << "  subgraph " << key << " {" << std::endl;
        ss << "    label=\"" << key << "\"" << std::endl;
      }
      const std::string scheme = "rdpu9";
      std::string color = "1";
      if      (tc->name() == "L1") { color = "1"; }
      else if (tc->name() == "F")  { color = "2"; }
      else if (tc->name() == "IM") { color = "3"; }
      else if (tc->name() == "H")  { color = "4"; }
      else if (tc->name() == "CH") { color = "5"; }
      else if (tc->name() == "SF") { color = "6"; }
      else if (tc->name() == "HLTPassRaw") { color = "7"; }
      ss << "    \"" << selfKey << "_" << selfIndex << "\" [colorscheme="<<scheme<<",style=filled,fillcolor="<<color<<",label=<<B>Container</B>=" << typeNameTC; 
      if (tc->name() != "") ss << " <B>Name</B>=" << tc->name();
      ss << "<BR/><B>Key</B>=" << key << "<BR/><B>Index</B>=" << selfIndex;
      const bool isRemapped = tc->isRemapped();
      if (isHypoAlgNode) ss << " <B>linksRemapped</B>=" << (isRemapped ? "Y" : "N");
      if (decisions.size() > 0) {
        ss << "<BR/><B>Pass</B>=";
        size_t c = 0;
        for (unsigned decisionID : decisions) {
          HLT::Identifier dID(decisionID);
          std::string highlight = (dID.numeric() == chainID.numeric() ? "<B>[CHAIN:" : "");
          if (highlight == "" and chainIDs.count(dID.numeric()) == 1 and TrigCompositeUtils::isLegId(dID)) {
            highlight = "<B>[LEG" + std::to_string(TrigCompositeUtils::getIndexFromLeg(dID)) + ":";
          }
          ss << std::hex << highlight << decisionID << (!highlight.empty() ? "]</B>" : "") << std::dec << ",";
          if (c++ == 5) {
            ss << "<BR/>";
            c = 0;
          }
        }
      }
      ss << ">]" << std::endl;
      // Output all the things I link to
      size_t seedCount = 0;
      for (size_t i = 0; i < tc->linkColNames().size(); ++i) {
        const std::string link = tc->linkColNames().at(i);
        if (link == "seed" || link == "seed__COLL") {
          ElementLink<DecisionContainer> seedEL = seedELs.at(seedCount++);
          const uint32_t seedKey = tc->linkColKeys().at(i);
          const uint32_t seedIndex = tc->linkColIndices().at(i);
          ATH_CHECK( seedKey == seedEL.key() );
          ATH_CHECK( seedIndex == seedEL.index() );
          if (m_dumpNavForChain != "") { // Only print "seed" link to nodes we include in our search
            const std::vector<DecisionID> seedDecisions = (*seedEL)->decisions();
            bool doSeedLink = false;
            for (DecisionID id : seedDecisions) {
              if (chainIDs.count(id) == 1) {
                doSeedLink = true;
                break;
              }
            }            
            if (!doSeedLink) {
              continue;
            }
          }
          ss << "    \"" << selfKey << "_" << selfIndex << "\" -> \"" << seedKey << "_" << seedIndex << "\" [colorscheme="<<scheme<<",color=9,fontcolor=8,label=\"seed\"]" << std::endl;
        } else {
          // Start with my class ID
          std::string linkColour = "12";
          std::string linkBackground = "11";
          const std::string extScheme =  "paired12";
          if      (link == "roi") { linkColour="2"; linkBackground="1"; }
          else if (link == "initialRoI") { linkColour="2"; linkBackground="1"; }
          else if (link == "initialRecRoI") { linkColour="8"; linkBackground="7"; }
          else if (link == "feature") { linkColour="4"; linkBackground="3"; }
          else if (link == "view") { linkColour="10"; linkBackground="9"; }
          const CLID linkCLID = static_cast<CLID>( tc->linkColClids().at(i) );
          // Use it to get my class name
          std::string tname;
          ATH_CHECK(m_clidSvc->getTypeNameOfID(linkCLID, tname));
          // Now get the sgkey I'm linking to & the index
          const SG::sgkey_t key = (isRemapped ? static_cast<SG::sgkey_t>( tc->linkColKeysRemap().at(i) ) : static_cast<SG::sgkey_t>( tc->linkColKeys().at(i) ));
          const unsigned index = (isRemapped ? tc->linkColIndicesRemap().at(i) : tc->linkColIndices().at(i));
          // Look it up
          CLID checkCLID;
          const std::string* keyStr = evtStore()->keyToString(key, checkCLID); // I don't own this str
          if (keyStr != nullptr && checkCLID != linkCLID) {
            std::string tnameOfCheck;
            m_clidSvc->getTypeNameOfID(checkCLID, tnameOfCheck).ignore(); // Might be invalid. But we don't care.
            ATH_MSG_ERROR("Inconsistent CLID " << checkCLID << " [" << tnameOfCheck << "] stored in storegate for key " << key
              << ". We were expecting " << linkCLID << " [" << tname << "]");
          }
 
          std::string tnameEscape;
          for (std::string::const_iterator i = tname.begin(); i != tname.end(); ++i) {
            unsigned char c = *i;
            if (c == '<') {
              tnameEscape += "&lt;";
            } else if (c == '>') {
              tnameEscape += "&gt;";
            } else {
              tnameEscape += c;
            }
          }
 
          // Print
          ss << "    \"" << selfKey << "_" << selfIndex << "\" -> \"" << key << "_" << index << "\" ";
          ss << "[colorscheme="<<extScheme<<",color="<<linkColour<<",fontcolor="<<linkColour<<",arrowhead=empty,label=\"" << link << "\"]" << std::endl; 
 
          // Check if we are linking to self (e.g. a dummy-feature), don't output a new box for this
          const bool linkToSelf = (selfKey == key and selfIndex == index);
 
          if (converted.count(key + index) == 0 and not linkToSelf) {
            ss << "    \"" << key << "_" << index << "\" [colorscheme="<<extScheme<<",style=filled,fillcolor="<<linkBackground<<",label=<<B>Container</B>=" << tnameEscape << "<BR/><B>Key</B>=";
            if (keyStr != nullptr) ss << *keyStr;
            else ss << "[<I>KEY "<< key <<" NOT IN STORE</I>] "; 
            ss << "<BR/><B>Index</B>=" << index << ">]";
          }
 
          converted.insert(key + index);
        }
      }
    }
    if (writtenHeader) {
      ss << "  }" << std::endl;
    }
  }
 
  ss << "}" << std::endl;
 
  returnValue.assign( ss.str() );
  return StatusCode::SUCCESS;
}

updateEvtStore()

void AthAnalysisAlgorithm::updateEvtStore ( Gaudi::Details::PropertyBase &  prop )

protectedinherited

Definition at line 45 of file AthAnalysisAlgorithm.cxx.

                                                                        {
  evtStore().release().ignore(); 
  evtStore().setTypeAndName(prop.toString());
}

updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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);
      }
    }
  }

Member Data Documentation

m_clidSvc

ServiceHandle< ::IClassIDSvc > TrigEDMChecker::m_clidSvc

private

Definition at line 216 of file TrigEDMChecker.h.

m_currentFile

TFile* AthAnalysisAlgorithm::m_currentFile {nullptr}

privateinherited

Definition at line 120 of file AthAnalysisAlgorithm.h.

m_decisionsKey

SG::WriteHandleKey<TrigCompositeUtils::DecisionContainer> TrigEDMChecker::m_decisionsKey { this, "Decisions", "RoIDecisions", "Decisions created from TEs" }

private

Definition at line 220 of file TrigEDMChecker.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_doDumpAll

bool TrigEDMChecker::m_doDumpAll

private

a handle on Store Gate for access to the Event Store

Definition at line 48 of file TrigEDMChecker.h.

m_doDumpAllTrigComposite

bool TrigEDMChecker::m_doDumpAllTrigComposite

private

Definition at line 180 of file TrigEDMChecker.h.

m_doDumpCombinedMuonFeature

bool TrigEDMChecker::m_doDumpCombinedMuonFeature

private

Definition at line 95 of file TrigEDMChecker.h.

m_doDumpHLTResult

bool TrigEDMChecker::m_doDumpHLTResult

private

Definition at line 146 of file TrigEDMChecker.h.

m_doDumpLVL1_ROI

bool TrigEDMChecker::m_doDumpLVL1_ROI

private

Definition at line 52 of file TrigEDMChecker.h.

m_doDumpMuonFeature

bool TrigEDMChecker::m_doDumpMuonFeature

private

Definition at line 99 of file TrigEDMChecker.h.

m_doDumpNavigation

bool TrigEDMChecker::m_doDumpNavigation

private

Definition at line 183 of file TrigEDMChecker.h.

m_doDumpStoreGate

bool TrigEDMChecker::m_doDumpStoreGate

private

Definition at line 167 of file TrigEDMChecker.h.

m_doDumpTauJetContainer

bool TrigEDMChecker::m_doDumpTauJetContainer

private

Definition at line 158 of file TrigEDMChecker.h.

m_doDumpTileMuFeature

bool TrigEDMChecker::m_doDumpTileMuFeature

private

Definition at line 102 of file TrigEDMChecker.h.

m_doDumpTileTrackMuFeature

bool TrigEDMChecker::m_doDumpTileTrackMuFeature

private

Definition at line 105 of file TrigEDMChecker.h.

m_doDumpTrackParticleContainer

bool TrigEDMChecker::m_doDumpTrackParticleContainer

private

Definition at line 55 of file TrigEDMChecker.h.

m_doDumpTrigCompsiteNavigation

bool TrigEDMChecker::m_doDumpTrigCompsiteNavigation

private

Definition at line 203 of file TrigEDMChecker.h.

m_doDumpTrigEFBjetContainer

bool TrigEDMChecker::m_doDumpTrigEFBjetContainer

private

Definition at line 73 of file TrigEDMChecker.h.

m_doDumpTrigEFBphysContainer

bool TrigEDMChecker::m_doDumpTrigEFBphysContainer

private

Definition at line 70 of file TrigEDMChecker.h.

m_doDumpTrigElectronContainer

bool TrigEDMChecker::m_doDumpTrigElectronContainer

private

Definition at line 125 of file TrigEDMChecker.h.

m_doDumpTrigEMCluster

bool TrigEDMChecker::m_doDumpTrigEMCluster

private

Definition at line 82 of file TrigEDMChecker.h.

m_doDumpTrigEMClusterContainer

bool TrigEDMChecker::m_doDumpTrigEMClusterContainer

private

Definition at line 85 of file TrigEDMChecker.h.

m_doDumpTrigInDetTrackCollection

bool TrigEDMChecker::m_doDumpTrigInDetTrackCollection

private

Definition at line 149 of file TrigEDMChecker.h.

m_doDumpTrigL2BjetContainer

bool TrigEDMChecker::m_doDumpTrigL2BjetContainer

private

Definition at line 76 of file TrigEDMChecker.h.

m_doDumpTrigL2BphysContainer

bool TrigEDMChecker::m_doDumpTrigL2BphysContainer

private

Definition at line 67 of file TrigEDMChecker.h.

m_doDumpTrigMissingET

bool TrigEDMChecker::m_doDumpTrigMissingET

private

Definition at line 58 of file TrigEDMChecker.h.

m_doDumpTrigMuonEFContainer

bool TrigEDMChecker::m_doDumpTrigMuonEFContainer

private

Definition at line 111 of file TrigEDMChecker.h.

m_doDumpTrigMuonEFInfoContainer

bool TrigEDMChecker::m_doDumpTrigMuonEFInfoContainer

private

Definition at line 114 of file TrigEDMChecker.h.

m_doDumpTrigMuonEFIsolationContainer

bool TrigEDMChecker::m_doDumpTrigMuonEFIsolationContainer

private

Definition at line 122 of file TrigEDMChecker.h.

m_doDumpTrigPassBits

bool TrigEDMChecker::m_doDumpTrigPassBits

private

Definition at line 50 of file TrigEDMChecker.h.

m_doDumpTrigPhotonContainer

bool TrigEDMChecker::m_doDumpTrigPhotonContainer

private

Definition at line 108 of file TrigEDMChecker.h.

m_doDumpTrigTauClusterContainer

bool TrigEDMChecker::m_doDumpTrigTauClusterContainer

private

Definition at line 79 of file TrigEDMChecker.h.

m_doDumpTrigTauContainer

bool TrigEDMChecker::m_doDumpTrigTauContainer

private

Definition at line 140 of file TrigEDMChecker.h.

m_doDumpTrigTauTracksInfo

bool TrigEDMChecker::m_doDumpTrigTauTracksInfo

private

Definition at line 143 of file TrigEDMChecker.h.

m_doDumpTrigVertexCollection

bool TrigEDMChecker::m_doDumpTrigVertexCollection

private

Definition at line 152 of file TrigEDMChecker.h.

m_doDumpxAODElectronContainer

bool TrigEDMChecker::m_doDumpxAODElectronContainer

private

Definition at line 134 of file TrigEDMChecker.h.

m_doDumpxAODJetContainer

bool TrigEDMChecker::m_doDumpxAODJetContainer

private

Definition at line 64 of file TrigEDMChecker.h.

m_doDumpxAODMuonContainer

bool TrigEDMChecker::m_doDumpxAODMuonContainer

private

Definition at line 119 of file TrigEDMChecker.h.

m_doDumpxAODPhotonContainer

bool TrigEDMChecker::m_doDumpxAODPhotonContainer

private

Definition at line 137 of file TrigEDMChecker.h.

m_doDumpxAODTauJetContainer

bool TrigEDMChecker::m_doDumpxAODTauJetContainer

private

Definition at line 155 of file TrigEDMChecker.h.

m_doDumpxAODTrackParticle

bool TrigEDMChecker::m_doDumpxAODTrackParticle

private

Definition at line 161 of file TrigEDMChecker.h.

m_doDumpxAODTrigElectronContainer

bool TrigEDMChecker::m_doDumpxAODTrigElectronContainer

private

Definition at line 128 of file TrigEDMChecker.h.

m_doDumpxAODTrigEMCluster

bool TrigEDMChecker::m_doDumpxAODTrigEMCluster

private

Definition at line 89 of file TrigEDMChecker.h.

m_doDumpxAODTrigEMClusterContainer

bool TrigEDMChecker::m_doDumpxAODTrigEMClusterContainer

private

Definition at line 92 of file TrigEDMChecker.h.

m_doDumpxAODTrigMinBias

bool TrigEDMChecker::m_doDumpxAODTrigMinBias

private

Definition at line 173 of file TrigEDMChecker.h.

m_doDumpxAODTrigMissingET

bool TrigEDMChecker::m_doDumpxAODTrigMissingET

private

Definition at line 61 of file TrigEDMChecker.h.

m_doDumpxAODTrigPhotonContainer

bool TrigEDMChecker::m_doDumpxAODTrigPhotonContainer

private

Definition at line 131 of file TrigEDMChecker.h.

m_doDumpxAODVertex

bool TrigEDMChecker::m_doDumpxAODVertex

private

Definition at line 164 of file TrigEDMChecker.h.

m_doneFirstEvent

bool AthAnalysisAlgorithm::m_doneFirstEvent {false}

privateinherited

Definition at line 122 of file AthAnalysisAlgorithm.h.

m_doTDTCheck

bool TrigEDMChecker::m_doTDTCheck

private

Definition at line 170 of file TrigEDMChecker.h.

m_dumpNavForChain

Gaudi::Property<std::string> TrigEDMChecker::m_dumpNavForChain {this, "DumpNavigationForChain", "", "Optional chain to restrict navigation dump info."}

private

Definition at line 185 of file TrigEDMChecker.h.

m_dumpTrigCompositeContainers

std::vector<std::string> TrigEDMChecker::m_dumpTrigCompositeContainers

private

Definition at line 181 of file TrigEDMChecker.h.

m_effMap

EffMap_t AthHistogramming::m_effMap

privateinherited

The map of histogram names to their pointers.

Definition at line 208 of file AthHistogramming.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_excludeFailedHypoNodes

Gaudi::Property<bool> TrigEDMChecker::m_excludeFailedHypoNodes

private

Initial value:

{this, "excludeFailedHypoNodes", false,
    "Optional flag to exclude nodes which fail the hypothesis tool for a chain when dumping navigation graphs."}

Definition at line 186 of file TrigEDMChecker.h.

m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects

privateinherited

Definition at line 79 of file AthAlgorithm.h.

m_graphMap

GraphMap_t AthHistogramming::m_graphMap

privateinherited

The map of TGraph names to their pointers.

Definition at line 222 of file AthHistogramming.h.

m_histMap

HistMap_t AthHistogramming::m_histMap

privateinherited

The map of histogram names to their pointers.

Definition at line 201 of file AthHistogramming.h.

m_histNamePostfix

std::string AthHistogramAlgorithm::m_histNamePostfix

privateinherited

The postfix for the histogram THx name.

Definition at line 97 of file AthHistogramAlgorithm.h.

m_histNamePrefix

std::string AthHistogramAlgorithm::m_histNamePrefix

privateinherited

The prefix for the histogram THx name.

Definition at line 94 of file AthHistogramAlgorithm.h.

m_histSvc

ServiceHandle<ITHistSvc> AthHistogramAlgorithm::m_histSvc

privateinherited

Default constructor: AthHistogramAlgorithm();.

a handle on the Hist/TTree registration service

Definition at line 83 of file AthHistogramAlgorithm.h.

m_histTitlePostfix

std::string AthHistogramAlgorithm::m_histTitlePostfix

privateinherited

The postfix for the histogram THx title.

Definition at line 103 of file AthHistogramAlgorithm.h.

m_histTitlePrefix

std::string AthHistogramAlgorithm::m_histTitlePrefix

privateinherited

The prefix for the histogram THx title.

Definition at line 100 of file AthHistogramAlgorithm.h.

m_inputMetaStore

ServiceHandle< StoreGateSvc > AthAnalysisAlgorithm::m_inputMetaStore

privateinherited

Object accessing the input metadata store.

Definition at line 116 of file AthAnalysisAlgorithm.h.

m_msg

MsgStream AthHistogramming::m_msg

privateinherited

Cached Message Stream.

Definition at line 248 of file AthHistogramming.h.

m_muonPrinter

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

private

Definition at line 214 of file TrigEDMChecker.h.

m_muonTracksKey

SG::ReadHandleKey< xAOD::TrackParticleContainer > TrigEDMChecker::m_muonTracksKey { this, "MuonTracksKey", "HLT_IDTrack_Muon_FTF"}

private

Definition at line 218 of file TrigEDMChecker.h.

m_name

std::string AthHistogramming::m_name

privateinherited

Instance name.

Definition at line 245 of file AthHistogramming.h.

m_navigationHandleKey

SG::ReadHandleKey< xAOD::TrigNavigation > TrigEDMChecker::m_navigationHandleKey { this, "TrigNavigation", "TrigNavigation", "" }

private

Definition at line 219 of file TrigEDMChecker.h.

m_navigationTool

ToolHandle< HLT::Navigation > TrigEDMChecker::m_navigationTool { this, "NavigationTool", "HLT::Navigation/Navigation", "" }

private

Definition at line 221 of file TrigEDMChecker.h.

m_outputMetaStore

ServiceHandle< StoreGateSvc > AthAnalysisAlgorithm::m_outputMetaStore

privateinherited

Object accessing the output metadata store.

Definition at line 118 of file AthAnalysisAlgorithm.h.

m_prefix

std::string AthHistogramAlgorithm::m_prefix

privateinherited

Name of the ROOT output stream (file)

Definition at line 88 of file AthHistogramAlgorithm.h.

m_rootDir

std::string AthHistogramAlgorithm::m_rootDir

privateinherited

Name of the ROOT directory.

Definition at line 91 of file AthHistogramAlgorithm.h.

m_streamName

std::string AthHistogramming::m_streamName

privateinherited

Name of the ROOT output stream (file)

Definition at line 226 of file AthHistogramming.h.

m_trackWarningNum

int TrigEDMChecker::m_trackWarningNum {0}

private

Definition at line 224 of file TrigEDMChecker.h.

m_treeMap

TreeMap_t AthHistogramming::m_treeMap

privateinherited

The map of TTree names to their pointers.

Definition at line 215 of file AthHistogramming.h.

m_trigDec

PublicToolHandle< Trig::TrigDecisionTool > TrigEDMChecker::m_trigDec { this, "TriggerDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool", ""}

private

Definition at line 222 of file TrigEDMChecker.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vertexWarningNum

int TrigEDMChecker::m_vertexWarningNum {0}

private

Definition at line 225 of file TrigEDMChecker.h.

m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• TrigEDMChecker.h
• TrigEDMChecker.cxx