ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
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 > &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...
 

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...
 
TH1bookGetPointer (const TH1 &hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms. More...
 
TH1bookGetPointer (TH1 *hist, const std::string &tDir="", const std::string &stream="")
 Simplify the booking and registering (into THistSvc) of histograms. More...
 
TH1bookGetPointer (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...
 
TH1hist (const std::string &histName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered histograms of any type. More...
 
TH2hist2d (const std::string &histName, const std::string &tDir="", const std::string &stream="")
 Simplify the retrieval of registered 2-d histograms. More...
 
TH3hist3d (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< StoreGateSvcStoreGateSvc_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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 
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::IMuonPrintingToolm_muonPrinter {this, "MuonPrinter", "Rec::MuonPrintingTool/MuonPrintingTool"}
 
ServiceHandle< ::IClassIDSvc > m_clidSvc
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_muonTracksKey { this, "MuonTracksKey", "HLT_IDTrack_Muon_FTF"}
 
SG::ReadHandleKey< xAOD::TrigNavigationm_navigationHandleKey { this, "TrigNavigation", "TrigNavigation", "" }
 
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainerm_decisionsKey { this, "Decisions", "RoIDecisions", "Decisions created from TEs" }
 
ToolHandle< HLT::Navigationm_navigationTool { this, "NavigationTool", "HLT::Navigation/Navigation", "" }
 
PublicToolHandle< Trig::TrigDecisionToolm_trigDec { this, "TriggerDecisionTool", "Trig::TrigDecisionTool/TrigDecisionTool", ""}
 
int m_trackWarningNum {0}
 
int m_vertexWarningNum {0}
 
ServiceHandle< StoreGateSvcm_inputMetaStore
 Object accessing the input metadata store. More...
 
ServiceHandle< StoreGateSvcm_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 36 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 113 of file TrigEDMChecker.cxx.

114  : AthAnalysisAlgorithm(name, pSvcLocator),
115  m_clidSvc( "ClassIDSvc", name )
116 {
119  declareProperty("doDumpAll", m_doDumpAll = true);
120  declareProperty("doDumpTrigPassBits", m_doDumpTrigPassBits = false);
121  declareProperty("doDumpLVL1_ROI", m_doDumpLVL1_ROI = false);
122  declareProperty("doDumpTrigMissingET", m_doDumpTrigMissingET = false);
123  declareProperty("doDumpxAODTrigMissingET", m_doDumpxAODTrigMissingET = false);
124  declareProperty("doDumpMuonFeature", m_doDumpMuonFeature = false);
125  declareProperty("doDumpCombinedMuonFeature", m_doDumpCombinedMuonFeature = false);
126  declareProperty("doDumpTileMuFeature", m_doDumpTileMuFeature = false);
127  declareProperty("doDumpTileTrackMuFeature", m_doDumpTileTrackMuFeature = false);
128  declareProperty("doDumpTrigPhotonContainer", m_doDumpTrigPhotonContainer = false);
129  declareProperty("doDumpTrigL2BphysContainer", m_doDumpTrigL2BphysContainer = false);
130  declareProperty("doDumpTrigEFBphysContainer", m_doDumpTrigEFBphysContainer = false);
131  declareProperty("doDumpTrigEFBjetContainer", m_doDumpTrigEFBjetContainer = false);
132  declareProperty("doDumpTrigL2BjetContainer", m_doDumpTrigL2BjetContainer = false);
133  declareProperty("doDumpxAODJetContainer", m_doDumpxAODJetContainer = false);
134  declareProperty("doDumpTrigMuonEFContainer", m_doDumpTrigMuonEFContainer = false);
135  declareProperty("doDumpTrigMuonEFInfoContainer", m_doDumpTrigMuonEFInfoContainer = false);
136  declareProperty("doDumpTrigMuonEFIsolationContainer", m_doDumpTrigMuonEFIsolationContainer = false);
137  declareProperty("doDumpxAODMuonContainer", m_doDumpxAODMuonContainer = false);
138  declareProperty("doDumpTrigElectronContainer", m_doDumpTrigElectronContainer = false);
139  declareProperty("doDumpxAODTrigElectronContainer", m_doDumpxAODTrigElectronContainer = false);
140  declareProperty("doDumpxAODTrigPhotonContainer", m_doDumpxAODTrigPhotonContainer = false);
141  declareProperty("doDumpxAODElectronContainer", m_doDumpxAODElectronContainer = false);
142  declareProperty("doDumpxAODPhotonContainer", m_doDumpxAODPhotonContainer = false);
143  declareProperty("doDumpHLTResult", m_doDumpHLTResult = false);
144  declareProperty("doDumpTrigTauContainer", m_doDumpTrigTauContainer = false);
145  declareProperty("doDumpTrigTauTracksInfo", m_doDumpTrigTauTracksInfo = false);
146  declareProperty("doDumpTrigInDetTrackCollection", m_doDumpTrigInDetTrackCollection = false);
147  declareProperty("doDumpTrigVertexCollection", m_doDumpTrigVertexCollection = false);
148  declareProperty("doDumpTrigEMCluster", m_doDumpTrigEMCluster = false);
149  declareProperty("doDumpTrigEMClusterContainer", m_doDumpTrigEMClusterContainer = false);
150  declareProperty("doDumpxAODTrigEMCluster", m_doDumpxAODTrigEMCluster = false);
151  declareProperty("doDumpxAODTrigEMClusterContainer", m_doDumpxAODTrigEMClusterContainer = false);
152  declareProperty("doDumpTrigTauClusterContainer", m_doDumpTrigTauClusterContainer = false);
153  declareProperty("doDumpTrackParticleContainer", m_doDumpTrackParticleContainer = false);
154  declareProperty("doDumpTauJetContainer", m_doDumpTauJetContainer = false);
155  declareProperty("doDumpxAODTrackParticle", m_doDumpxAODTrackParticle = false);
156  declareProperty("doDumpxAODVertex", m_doDumpxAODVertex = false);
157  declareProperty("doDumpxAODTauJetContainer", m_doDumpxAODTauJetContainer = false);
158  declareProperty("doDumpxAODTrigMinBias", m_doDumpxAODTrigMinBias = false);
159  declareProperty("doDumpStoreGate", m_doDumpStoreGate = false );
160  declareProperty("doDumpAllTrigComposite", m_doDumpAllTrigComposite = false );
161  declareProperty("dumpTrigCompositeContainers", m_dumpTrigCompositeContainers, "List of TC to dump" );
162  declareProperty("doDumpTrigCompsiteNavigation", m_doDumpTrigCompsiteNavigation = false );
163  declareProperty("doDumpNavigation", m_doDumpNavigation = false );
164  declareProperty("doTDTCheck", m_doTDTCheck = false );
165  declareProperty( "ClassIDSvc", m_clidSvc, "Service providing CLID info" );
166 }

◆ ~TrigEDMChecker()

TrigEDMChecker::~TrigEDMChecker ( )
virtual

Definition at line 170 of file TrigEDMChecker.cxx.

170 {}

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::MuonTPMetaDataAlg.

Definition at line 114 of file AthAnalysisAlgorithm.cxx.

114  {
115 
116  // Return gracefully:
117  return StatusCode::SUCCESS;
118 }

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

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

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

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

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

404 {
405  // Call the other Book method and see if it returns a valid pointer
406  TTree* treePointer = this->bookGetPointer( treeRef, tDir, stream );
407  if ( treePointer )
408  {
409  return StatusCode::SUCCESS;
410  }
411  else
412  {
413  return StatusCode::FAILURE;
414  }
415 }

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

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

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

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

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

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

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

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

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

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

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

428 {
429  // Get a pointer
430  const TGraph* graphPointer = &graphRef;
431 
432  // Check that we got a valid pointer
433  if ( !graphPointer )
434  {
435  m_msg << MSG::WARNING
436  << "We got an invalid TGraph pointer in the BookGetPointer(TGraph*) method of the class" << m_name
437  << "!" << endmsg;
438  return NULL;
439  }
440 
441  // Modify the name and title according to the prefixes of this classes instance
442  std::string graphName = graphPointer->GetName();
443  const std::string graphTitle = graphPointer->GetTitle();
444 
445  // Check if the hash for this graphName already exists, i.e., if we have a hash collision
446  const hash_t graphHash = this->hash(graphName);
447  GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
448  if ( it != m_graphMap.end() ) // It does exist!
449  {
450  m_msg << MSG::WARNING
451  << "Detected a hash collision. The hash for the TGraph with name=" << graphName
452  << " already exists and points to a TGraph with name=" << it->second->GetName()
453  << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
454  return NULL;
455  }
456 
457  // Create a clone that has the new name
458  TGraph* graphClone = dynamic_cast< TGraph* >( graphPointer->Clone((m_histNamePrefix+graphName+m_histNamePostfix).c_str()) );
459  if( !graphClone )
460  {
461  m_msg << MSG::WARNING
462  << "We couldn't clone the TGraph in the BookGetPointer(TGraph&) method of the class" << m_name
463  << "!" << endmsg;
464  return NULL;
465  }
466  graphClone->SetTitle ((m_histTitlePrefix+graphTitle+m_histTitlePostfix).c_str());
467 
468  // Massage the final string to book things
469  std::string bookingString("");
470  this->buildBookingString( bookingString, graphName, tDir, stream );
471 
472  // Register the TGraph into the THistSvc
473  if ( !((histSvc()->regGraph(bookingString, graphClone)).isSuccess()) )
474  {
475  m_msg << MSG::WARNING
476  << "Problem registering TGraph with name " << graphName
477  << ", title " << graphTitle
478  << " in " << m_name << "!" << endmsg;
479  return NULL;
480  }
481 
482  // Also register it in the local map of string to pointer
483  m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphClone ) );
484 
485  return graphClone;
486 }

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

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

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

313 {
314  // Get a pointer
315  const TTree* treePointer = &treeRef;
316 
317  // Check that we got a valid pointer
318  if ( !treePointer )
319  {
320  m_msg << MSG::WARNING
321  << "We got an invalid TTree pointer in the BookGetPointer(TTree*) method of the class" << m_name
322  << "!" << endmsg;
323  return NULL;
324  }
325 
326  // Modify the name and title according to the prefixes of this classes instance
327  std::string treeName = treePointer->GetName();
328  const std::string treeTitle = treePointer->GetTitle();
329 
330  // Check if the hash for this treeName already exists, i.e., if we have a hash collision
331  const hash_t treeHash = this->hash(treeName);
332  TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
333  if ( it != m_treeMap.end() ) // It does exist!
334  {
335  m_msg << MSG::WARNING
336  << "Detected a hash collision. The hash for the TTree with name=" << treeName
337  << " already exists and points to a TTree with name=" << it->second->GetName()
338  << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
339  return NULL;
340  }
341 
342  // Create a clone that has the new name
343  TTree* treeClone = dynamic_cast< TTree* >( treePointer->Clone(treeName.c_str()) );
344  if( !treeClone )
345  {
346  m_msg << MSG::WARNING
347  << "We couldn't clone the TTree in the BookGetPointer(TTree&) method of the class" << m_name
348  << "!" << endmsg;
349  return NULL;
350  }
351  treeClone->SetTitle (treeTitle.c_str());
352 
353  // Massage the final string to book things
354  std::string bookingString("");
355  this->buildBookingString( bookingString, treeName, tDir, stream );
356 
357  // Register the TTree into the THistSvc
358  if ( !((histSvc()->regTree(bookingString, treeClone)).isSuccess()) )
359  {
360  m_msg << MSG::WARNING
361  << "Problem registering TTree with name " << treeName
362  << ", title " << treeTitle
363  << " in " << m_name << "!" << endmsg;
364  return NULL;
365  }
366 
367  // Also register it in the local map of string to pointer
368  m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treeClone ) );
369 
370  return treeClone;
371 }

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

147 {
148  // Modify the name and title according to the prefixes of this classes instance
149  std::string effName(effRef.GetName());
150  const std::string effTitle(effRef.GetTitle());
151  std::string bookingString("");
152 
153  this->buildBookingString( bookingString, effName, tDir, stream );
154  effRef.SetTitle((m_histTitlePrefix+effTitle+m_histTitlePostfix).c_str() );
155  effRef.SetName(effName.c_str());
156 
157  // Check if the hash for this effName already exists, i.e., if we have a hash collision
158  const hash_t effHash = this->hash(effName);
159  EffMap_t::const_iterator it = m_effMap.find( effHash );
160  if ( it != m_effMap.end() ) // It does exist!
161  {
162  m_msg << MSG::WARNING
163  << "Detected a hash collision. The hash for the TEfficiency with name=" << effName
164  << " already exists and points to a TEfficiency with name=" << it->second->GetName()
165  << " NOT going to book the new TEfficiency and returning a NULL pointer!" << endmsg;
166  return NULL;
167  }
168 
169  // Set the new name and title for the TEfficiency, based on the prefixes that the user set for this class instance
170  // Create a clone that has the new name
171 
172  // Massage the final string to book things
173 
174  // Register the TEfficiency into the THistSvc
175  if ( !((histSvc()->regEfficiency(bookingString, &effRef)).isSuccess()) )
176  {
177  m_msg << MSG::WARNING
178  << "Problem registering TEfficiency with name " << effName
179  << ", name prefix " << m_histNamePrefix
180  << ", title " << effTitle
181  << ", tile prefix " << m_histTitlePrefix
182  << ", and tile postfix " << m_histTitlePostfix
183  << " in " << m_name << "!" << endmsg;
184  return NULL;
185  }
186 
187  // Also register it in the local map of string to pointer
188  m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, &effRef ) );
189 
190  return &effRef;
191 }

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

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

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

99 {
100  // Modify the name and title according to the prefixes of this classes instance
101  std::string histName(histRef.GetName());
102  const std::string histTitle(histRef.GetTitle());
103  std::string bookingString("");
104 
105  this->buildBookingString( bookingString, histName, tDir, stream );
106  histRef.SetTitle((m_histTitlePrefix+histTitle+m_histTitlePostfix).c_str() );
107  histRef.SetName(histName.c_str());
108 
109  // Check if the hash for this histName already exists, i.e., if we have a hash collision
110  const hash_t histHash = this->hash(histName);
111  HistMap_t::const_iterator it = m_histMap.find( histHash );
112  if ( it != m_histMap.end() ) // It does exist!
113  {
114  m_msg << MSG::WARNING
115  << "Detected a hash collision. The hash for the histogram with name=" << histName
116  << " already exists and points to a histogram with name=" << it->second->GetName()
117  << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
118  return NULL;
119  }
120 
121  // Set the new name and title for the histogram, based on the prefixes that the user set for this class instance
122  // Create a clone that has the new name
123 
124  // Massage the final string to book things
125 
126  // Register the histogram into the THistSvc
127  if ( !((histSvc()->regHist(bookingString, &histRef)).isSuccess()) )
128  {
129  m_msg << MSG::WARNING
130  << "Problem registering histogram with name " << histName
131  << ", name prefix " << m_histNamePrefix
132  << ", title " << histTitle
133  << ", tile prefix " << m_histTitlePrefix
134  << ", and tile postfix " << m_histTitlePostfix
135  << " in " << m_name << "!" << endmsg;
136  return NULL;
137  }
138 
139  // Also register it in the local map of string to pointer
140  m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, &histRef ) );
141 
142  return &histRef;
143 }

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

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

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

565 {
566  // Massage the final string to book things
567  if(tDir.empty()) tDir = m_rootDir;
568  size_t pos = histName.rfind('/');
569  if(pos != std::string::npos){
570  tDir+='/';
571  tDir.append(histName, 0,pos);
572  histName.erase(0,pos+1);
573  };
574  if(stream.empty()) stream = m_streamName;
575 
576  if(usePrefixPostfix){
577  bookingString = "/"+stream+"/"+tDir+"/"+m_histNamePrefix+histName+m_histNamePostfix;
578  } else {
579  bookingString = "/"+stream+"/"+tDir+"/"+histName;
580  }
581  while(bookingString.find("//") != std::string::npos){
582  this->myReplace(bookingString,"//","/");
583  }
584 
585  return;
586 }

◆ 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 4155 of file TrigEDMChecker.cxx.

4155  {
4156 
4157  const std::string name = tc->linkColNames().at(element);
4158  const CLID clid = static_cast<CLID>(tc->linkColClids().at(element));
4159 
4161 
4163  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to TrigRoiDescriptorCollection, link name:'" << name << "'");
4164  else ATH_MSG_DEBUG(" Dereferenced link '" << name << "'' to TrigRoiDescriptor:" << *elementLink);
4165 
4166  } else if (clid == ClassID_traits< DataVector< LVL1::RecEmTauRoI > >::ID()) { // There could be a few ROI types....
4167  // CLASS_DEF( DataVector< LVL1::RecEmTauRoI >, 6256, 1 )
4168 
4170  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to LVL1::RecEmTauRoI, link name:'" << name << "'");
4171  else ATH_MSG_DEBUG(" Dereferenced link '" << name << "' to LVL1::RecEmTauRoI:" << *elementLink);
4172 
4174 
4176  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to TrigComposite, link name:'" << name << "'");
4177  else ATH_MSG_DEBUG(" Dereferenced link '" << name << "' to TrigComposite, TC name:'" << (*elementLink)->name() << "'");
4178 
4179  } else if (clid == ClassID_traits< ViewContainer >::ID()) {
4180 
4181  const ElementLink<ViewContainer> elementLink = tc->objectLink<ViewContainer>(name);
4182  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to View, link name:'" << name << "'");
4183  else ATH_MSG_DEBUG(" Dereferenced link '" << name << "' to View:'" << *elementLink);
4184 
4185  } else if (name == "feature") {
4186 
4188 
4190  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to xAOD::TrigEMClusterContainer 'feature'");
4191  else ATH_MSG_DEBUG(" Dereferenced xAOD::TrigEMClusterContainer link 'feature', Energy:" << (*elementLink)->energy());
4192 
4194 
4196  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to xAOD::TrigMissingETContainer 'feature'");
4197  else ATH_MSG_DEBUG(" Dereferenced xAOD::TrigMissingETContainer link 'feature', ex:" << (*elementLink)->ex() << " ey:" << (*elementLink)->ey());
4198 
4199  } else {
4200 
4201  try {
4203  if (!elementLink.isValid()) ATH_MSG_WARNING(" Invalid element link to 'feature'");
4204  else ATH_MSG_DEBUG(" Dereferenced IParticle link 'feature', pt:" << (*elementLink)->pt() << " eta:" << (*elementLink)->eta() << " phi:" << (*elementLink)->phi());
4205  } catch(std::runtime_error& e) {
4206  ATH_MSG_WARNING(" Cannot dereference 'feature' as IParticle: '" << e.what() << "'");
4207  }
4208 
4209  }
4210 
4211  } else {
4212  ATH_MSG_DEBUG(" Ignoring link to '" << name << "' with link CLID " << clid);
4213  }
4214 
4215  return StatusCode::SUCCESS;
4216 
4217 }

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

70 {
73  m_rootDir = rootDir;
74  m_histNamePrefix = histNamePrefix;
75  m_histNamePostfix = histNamePostfix;
76  m_histTitlePrefix = histTitlePrefix;
77  m_histTitlePostfix = histTitlePostfix;
78 
79  return StatusCode::SUCCESS;
80 }

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

147  {
148  if(m_currentFile) return m_currentFile;
149 
150  //get the EventSelector so we can get it's list of input files
151  //dont get it with a ServiceHandle, because that invokes initialize, can get into init loop
152 
153  IProperty* evtSelector = 0;
154  if(service(evtSelName,evtSelector,false).isFailure()) {
155  ATH_MSG_ERROR("currentFile(): Couldn't find the service: " << evtSelName);return 0;
156  }
157  //SmartIF<IProperty> evtSelector(mysel);
158  /*
159  ServiceHandle<IProperty> evtSelector(evtSelName,name());
160 
161  if(evtSelector.retrieve().isFailure()) {
162  ATH_MSG_ERROR("currentFile(): Couldn't find the service: " << evtSelName);return 0;
163  }*/
164 
165  try {
166  //get the list of input files - use this to determine which open file is the current input file
167  const StringArrayProperty& inputCollectionsName = dynamic_cast<const StringArrayProperty&>(evtSelector->getProperty("InputCollections"));
168 
169  ATH_MSG_VERBOSE("nOpenFile=" << gROOT->GetListOfFiles()->GetSize() << ". nFilesInInputCollection=" << inputCollectionsName.value().size());
170  if(msgLvl(MSG::VERBOSE)) {
171  for(int i=0;i<gROOT->GetListOfFiles()->GetSize();i++) {
172  ATH_MSG_VERBOSE("Open file: " << gROOT->GetListOfFiles()->At(i)->GetName());
173  }
174  }
175 
176  //look through list of files and find the one from the input collection that is currently open
177 
178  for(int i=0;i<gROOT->GetListOfFiles()->GetSize();i++) {
179  TFile *g = (TFile*)gROOT->GetListOfFiles()->At(i);
180  //see if this file is in the input file list
181  //strip everything except stuff either side of last /
182  TString s(g->GetName());
183  TObjArray* tokens = s.Tokenize("/");
184  TObjString* lastToken = dynamic_cast<TObjString*>(tokens->Last());
185  TString sToCompare("");
186  bool shortComparison(false);
187  if(tokens->GetEntries()>1) {
188  TString beforeSlash((dynamic_cast<TObjString*>(tokens->At(tokens->GetEntries()-2)))->GetString());
189  if(beforeSlash.Length()>0) sToCompare += beforeSlash;
190  sToCompare += "/";
191  } else {
192  shortComparison=true;
193  }
194  sToCompare += lastToken->GetString();
195  TString sToCompare_short(lastToken->GetString()); //short versions search
196  delete tokens;
197 
198  for(unsigned int j=0;j<inputCollectionsName.value().size();j++) {
199  TString t(inputCollectionsName.value()[j].c_str());
200  //try perfect match first
201  if(s.EqualTo(t)) {
202  ATH_MSG_VERBOSE("Current File is: " << inputCollectionsName.value()[j]);
203  m_currentFile = g;
204  return g;
205  }
206  TObjArray* tokens = t.Tokenize("/");
207  TObjString* lastToken = dynamic_cast<TObjString*>(tokens->Last());
208  TString tToCompare = "";
209  bool shortComparison2(false);
210  if(tokens->GetEntries()>1) {
211  TString beforeSlash((dynamic_cast<TObjString*>(tokens->At(tokens->GetEntries()-2)))->GetString());
212  if(beforeSlash.Length()>0) tToCompare += beforeSlash;
213  tToCompare += "/";
214  } else {
215  shortComparison2=true;
216  }
217  tToCompare += lastToken->GetString();
218  TString tToCompare_short(lastToken->GetString());
219  delete tokens;
220 
221  if(shortComparison || shortComparison2) { //doing short version search, no directories to distinguish files!
222  if(sToCompare_short.EqualTo(tToCompare_short)) {
223  ATH_MSG_VERBOSE("Current File is: " << inputCollectionsName.value()[j]);
224  m_currentFile = g;
225  return g;
226  }
227  } else
228  if(sToCompare.EqualTo(tToCompare)) {
229  ATH_MSG_VERBOSE("Current File is: " << inputCollectionsName.value()[j]);
231  return g;
232  }
233  }
234  }
235 
236  } catch(...) {
237  ATH_MSG_ERROR("currentFile(): Couldn't load InputCollections property of " << evtSelName); return 0;
238  }
239 
240  ATH_MSG_ERROR("currentFile(): Could not find the current file!");
241  return 0; //something went wrong :-(
242 
243 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< 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.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

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

95 { return m_detStore; }

◆ dumpHLTResult()

StatusCode TrigEDMChecker::dumpHLTResult ( )
private

Definition at line 2109 of file TrigEDMChecker.cxx.

2109  {
2110 
2111  ATH_MSG_DEBUG("in dumpHLTResult()");
2112 
2113  ATH_MSG_INFO("REGTEST ==========START of HLTResult DUMP===========");
2114 
2115  const HLT::HLTResult* hltResult = 0;
2116  StatusCode sc=evtStore()->retrieve( hltResult, "HLTResult_L2");
2117  if( sc.isFailure() || !hltResult ) {
2118  ATH_MSG_INFO("No HLTResult_L2 found in TDS");
2119  return StatusCode::SUCCESS;
2120  }
2121  ATH_MSG_INFO("REGTEST HLTResult_L2 Successfully Retrieved");
2122 
2123  ATH_MSG_INFO("REGTEST HLTResult_L2->isEmpty() returns " << hltResult->isEmpty());
2124  ATH_MSG_INFO("REGTEST HLTResult_L2->size() returns " << hltResult->size());
2125  ATH_MSG_INFO("REGTEST HLTResult_L2->isPassThrough() returns " << hltResult->isPassThrough());
2126  ATH_MSG_INFO("REGTEST HLTResult_L2->isAccepted() returns " << hltResult->isAccepted());
2127 
2128  ATH_MSG_INFO("REGTEST ==========END of HLTResult DUMP===========");
2129 
2130  ATH_MSG_DEBUG("dumpHLTResult() succeeded");
2131 
2132  return StatusCode::SUCCESS;
2133 }

◆ dumpLVL1_ROI()

StatusCode TrigEDMChecker::dumpLVL1_ROI ( )
private

Definition at line 1172 of file TrigEDMChecker.cxx.

1172  {
1173 
1174  ATH_MSG_DEBUG("in dumpLVL1_ROI()");
1175 
1176  ATH_MSG_INFO("REGTEST ==========START of LVL1_ROI DUMP===========");
1177 
1178  const LVL1_ROI * lvl1ROI;
1179  StatusCode sc = evtStore()->retrieve(lvl1ROI);
1180  if (sc.isFailure() ) {
1181  ATH_MSG_INFO("REGTEST No LVL1_ROI found");
1182  return StatusCode::SUCCESS;
1183  }
1184 
1185  ATH_MSG_INFO("REGTEST LVL1_ROI retrieved");
1186 
1187  LVL1_ROI::emtaus_type::const_iterator itEMTau =
1188  (lvl1ROI->getEmTauROIs()).begin();
1189  LVL1_ROI::emtaus_type::const_iterator itEMTau_e =
1190  (lvl1ROI->getEmTauROIs()).end();
1191  int j = 0;
1192  for( ; itEMTau != itEMTau_e; ++itEMTau, ++j) {
1193  ATH_MSG_INFO("REGTEST Looking at LVL1_ROI " << j);
1194  ATH_MSG_INFO("REGTEST LVL1 EmTauROI Eta is " << itEMTau->getEta());
1195  ATH_MSG_INFO("REGTEST LVL1 EmTauROI Phi is " << itEMTau->getPhi());
1196  ATH_MSG_INFO("REGTEST LVL1 EmTauROI EMClus is " << itEMTau->getEMClus());
1197  ATH_MSG_INFO("REGTEST LVL1 EmTauROI TauClus is " << itEMTau->getTauClus());
1198  ATH_MSG_INFO("REGTEST LVL1 EmTauROI EMIsol is " << itEMTau->getEMIsol());
1199  ATH_MSG_INFO("REGTEST LVL1 EmTauROI HadIsol is " << itEMTau->getHadIsol());
1200  ATH_MSG_INFO("REGTEST LVL1 EmTauROI Core is " << itEMTau->getCore());
1201  ATH_MSG_INFO("REGTEST LVL1 EmTauROI HadCore is " << itEMTau->getHadCore());
1202  ATH_MSG_INFO("REGTEST LVL1 EmTauROI roiWord is " << itEMTau->getROIWord());
1203  }
1204 
1205  ATH_MSG_INFO("REGTEST ==========END of LVL1_ROI DUMP===========");
1206  ATH_MSG_DEBUG("dumpLVL1_ROI() succeeded");
1207  return StatusCode::SUCCESS;
1208 }

◆ dumpNavigation()

StatusCode TrigEDMChecker::dumpNavigation ( )
private

Definition at line 4446 of file TrigEDMChecker.cxx.

4447 {
4448  // Get object from store
4449  const xAOD::TrigNavigation * navigationHandle = nullptr;
4450  ATH_CHECK( evtStore()->retrieve( navigationHandle, m_navigationHandleKey.key() ) );
4451  // Proper version doesn't work - conversion issue?
4452  //SG::ReadHandle< xAOD::TrigNavigation > navigationHandle = SG::ReadHandle< xAOD::TrigNavigation >( m_navigationHandleKey );
4453  //if ( !navigationHandle.isValid() ) ATH_MSG_FATAL( "Could not retrieve navigation" );
4454 
4455  // Get serialised navigation info
4456  const std::vector< unsigned int > serialisedNavigation = navigationHandle->serialized();
4457  ATH_MSG_INFO( "Serialised navigation size: " << serialisedNavigation.size() );
4458 
4459  // Convert the input
4460  HLT::Navigation* testNav = m_navigationTool.get();
4461  testNav->deserialize( serialisedNavigation );
4462 
4463  // Make a map of TE name hashes
4464  const xAOD::TriggerMenuContainer * testMenu = nullptr;
4465  ATH_CHECK( inputMetaStore()->retrieve( testMenu, "TriggerMenu" ) );
4466  std::map< int, std::string > hash2string;
4467  for ( auto const& sequence : testMenu->front()->sequenceInputTEs() ) {
4468  for ( auto const& name : sequence ) {
4470  hash2string[ hash ] = name;
4471  }
4472  }
4473 
4474  // Map TE names to chain names
4475  unsigned int chainCounter = 0;
4476  std::map< int, std::string > hash2chain;
4477  for ( auto const& chain : testMenu->front()->chainSignatureOutputTEs() ) {
4478 
4479  // Find the chain name
4480  std::string chainName = testMenu->front()->chainNames()[ chainCounter ];
4481  ++chainCounter;
4482 
4483  // Find all associated TEs
4484  for ( auto const& signature : chain ) {
4485  for ( auto const& name : signature ) {
4487  hash2string[ hash ] = name; // for decoding
4488  hash2chain[ hash ] = chainName;
4489  }
4490  }
4491  }
4492 
4493  // Define a map of TE features, to the TEs that use them. Needs a custom sort lambda
4494  auto cmpLambda = []( const HLT::TriggerElement::FeatureAccessHelper &lhs, const HLT::TriggerElement::FeatureAccessHelper &rhs) {
4495 
4496  // Compare indices if CLID matches
4497  if ( lhs.getCLID() == rhs.getCLID() ) return ( lhs.getIndex() < rhs.getIndex() );
4498 
4499  // Compare CLIDs
4500  else return ( lhs.getCLID() < rhs.getCLID() );
4501  };
4502  std::map< HLT::TriggerElement::FeatureAccessHelper, std::vector< HLT::TriggerElement* >, decltype(cmpLambda) > feature2element(cmpLambda);
4503 
4504  // Retrieve all TE features and add them to the map
4505  std::vector< HLT::TriggerElement* > allTEs;
4506  testNav->getAll( allTEs, false );
4507  for ( auto element : allTEs ) {
4508 
4509  // Add TE features to the big map
4510  for ( auto helper : element->getFeatureAccessHelpers() ) {
4511  feature2element[ helper ].push_back( element );
4512  }
4513  }
4514 
4515  // Debug - output all TEs and their ancestors
4516  // No duplication - only print terminal nodes
4517  for ( auto element : allTEs ) {
4518  if ( testNav->isTerminalNode( element ) ) {
4519  ATH_MSG_INFO( "+++++++++++ " << hash2string[ element->getId() ] << " is terminal node" );
4520  ATH_MSG_INFO( "ptr: " << element );
4521  std::queue< HLT::TriggerElement* > allAncestors;
4522  allAncestors.push( element );
4523  while ( allAncestors.size() ) {
4524 
4525  HLT::TriggerElement * thisElement = allAncestors.front();
4526  allAncestors.pop();
4527  auto theseAncestors = thisElement->getRelated( HLT::TriggerElement::Relation::seededByRelation );
4528 
4529  // Dump TE
4530  ATH_MSG_INFO( "te: " << thisElement->getId() << " " << hash2string[ thisElement->getId() ] );
4531  ATH_MSG_INFO( " chain: " << hash2chain[ thisElement->getId() ] );
4532  for ( auto helper : thisElement->getFeatureAccessHelpers() ) {
4533  ATH_MSG_INFO( " feat: " << helper );
4534  }
4535  ATH_MSG_INFO( theseAncestors.size() << " ancestors" );
4536 
4537  // Examine ancestors
4538  for ( auto ancestor : theseAncestors ) {
4539  allAncestors.push( ancestor );
4540  }
4541  }
4542  }
4543  }
4544 
4545  // Make the decision container
4547  auto decisionOutput = outputNavigation.ptr();
4548 
4549  // Find unique chains associated with a feature
4550  std::map< HLT::TriggerElement const*, std::vector< int > > element2decisions;
4551  for ( const auto& pair : feature2element ) {
4552 
4553  // Get the feature info
4554  std::string featureName = testNav->label( pair.first.getCLID(), pair.first.getIndex().subTypeIndex() );
4555  auto sgKey = evtStore()->stringToKey( featureName, pair.first.getCLID() );
4556 
4557  // Store RoIs with appropriate label ?
4558  std::string storeFeatureName = "feature";
4559 /* if ( pair.first.getCLID() == ClassID_traits< TrigRoiDescriptor >::ID() ) {
4560  storeFeatureName = "roi";
4561  }*/
4562 
4563  // Make a decision object for the feature
4564  auto decision = TrigCompositeUtils::newDecisionIn( decisionOutput );
4565  decision->typelessSetObjectLink( storeFeatureName, sgKey, pair.first.getCLID(), pair.first.getIndex().objectsBegin(), pair.first.getIndex().objectsEnd() );
4566 
4567  // Examine associated TEs, look for chains
4568  std::set< std::string > passedChains;
4569  for ( HLT::TriggerElement const* element : pair.second ) {
4570 
4571  // TODO - find out what chains actually passed!
4572  passedChains.insert( hash2chain[ element->getId() ] );
4573 
4574  // Index the TE
4575  int decisionNumber = decisionOutput->size() - 1;
4576  element2decisions[ element ].push_back( decisionNumber );
4577  }
4578 
4579  // Store unique chains in the decision
4580  for ( auto& chain : passedChains ) {
4582  }
4583  }
4584 
4585  // Store decision ancestry (had to go through once before to ensure indices populated)
4586  unsigned int decisionCounter = 0;
4587  for ( const auto& pair : feature2element ) {
4588 
4589  // Get current decision
4590  auto decision = decisionOutput->at( decisionCounter );
4591  ++decisionCounter;
4592 
4593  // Find ancestor TEs
4594  for ( auto element : pair.second ) {
4595  auto theseAncestors = element->getRelated( HLT::TriggerElement::Relation::seededByRelation );
4596  for ( auto ancestor : theseAncestors ) {
4597  for ( int decisionIndex : element2decisions[ ancestor ] ) {
4598  TrigCompositeUtils::linkToPrevious( decision, m_decisionsKey.key(), decisionIndex );
4599  }
4600  }
4601  }
4602  }
4603 
4604  return StatusCode::SUCCESS;
4605 }

◆ dumpStoreGate()

StatusCode TrigEDMChecker::dumpStoreGate ( )
private

◆ dumpTDT()

StatusCode TrigEDMChecker::dumpTDT ( )
private

Definition at line 4023 of file TrigEDMChecker.cxx.

4023  {
4024  using namespace TrigCompositeUtils; // LinkInfo
4025  ATH_MSG_INFO( "REGTEST ==========START of TDT DUMP===========" );
4026  // Note: This minimal TDT dumper is for use during run-3 dev
4027  std::string chain = m_dumpNavForChain;
4028  if (chain.empty()) {
4029  chain = "HLT_.*";
4030  }
4031  std::vector<std::string> confChains = m_trigDec->getListOfTriggers(chain);
4032  for (const auto& item : confChains) {
4033  bool passed = m_trigDec->isPassed(item);
4034  ATH_MSG_INFO(" HLT Item " << item << " (numeric ID " << TrigConf::HLTUtils::string2hash(item, "Identifier") << ") passed raw? " << passed);
4035  if (m_trigDec->getNavigationFormat() == "TriggerElement") {
4036  ATH_MSG_DEBUG(" Skipping Run 2 features in this dumper");
4037  continue;
4038  }
4039  std::vector< LinkInfo<xAOD::IParticleContainer> > passFeatures = m_trigDec->features<xAOD::IParticleContainer>(item);
4040  if (passFeatures.size()) {
4041  ATH_MSG_INFO(" " << item << " Passed Final IParticle features size: " << passFeatures.size());
4042  for (const LinkInfo<xAOD::IParticleContainer>& li : passFeatures) {
4043  if (!li.isValid()) {
4044  ATH_MSG_WARNING(" Unable to access feature - link invalid.");
4045  } else {
4046  try {
4047  std::string state = "ACTIVE";
4048  if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
4049  else if (li.state == ActiveState::UNSET) state = "UNSET";
4050  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);
4051  } catch (const std::exception& e) {
4052  ATH_MSG_WARNING(" Unable to dereference feature {" << e.what() << "}");
4053  }
4054  }
4055  }
4056  }
4057  std::vector< LinkInfo<xAOD::IParticleContainer> > passAndFailFeatures = m_trigDec->features<xAOD::IParticleContainer>(item, TrigDefs::includeFailedDecisions);
4058  if (passAndFailFeatures.size()) {
4059  ATH_MSG_INFO(" " << item << " Passed+Failed Final IParticle features size: " << passAndFailFeatures.size());
4060  for (const LinkInfo<xAOD::IParticleContainer>& li : passAndFailFeatures) {
4061  if (!li.isValid()) {
4062  ATH_MSG_WARNING(" Unable to access feature - link invalid.");
4063  } else {
4064  try {
4065  std::string state = "ACTIVE";
4066  if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
4067  else if (li.state == ActiveState::UNSET) state = "UNSET";
4068  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);
4069  } catch (const std::exception& e) {
4070  ATH_MSG_WARNING(" Unable to dereference feature {" << e.what() << "}");
4071  }
4072  }
4073  }
4074  }
4075  std::vector< LinkInfo<xAOD::IParticleContainer> > allFeatures = m_trigDec->features<xAOD::IParticleContainer>(item, TrigDefs::includeFailedDecisions, "", TrigDefs::allFeaturesOfType);
4076  if (allFeatures.size()) {
4077  ATH_MSG_INFO(" " << item << " Passed+Failed ALL IParticle features size: " << allFeatures.size());
4078  for (const LinkInfo<xAOD::IParticleContainer>& li : allFeatures) {
4079  if (!li.isValid()) {
4080  ATH_MSG_WARNING(" Unable to access feature - link invalid.");
4081  } else {
4082  try {
4083  std::string state = "ACTIVE";
4084  if (li.state == ActiveState::INACTIVE) state = "INACTIVE";
4085  else if (li.state == ActiveState::UNSET) state = "UNSET";
4086  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);
4087  } catch (const std::exception& e) {
4088  ATH_MSG_WARNING(" Unable to dereference feature {" << e.what() << "}");
4089  }
4090  }
4091  }
4092  }
4093  }
4094 
4095  if (m_trigDec->getNavigationFormat() == "TrigComposite") {
4096  // Check associateToEventView helper function
4097  std::vector< LinkInfo<xAOD::IParticleContainer> > muons = m_trigDec->features<xAOD::IParticleContainer>("HLT_mu24_idperf_L1MU20", TrigDefs::Physics, "HLT_MuonL2CBInfo");
4098  SG::ReadHandle<xAOD::TrackParticleContainer> muonTracksReadHandle(m_muonTracksKey, Gaudi::Hive::currentContext());
4099  for (const LinkInfo<xAOD::IParticleContainer>& mu : muons) {
4100  // Note: auto here refers to type std::pair< xAOD::TrackParticleContainer::const_iterator, xAOD::TrackParticleContainer::const_iterator>
4101  const auto roiTrackItPair = m_trigDec->associateToEventView<xAOD::TrackParticleContainer>(muonTracksReadHandle, mu, "roi");
4102  const xAOD::TrackParticleContainer::const_iterator startIt = roiTrackItPair.first;
4103  const xAOD::TrackParticleContainer::const_iterator stopIt = roiTrackItPair.second;
4104  ATH_MSG_INFO("Muon pT: " << (*mu.link)->pt() << " is from the same ROI as tracks with index "
4105  << std::distance(muonTracksReadHandle->begin(), startIt) << "-" << std::distance(muonTracksReadHandle->begin(), stopIt)
4106  << ", which is " << std::distance(startIt, stopIt) << " tracks, out of " << muonTracksReadHandle->size() << " total tracks.");
4107  for (xAOD::TrackParticleContainer::const_iterator it = startIt; it != stopIt; ++it) {
4108  ATH_MSG_VERBOSE(" -- Track " << std::distance(startIt, it) << " in this ROI, pT: " << (*it)->pt() );
4109  }
4110  }
4111  }
4112 
4113  ATH_MSG_INFO( "REGTEST ==========END of TDT DUMP===========" );
4114  return StatusCode::SUCCESS;
4115 }

◆ dumpTrackParticleContainer()

StatusCode TrigEDMChecker::dumpTrackParticleContainer ( )
private

track

track vertex position

access to TrackSummary information

Definition at line 1065 of file TrigEDMChecker.cxx.

1065  {
1066 
1067  ATH_MSG_DEBUG("in dumpTrackParticleContainer()");
1068 
1069  ATH_MSG_INFO("REGTEST ==========START of TrackParticleContainer DUMP===========");
1070 
1071  std::string trackPtags[]={"HLT_InDetTrigParticleCreation_Bjet_EFID",
1072  "HLT_InDetTrigParticleCreation_Bphysics_EFID",
1073  "HLT_InDetTrigParticleCreation_Electron_EFID",
1074  "HLT_InDetTrigParticleCreation_FullScan_EFID",
1075  "HLT_InDetTrigParticleCreation_Muon_EFID",
1076  "HLT_InDetTrigParticleCreation_Photon_EFID",
1077  "HLT_InDetTrigParticleCreation_Tau_EFID"};
1078 
1079  int ntag=7;
1080 
1081  StatusCode returnsc=StatusCode::SUCCESS;
1082 
1083  for (int itag=0; itag<ntag; itag++){
1084  const Rec::TrackParticleContainer* pTrackParticleC = nullptr;
1085  StatusCode sc = evtStore()->retrieve(pTrackParticleC, trackPtags[itag]);
1086  if (sc.isFailure()) {
1087  ATH_MSG_INFO("REGTEST No TrackParticleContainer found with tag " << trackPtags[itag]);
1088  continue;
1089  }
1090  ATH_MSG_INFO("TrackParticleContainer found with tag " << trackPtags[itag]
1091  << " and size " << pTrackParticleC->size());
1092 
1093  Rec::TrackParticleContainer::const_iterator trackItr = pTrackParticleC->begin();
1094  Rec::TrackParticleContainer::const_iterator trackItrE = pTrackParticleC->end();
1095  for (int ind=1; trackItr != trackItrE; ++trackItr, ind++) {
1096  const Rec::TrackParticle * trackParticle = (*trackItr);
1097  ATH_MSG_INFO(" TrackParticle " << ind << " charge "
1098  << trackParticle->charge() << " p "
1099  << trackParticle->p()<< " eta " << trackParticle->eta()
1100  << " phi " << trackParticle->phi());
1101 
1103  const Trk::Track * track = trackParticle->originalTrack();
1104  if ( track ) {
1105  ATH_MSG_INFO(" Got attached track");
1106  const Trk::TrackParameters* perigee = track->perigeeParameters();
1107  if (perigee) {
1108  const auto& parameterVector = perigee->parameters();
1109  ATH_MSG_INFO(" q/P " << parameterVector[Trk::qOverP] <<
1110  " theta " << parameterVector[Trk::theta] <<
1111  " phi " <<parameterVector[Trk::phi]);
1112  } else {
1113  ATH_MSG_INFO(" No perigee attached to track");
1114  }
1115 
1116  } else {
1117  if( m_trackWarningNum <= maxRepWarnings ) {
1118  ATH_MSG_DEBUG(" No attached track");
1119  if( m_trackWarningNum == maxRepWarnings) {
1120  ATH_MSG_WARNING(" Max attached track warning reached, no further warnings given");
1121  }
1123  }
1124  }
1125 
1127  const Trk::VxCandidate * vertex = trackParticle->reconstructedVertex();
1128  if ( vertex ) {
1129  const Trk::RecVertex& vtx = vertex->recVertex();
1130  const Amg::Vector3D& position = vtx.position();
1131  ATH_MSG_INFO(" vertex position (" << position[0] << ", " <<
1132  position[1] << ", " << position[2] << ") ");
1133  } else {
1134  if( m_vertexWarningNum <= maxRepWarnings ) {
1135  ATH_MSG_DEBUG(" No attached vertex");
1136  if( m_vertexWarningNum == maxRepWarnings) {
1137  ATH_MSG_WARNING(" Max attached vertex warning reached, no further warnings given");
1138  }
1140  }
1141  }
1142 
1143  const Trk::Perigee* perigee = trackParticle->measuredPerigee();
1144  if (perigee) {
1145  const auto& parameters = perigee->parameters();
1146  ATH_MSG_INFO("Trk::Perigee parameters:");
1147  ATH_MSG_INFO(" * d_0 : "<< parameters[Trk::d0] );
1148  ATH_MSG_INFO(" * z_0 : "<< parameters[Trk::z0] );
1149  ATH_MSG_INFO(" * phi : "<< parameters[Trk::phi] );
1150  ATH_MSG_INFO(" * Theta : "<< parameters[Trk::theta] );
1151  ATH_MSG_INFO(" * q/p : "<< parameters[Trk::qOverP] );
1152  } else {
1153  ATH_MSG_WARNING(" No attached perigee");
1154  }
1156  const Trk::TrackSummary* summary = trackParticle->trackSummary();
1157  if (summary) {
1158  ATH_MSG_DEBUG("Track summary information:");
1159  ATH_MSG_DEBUG(" * Number of B layer hits : "<<summary->get(Trk::numberOfBLayerHits));
1160  ATH_MSG_DEBUG(" * Number of pixel hits : "<<summary->get(Trk::numberOfPixelHits));
1161  ATH_MSG_DEBUG(" * Number of SCT hits : "<<summary->get(Trk::numberOfSCTHits));
1162  ATH_MSG_DEBUG(" * Number of TRT hits : "<<summary->get(Trk::numberOfTRTHits));
1163  }
1164  }
1165  }
1166  return returnsc;
1167 }

◆ dumpTrigComposite()

StatusCode TrigEDMChecker::dumpTrigComposite ( )
private

Dump information on TrigComposite collections.

Only dumpTrigCompositeContainers are dumped unless doDumpAllTrigComposite is set

Definition at line 4117 of file TrigEDMChecker.cxx.

4117  {
4118  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigCompositeContainer DUMP===========" );
4119 
4122  const CLID TrigCompositeCLID = static_cast<CLID>( ClassID_traits< xAOD::TrigCompositeContainer >::ID() );
4123  evtStore()->keys(TrigCompositeCLID, m_dumpTrigCompositeContainers);
4124  std::string typeNameTC;
4125  ATH_CHECK(m_clidSvc->getTypeNameOfID(TrigCompositeCLID, typeNameTC));
4126  ATH_MSG_DEBUG("dumpTrigComposite got " << m_dumpTrigCompositeContainers.size() << " keys for " << typeNameTC);
4127  } else {
4128  ATH_MSG_DEBUG("Using supplied " << m_dumpTrigCompositeContainers.size() << " keys");
4129  }
4130 
4131  for ( const std::string & key: m_dumpTrigCompositeContainers ) {
4132  // get the collection
4133  if ( not evtStore()->contains<xAOD::TrigCompositeContainer>(key) ) {
4134  ATH_MSG_WARNING("Absent TrigCompositeContainer: " << key );
4135  continue;
4136  }
4137  ATH_MSG_DEBUG( "#################### Dumping container of : " << key );
4138  const xAOD::TrigCompositeContainer* cont= nullptr;
4139  ATH_CHECK( evtStore()->retrieve( cont, key ) );
4140 
4141  size_t count = 0;
4142  for ( auto tc: *cont ) {
4143  ATH_MSG_DEBUG("########## ELEMENT " << count++);
4144  ATH_MSG_DEBUG(*tc);
4145  // Get the objects we know of
4146  for (size_t i = 0; i < tc->linkColNames().size(); ++i) ATH_CHECK(checkTrigCompositeElementLink(tc, i));
4147  }
4148  }
4149  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigCompositeContainer DUMP===========" );
4150  return StatusCode::SUCCESS;
4151 }

◆ dumpTrigEFBphysContainer()

StatusCode TrigEDMChecker::dumpTrigEFBphysContainer ( )
private

Definition at line 2344 of file TrigEDMChecker.cxx.

2344  {
2345 
2346  ATH_MSG_DEBUG("in dumpTrigEFBphysContainer()");
2347 
2348  ATH_MSG_INFO("REGTEST ==========START of TrigEFBphysContainer DUMP===========");
2349 
2350  std::string EFBphysTags[]={"HLT_xAOD__TrigBphysContainer_EFBMuMuFex",
2351  "HLT_xAOD__TrigBphysContainer_EFBMuMuXFex",
2352  "HLT_xAOD__TrigBphysContainer_EFDsPhiPiFex",
2353  "HLT_xAOD__TrigBphysContainer_EFMuPairs",
2354  "HLT_xAOD__TrigBphysContainer_EFMultiMuFex",
2355  "HLT_xAOD__TrigBphysContainer_EFTrackMass"
2356  };
2357 
2358  int ntag= (int) sizeof(EFBphysTags) / sizeof(EFBphysTags[0]);
2359 
2360 
2361  for (int itag=0; itag<ntag; itag++){
2362  const xAOD::TrigBphysContainer* trigEFBphys;
2363  StatusCode sc = evtStore()->retrieve(trigEFBphys, EFBphysTags[itag]);
2364  if (sc.isFailure()) {
2365  ATH_MSG_INFO("REGTEST No TrigEFBphysContainer found with tag " << EFBphysTags[itag]);
2366  continue;
2367  }
2368 
2369  ATH_MSG_INFO("REGTEST TrigEFBphysContainer found with tag " << EFBphysTags[itag]
2370  << " and size " << trigEFBphys->size());
2371 
2372  // for (int i=0; trigEFBphys != lastTrigEFBphys; ++trigEFBphys, ++i) {
2373 
2374  //mLog << MSG::INFO << "REGTEST Looking at TrigEFBphysContainer " << i << endmsg;
2375 
2376  xAOD::TrigBphysContainer::const_iterator EFBphysItr = trigEFBphys->begin();
2377  xAOD::TrigBphysContainer::const_iterator EFBphysItrE = trigEFBphys->end();
2378 
2379  for (int j=0; EFBphysItr != EFBphysItrE; ++EFBphysItr, ++j ) {
2380 
2381  ATH_MSG_INFO("REGTEST Looking at TrigEFBphys " << j);
2382 
2383  ATH_MSG_INFO("REGTEST TrigEFBphys->eta() returns " << (*EFBphysItr)->eta());
2384  ATH_MSG_INFO("REGTEST TrigEFBphys->phi() returns " << (*EFBphysItr)->phi());
2385  ATH_MSG_INFO("REGTEST TrigEFBphys->mass() returns " << (*EFBphysItr)->mass());
2386  ATH_MSG_INFO("REGTEST TrigEFBphys->fitmass() returns " << (*EFBphysItr)->fitmass());
2387  // ATH_MSG_INFO("REGTEST TrigEFBphys->isValid() returns " << (*EFBphysItr)->isValid());
2388  ATH_MSG_INFO("REGTEST TrigEFBphys->roiId() returns " << (*EFBphysItr)->roiId());
2389  ATH_MSG_INFO("REGTEST TrigEFBphys->particleType() returns " << (*EFBphysItr)->particleType());
2390 
2391  if( (*EFBphysItr)->secondaryDecay() != NULL){
2392  const xAOD::TrigBphys * psecond =(*EFBphysItr)->secondaryDecay();
2393  ATH_MSG_INFO("REGTEST Secondary decay info: ");
2394  ATH_MSG_INFO("REGTEST pSecondDecay->eta() returns " << psecond->eta());
2395  ATH_MSG_INFO("REGTEST pSecondDecay->phi() returns " << psecond->phi());
2396  ATH_MSG_INFO("REGTEST pSecondDecay->mass() returns " << psecond->mass());
2397  ATH_MSG_INFO("REGTEST pSecondDecay->fitmass() returns " << psecond->fitmass());
2398  // ATH_MSG_INFO("REGTEST pSecondDecay->isValid() returns " << (*EFBphysItr)->secondaryDecayLink()->isValid());
2399  ATH_MSG_INFO("REGTEST pSecondDecay->roiId() returns " << psecond->roiId());
2400  ATH_MSG_INFO("REGTEST pSecondDecay->particleType() returns " << psecond->particleType());
2401 
2402  } // end if secondary exists
2403 
2404 
2405 
2406  const std::vector<ElementLink<xAOD::TrackParticleContainer> > trackVector = (*EFBphysItr)->trackParticleLinks();
2407  if (trackVector.size() != 0) {
2408  ATH_MSG_INFO(" REGTEST got track vector size: " << trackVector.size());
2409  } else {
2410  ATH_MSG_INFO(" REGTEST no track vector!!! " );
2411  }
2412  std::vector<ElementLink<xAOD::TrackParticleContainer> >::const_iterator trkIt=trackVector.begin();
2413  for (int itrk=0 ; trkIt!= trackVector.end(); ++itrk, ++trkIt) {
2414  if (!(trkIt->isValid())) {
2415  ATH_MSG_WARNING("TrackParticleContainer::Invalid ElementLink to track ");
2416  continue;
2417  }
2418  //const Trk::Perigee* trackPerigee=(*(*trkIt))->measuredPerigee();
2419  const Trk::Perigee* trackPerigee=&((*(*trkIt))->perigeeParameters());
2420 
2421  // msg() << MSG::VERBOSE << "track, iterator, pointer " << itrk << " " << *trkIt << " " << *(*trkIt) << endmsg;
2422  double phi = trackPerigee->parameters()[Trk::phi];
2423  double theta = trackPerigee->parameters()[Trk::theta];
2424  double px = trackPerigee->momentum()[Trk::px];
2425  double py = trackPerigee->momentum()[Trk::py];
2426  double pt = sqrt(px*px + py*py);
2427  double eta = -std::log(tan(theta/2));
2428 
2429  ATH_MSG_INFO("track " << itrk << " pt phi eta " << pt << " " <<
2430  phi << " " << eta);
2431  }
2432 
2433  }
2434  }
2435  ATH_MSG_INFO("REGTEST ==========END of TrigEFBphysContainer DUMP===========");
2436  ATH_MSG_DEBUG("dumpTrigEFBphysContainer() succeeded");
2437 
2438  return StatusCode::SUCCESS;
2439 }

◆ dumpTrigInDetTrackCollection()

StatusCode TrigEDMChecker::dumpTrigInDetTrackCollection ( )
private

Definition at line 2140 of file TrigEDMChecker.cxx.

2140  {
2141 
2142  std::string TrigInDetTrackTags[]={ "HLT_TrigIDSCAN_Jet",
2143  "HLT_TrigIDSCAN_Tau",
2144  "HLT_TrigIDSCAN_eGamma",
2145  "HLT_TrigIDSCAN_Muon",
2146  "HLT_TrigIDSCAN_muonIso",
2147  "HLT_TrigIDSCAN_Bphysics",
2148  "HLT_TrigIDSCAN_FullScan",
2149  "HLT_TrigIDSCAN_Cosmics",
2150  "HLT_TrigIDSCAN_eGamma_Brem",
2151  "HLT_TrigIDSCAN_Tile",
2152  "HLT_TrigSiTrack_eGamma",
2153  "HLT_TrigSiTrack_Muon",
2154  "HLT_TrigSiTrack_muonIso",
2155  "HLT_TrigSiTrack_Tau",
2156  "HLT_TrigSiTrack_Jet",
2157  "HLT_TrigSiTrack_Bphysics",
2158  "HLT_TrigSiTrack_FullScan",
2159  "HLT_TrigSiTrack_Cosmics",
2160  "HLT_TRTSegmentFinder",
2161  "HLT_TRTxK"};
2162  int ntag=20;
2163 
2164  ATH_MSG_DEBUG("in dumpTrigInDetTrackCollection()");
2165 
2166  const TrigInDetTrackTruthMap* pTruthMap(nullptr);
2167  bool gotTruthMap = false;
2168 
2169  if (evtStore()->contains<TrigInDetTrackTruthMap>("TrigInDetTrackTruthMap")) {
2170  StatusCode sc=evtStore()->retrieve(pTruthMap,"TrigInDetTrackTruthMap");
2171  if (sc.isFailure())
2172  {
2173  ATH_MSG_WARNING(" could not retrieve TrackTruthMap with key TrigInDetTruthMap");
2174  } else {
2175  gotTruthMap=true;
2176  // pTruthMap->print();
2177  }
2178  }
2179  else ATH_MSG_DEBUG(" didn't find any TrackTruthMap objects with key TrigInDetTruthMap");
2180 
2181  ATH_MSG_INFO("REGTEST ==========START of TrigInDetTrackCollection DUMP===========");
2182 
2183  for (int iTag=0; iTag < ntag; iTag++) {
2184  const TrigInDetTrackCollection* trigInDetTrackCollection = nullptr;
2185  StatusCode sc = evtStore()->retrieve(trigInDetTrackCollection,TrigInDetTrackTags[iTag] );
2186  if (sc.isFailure()) {
2187  ATH_MSG_DEBUG("REGTEST No TrigInDetTrackCollection found with key " << TrigInDetTrackTags[iTag]);
2188  continue;
2189  }
2190  ATH_MSG_INFO("REGTEST TrigInDetTrackCollections retrieved with key "
2191  << TrigInDetTrackTags[iTag]);
2192 
2193  ATH_MSG_INFO("REGTEST TrigInDetTrackCollection->size() returns " << trigInDetTrackCollection->size());
2194 
2195  TrigInDetTrackCollection::const_iterator trkItr = trigInDetTrackCollection->begin();
2196  TrigInDetTrackCollection::const_iterator trkItrE = trigInDetTrackCollection->end();
2197 
2198  for (int j=0; trkItr != trkItrE; ++trkItr, ++j ) {
2199 
2200  ATH_MSG_INFO("REGTEST Looking at TrigInDetTrack " << j);
2201 
2202  ATH_MSG_INFO("REGTEST TrigInDetTrack->algorithmId() returns " << (*trkItr)->algorithmId());
2203  ATH_MSG_INFO("REGTEST TrigInDetTrack->chi2() returns " << (*trkItr)->chi2());
2204  ATH_MSG_INFO("REGTEST TrigInDetTrack->NStrawHits() returns " << (*trkItr)->NStrawHits());
2205 
2206  ATH_MSG_INFO("REGTEST TrigInDetTrack->NStraw() returns " << (*trkItr)->NStraw());
2207  ATH_MSG_INFO("REGTEST TrigInDetTrack->NStrawTime() returns " << (*trkItr)->NStrawTime());
2208  ATH_MSG_INFO("REGTEST TrigInDetTrack->NTRHits() returns " << (*trkItr)->NTRHits());
2209 
2210  ATH_MSG_INFO("REGTEST Looking at TrigInDetFitTrack->param()");
2211  const TrigInDetTrackFitPar* my_param = (*trkItr)->param();
2212 
2213  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->a0() returns " << my_param->a0());
2214  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->z0() returns " << my_param->z0());
2215  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->phi0() returns " << my_param->phi0());
2216  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->eta() returns " << my_param->eta());
2217  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->pT() returns " << my_param->pT());
2218  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ea0() returns " << my_param->ea0());
2219  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ez0() returns " << my_param->ez0());
2220  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->ephi0() returns " << my_param->ephi0());
2221  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->eeta() returns " << my_param->eeta());
2222  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->epT() returns " << my_param->epT());
2223  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->surfaceType() returns " << my_param->surfaceType());
2224  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->surfaceCoordinate() returns " << my_param->surfaceCoordinate());
2225  ATH_MSG_INFO("REGTEST Looking at covarience matrix: ");
2226 
2227  const std::vector<double>* const my_cov = my_param->cov();
2228  if (!my_cov) {
2229  ATH_MSG_INFO("REGTEST covarience matrix NULL (not stored)");
2230  } else {
2231  std::vector<double> tempcov = *my_cov;
2233  int k;
2234  for(iter = tempcov.begin(), k=0; iter != tempcov.end(); ++iter, ++k){
2235  ATH_MSG_INFO("REGTEST TrigInDetTrackFitPar->cov() element " << k << " is " << (*iter));
2236  }
2237  }
2238  if (gotTruthMap) {
2239  if (!(pTruthMap->hasTruth((*trkItr)))) {
2240  ATH_MSG_DEBUG(" REGTEST Track has no truth info ");
2241  } else {
2242  ATH_MSG_DEBUG(" Track has truth info: ");
2243  const TrigInDetTrackTruth* pTRTtruth = pTruthMap->truth((*trkItr));
2244  int nMatches = pTRTtruth->nrMatches() ;
2245  if (nMatches==0) {
2246  ATH_MSG_INFO(" REGTEST Track has no truth matches");
2247  } else {
2248  ATH_MSG_INFO("REGTEST number of matched truth hits: Si: " << pTruthMap->bestMatchSiHits((*trkItr))
2249  << " TRT: " << pTruthMap->bestMatchTRTHits((*trkItr)));
2250  if (pTruthMap->bestMatchSiHits((*trkItr)) > 0) {
2251 
2252  const HepMcParticleLink* pSiTruth = pTruthMap->bestMatchSi((*trkItr));
2253 
2254  ATH_MSG_INFO("REGTEST Si match to kine ref " << pSiTruth->barcode());
2255  if (pSiTruth->cptr() != 0) {
2256  ATH_MSG_INFO("REGTEST Si PDG id " << pSiTruth->cptr()->pdg_id());
2257  }
2258  }
2259 
2260  if (pTruthMap->bestMatchTRTHits((*trkItr)) > 0) {
2261  const HepMcParticleLink* pTRTtruth = pTruthMap->bestMatchTRT((*trkItr));
2262 
2263  ATH_MSG_INFO("REGTEST TRT match to kine ref " << pTRTtruth->barcode());
2264  if (pTRTtruth->cptr() != 0) {
2265  ATH_MSG_INFO("REGTEST TRT PDG id " << pTRTtruth->cptr()->pdg_id());
2266  }
2267  }
2268  }
2269  }
2270  } // if (gotTruthMap)
2271  }
2272  }
2273 
2274  ATH_MSG_INFO("REGTEST ==========END of TrigInDetTrackCollection DUMP===========");
2275  ATH_MSG_DEBUG("dumpTrigInDetTrackCollection() succeeded");
2276 
2277  return StatusCode::SUCCESS;
2278 }

◆ dumpTrigL2BphysContainer()

StatusCode TrigEDMChecker::dumpTrigL2BphysContainer ( )
private

Definition at line 2442 of file TrigEDMChecker.cxx.

2442  {
2443 
2444  ATH_MSG_DEBUG("in dumpTrigL2BphysContainer()");
2445  ATH_MSG_INFO("REGTEST ==========START of TrigL2BphysContainer DUMP===========");
2446 
2447  std::string L2BphysTags[]={"HLT_xAOD__TrigBphysContainer_L2BMuMuFex",
2448  "HLT_xAOD__TrigBphysContainer_L2BMuMuXFex",
2449  "HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexDs",
2450  "HLT_xAOD__TrigBphysContainer_L2DsPhiPiFexPhi",
2451  "HLT_xAOD__TrigBphysContainer_L2JpsieeFex",
2452  "HLT_xAOD__TrigBphysContainer_L2MultiMuFex",
2453  "HLT_xAOD__TrigBphysContainer_L2TrackMass",
2454  };
2455  const int ntag = (int) sizeof(L2BphysTags) / sizeof(L2BphysTags[0]);
2456 
2457 
2458  for (int itag=0; itag<ntag; itag++){
2459  const xAOD::TrigBphysContainer* trigL2Bphys;
2460  StatusCode sc = evtStore()->retrieve(trigL2Bphys, L2BphysTags[itag]);
2461  if (sc.isFailure()) {
2462  ATH_MSG_INFO("REGTEST No TrigL2BphysContainer found with tag " << L2BphysTags[itag]);
2463  continue;
2464  }
2465 
2466  ATH_MSG_INFO("REGTEST TrigL2BphysContainer found with tag " << L2BphysTags[itag]
2467  << " and size " << trigL2Bphys->size());
2468 
2469  // for (int i=0; trigL2Bphys != lastTrigL2Bphys; ++trigL2Bphys, ++i) {
2470 
2471  // mLog << MSG::INFO << "REGTEST Looking at TrigL2BphysContainer " << i << endmsg;
2472 
2473  xAOD::TrigBphysContainer::const_iterator L2BphysItr = trigL2Bphys->begin();
2474  xAOD::TrigBphysContainer::const_iterator L2BphysItrE = trigL2Bphys->end();
2475 
2476  for (int j=0; L2BphysItr != L2BphysItrE; ++L2BphysItr, ++j ) {
2477 
2478  ATH_MSG_INFO("REGTEST Looking at TrigL2Bphys " << j);
2479 
2480  ATH_MSG_INFO("REGTEST TrigL2Bphys->eta() returns " << (*L2BphysItr)->eta());
2481  ATH_MSG_INFO("REGTEST TrigL2Bphys->phi() returns " << (*L2BphysItr)->phi());
2482  ATH_MSG_INFO("REGTEST TrigL2Bphys->mass() returns " << (*L2BphysItr)->mass());
2483  ATH_MSG_INFO("REGTEST TrigL2Bphys->fitmass() returns " << (*L2BphysItr)->fitmass());
2484  // ATH_MSG_INFO("REGTEST TrigL2Bphys->isValid() returns " << (*L2BphysItr)->isValid());
2485  ATH_MSG_INFO("REGTEST TrigL2Bphys->roiId() returns " << (*L2BphysItr)->roiId());
2486  ATH_MSG_INFO("REGTEST TrigL2Bphys->particleType() returns " << (*L2BphysItr)->particleType());
2487 
2488  if( (*L2BphysItr)->secondaryDecay() != NULL){
2489  const xAOD::TrigBphys * psecond =(*L2BphysItr)->secondaryDecay();
2490  ATH_MSG_INFO("REGTEST Secondary decay info: ");
2491  ATH_MSG_INFO("REGTEST pSecondDecay->eta() returns " << psecond->eta());
2492  ATH_MSG_INFO("REGTEST pSecondDecay->phi() returns " << psecond->phi());
2493  ATH_MSG_INFO("REGTEST pSecondDecay->mass() returns " << psecond->mass());
2494  ATH_MSG_INFO("REGTEST pSecondDecay->fitmass() returns " << psecond->fitmass());
2495  // ATH_MSG_INFO("REGTEST pSecondDecay->isValid() returns " << (*L2BphysItr)->secondaryDecayLink()->isValid());
2496  ATH_MSG_INFO("REGTEST pSecondDecay->roiId() returns " << psecond->roiId());
2497  ATH_MSG_INFO("REGTEST pSecondDecay->particleType() returns " << psecond->particleType());
2498  } // end if secondary exists
2499 
2500  const std::vector<ElementLink<xAOD::TrackParticleContainer> > trackVector = (*L2BphysItr)->trackParticleLinks();
2501  if (trackVector.size() != 0) {
2502  ATH_MSG_INFO(" REGTEST got track vector size: " << trackVector.size());
2503  } else {
2504  ATH_MSG_INFO(" REGTEST no track vector!!! " );
2505  }
2506  std::vector<ElementLink<xAOD::TrackParticleContainer> >::const_iterator trkIt=trackVector.begin();
2507  for (int itrk=0 ; trkIt!= trackVector.end(); ++itrk, ++trkIt) {
2508  if (!(trkIt->isValid())) {
2509  ATH_MSG_WARNING("TrackParticleContainer::Invalid ElementLink to track ");
2510  continue;
2511  }
2512  //const Trk::Perigee* trackPerigee=(*(*trkIt))->measuredPerigee();
2513  const Trk::Perigee* trackPerigee=&((*(*trkIt))->perigeeParameters());
2514 
2515  // msg() << MSG::VERBOSE << "track, iterator, pointer " << itrk << " " << *trkIt << " " << *(*trkIt) << endmsg;
2516  double phi = trackPerigee->parameters()[Trk::phi];
2517  double theta = trackPerigee->parameters()[Trk::theta];
2518  double px = trackPerigee->momentum()[Trk::px];
2519  double py = trackPerigee->momentum()[Trk::py];
2520  double pt = sqrt(px*px + py*py);
2521  double eta = -std::log(tan(theta/2));
2522 
2523  ATH_MSG_INFO("track " << itrk << " pt phi eta " << pt << " " <<
2524  phi << " " << eta);
2525  }
2526  }
2527  }
2528 
2529  ATH_MSG_INFO("REGTEST ==========END of TrigL2BphysContainer DUMP===========");
2530  ATH_MSG_DEBUG("dumpTrigL2BphysContainer() succeeded");
2531 
2532  return StatusCode::SUCCESS;
2533 }

◆ dumpTrigPassBits()

StatusCode TrigEDMChecker::dumpTrigPassBits ( )
private

Definition at line 583 of file TrigEDMChecker.cxx.

583  {
584  const std::string name="HLT_xAOD__TrigPassBitsContainer_passbits";
585  const xAOD::TrigPassBitsContainer *xbitscont=nullptr;
586  StatusCode sc = evtStore()->retrieve(xbitscont,name);
587  if (sc.isFailure() ){
588  ATH_MSG_INFO("Cannot retrieve TrigPassBits");
589  }
590  else {
591  ATH_MSG_INFO("Size of PassBits container : " << xbitscont->size());
592  for(const auto bits:*xbitscont){
593  if(bits==nullptr){
594  ATH_MSG_INFO("TrigPassBits point nullptr ");
595  continue;
596  }
597  ATH_MSG_DEBUG("Analyzing bits for " << bits->containerClid() << " of size " << bits->size() << " with bit size " << bits->passBits().size());
598  }
599  xAOD::TrigPassBitsContainer::const_iterator itr = xbitscont->begin();
600  xAOD::TrigPassBitsContainer::const_iterator itrE = xbitscont->end();
601 
602  for (int j=0; itr != itrE; ++itr, ++j ) {
603  const xAOD::TrigPassBits * bits = (*itr);
604  if(bits==nullptr){
605  ATH_MSG_INFO("TrigPassBits point nullptr ");
606  continue;
607  }
608  ATH_MSG_DEBUG("Analyzing bits for " << bits->containerClid() << " of size " << bits->size() << " with bit size " << bits->passBits().size());
609  }
610  }
611  return StatusCode::SUCCESS;
612 }

◆ dumpTrigSpacePointCounts()

void TrigEDMChecker::dumpTrigSpacePointCounts ( )
private

Definition at line 614 of file TrigEDMChecker.cxx.

615 {
616  ATH_MSG_INFO("MinBias in dumpTrigSpacePointCounts()");
617 
618  std::string METTag="HLT_xAOD__TrigSpacePointCountsContainer_spacepoints";
619 
620  const xAOD::TrigSpacePointCountsContainer* SpacePointCountsCont=0;
621  StatusCode sc = evtStore()->retrieve(SpacePointCountsCont,METTag);
622 
623  if (sc.isFailure())
624  ATH_MSG_INFO("failed to retrieve " << METTag);
625  else {
626  ATH_MSG_INFO("Accessing " << METTag << " with " << SpacePointCountsCont->size() << " elements");
627 
628  std::string s; char buff[128];
629  std::vector<float> getVec;
630  float sum;
631 
632  // Loop over container content
633  for(uint i = 0; i < SpacePointCountsCont->size(); i++) {
634  getVec = SpacePointCountsCont->at(i)->contentsPixelClusEndcapC();
635  sum = 0.;
636  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
637  snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusEndcapC() = %10.2f ", s.c_str(), sum );
639 
640  getVec = SpacePointCountsCont->at(i)->contentsPixelClusBarrel();
641  sum = 0.;
642  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
643  snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusBarrel() = %10.2f ", s.c_str(), sum );
645 
646  getVec = SpacePointCountsCont->at(i)->contentsPixelClusEndcapA();
647  sum = 0.;
648  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
649  snprintf(buff, sizeof(buff), "REGTEST %s SUM of contentsPixelClusEndcapA() = %10.2f ", s.c_str(), sum );
651 
652  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotBins() = %u ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotBins() );
654 
655  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotMin() = %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotMin() );
657 
658  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusTotMax() = %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusTotMax() );
660 
661  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeBins() = %u ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeBins() );
663 
664  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeMin() = %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeMin() );
666 
667  snprintf(buff, sizeof(buff), "REGTEST %s pixelClusSizeMax() = %10.2f ", s.c_str(), SpacePointCountsCont->at(i)->pixelClusSizeMax() );
669 
670  snprintf(buff, sizeof(buff), "REGTEST %s sctSpEndcapC() = %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpEndcapC() );
672 
673  snprintf(buff, sizeof(buff), "REGTEST %s sctSpBarrel() = %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpBarrel() );
675 
676  snprintf(buff, sizeof(buff), "REGTEST %s sctSpEndcapA() = %u ", s.c_str(), SpacePointCountsCont->at(i)->sctSpEndcapA() );
678  }
679  }
680 }

◆ dumpTrigT2MBTSBits()

void TrigEDMChecker::dumpTrigT2MBTSBits ( )
private

Definition at line 682 of file TrigEDMChecker.cxx.

682  {
683  ATH_MSG_INFO("MinBias in dumpTrigT2MBTSBits()");
684 
685  std::string METTag="HLT_xAOD__TrigT2MbtsBitsContainer_T2Mbts";
686 
687  const xAOD::TrigT2MbtsBitsContainer* T2MbtsBitsCont=0;
688  StatusCode sc = evtStore()->retrieve(T2MbtsBitsCont,METTag);
689 
690  if (sc.isFailure())
691  ATH_MSG_INFO("failed to retrieve " << METTag);
692  else {
693  ATH_MSG_INFO("Accessing " << METTag << " with " << T2MbtsBitsCont->size() << " elements");
694 
695  std::string s; char buff[380];
696  std::vector<float> getVec;
697  float sum;
698 
699  // Loop over container content
700  for(uint i = 0; i < T2MbtsBitsCont->size(); i++) {
701  getVec = T2MbtsBitsCont->at(i)->triggerEnergies();
702  sum = 0.;
703  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
704  snprintf(buff, sizeof(buff), "REGTEST %s SUM of triggerEnergies() = %10.2f ", s.c_str(), sum );
706 
707  getVec = T2MbtsBitsCont->at(i)->triggerTimes();
708  sum = 0.;
709  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
710  snprintf(buff, sizeof(buff), "REGTEST %s SUM of triggerTimes() = %10.2f ", s.c_str(), sum );
712  }
713  }
714 }

◆ dumpTrigTrackCounts()

void TrigEDMChecker::dumpTrigTrackCounts ( )
private

Definition at line 750 of file TrigEDMChecker.cxx.

750  {
751  ATH_MSG_INFO("MinBias in dumpTrigTrackCounts()");
752 
753  std::string METTag="HLT_xAOD__TrigTrackCountsContainer_trackcounts";
754 
755  const xAOD::TrigTrackCountsContainer* T2TrackCountsCont=0;
756  StatusCode sc = evtStore()->retrieve(T2TrackCountsCont,METTag);
757 
758  if (sc.isFailure())
759  ATH_MSG_INFO("failed to retrieve " << METTag);
760  else {
761  ATH_MSG_INFO("Accessing " << METTag << " with " << T2TrackCountsCont->size() << " elements");
762 
763  std::string s; char buff[380];
764  std::vector<float> getVec;
765  float sum;
766 
767  // Loop over container content
768  for(uint i = 0; i < T2TrackCountsCont->size(); i++) {
769  getVec = T2TrackCountsCont->at(i)->z0_pt();
770  sum = 0.;
771  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
772  snprintf(buff, sizeof(buff), "REGTEST %s SUM of z0_pt = %10.2f ", s.c_str(), sum );
774 
775  getVec = T2TrackCountsCont->at(i)->eta_phi();
776  sum = 0.;
777  for (uint j = 0; j < getVec.size(); ++j) sum += getVec[j];
778  snprintf(buff, sizeof(buff), "REGTEST %s SUM of eta_phi() = %10.2f ", s.c_str(), sum );
780 
781  snprintf(buff, sizeof(buff), "REGTEST %s z0Bins() = %u ", s.c_str(), T2TrackCountsCont->at(i)->z0Bins() );
783 
784  snprintf(buff, sizeof(buff), "REGTEST %s z0Min() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->z0Min() );
786 
787  snprintf(buff, sizeof(buff), "REGTEST %s z0Max() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->z0Max() );
789 
790  snprintf(buff, sizeof(buff), "REGTEST %s ptBins() = %u ", s.c_str(), T2TrackCountsCont->at(i)->ptBins() );
792 
793  snprintf(buff, sizeof(buff), "REGTEST %s ptMin() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->ptMin() );
795 
796  snprintf(buff, sizeof(buff), "REGTEST %s ptMax() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->ptMax() );
798 
799  snprintf(buff, sizeof(buff), "REGTEST %s etaBins() = %u ", s.c_str(), T2TrackCountsCont->at(i)->etaBins() );
801 
802  snprintf(buff, sizeof(buff), "REGTEST %s etaMin() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->etaMin() );
804 
805  snprintf(buff, sizeof(buff), "REGTEST %s etaMax() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->etaMax() );
807 
808  snprintf(buff, sizeof(buff), "REGTEST %s phiBins() = %u ", s.c_str(), T2TrackCountsCont->at(i)->phiBins() );
810 
811  snprintf(buff, sizeof(buff), "REGTEST %s phiMin() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->phiMin() );
813 
814  snprintf(buff, sizeof(buff), "REGTEST %s phiMax() = %10.2f ", s.c_str(), T2TrackCountsCont->at(i)->phiMax() );
816  }
817  }
818 }

◆ dumpTrigVertexCounts()

void TrigEDMChecker::dumpTrigVertexCounts ( )
private

Definition at line 716 of file TrigEDMChecker.cxx.

716  {
717  ATH_MSG_INFO("MinBias in dumpTrigVertexCounts()");
718 
719  std::string METTag="HLT_xAOD__TrigVertexCountsContainer_vertexcounts";
720 
721  const xAOD::TrigVertexCountsContainer* T2VertexCountsCont=0;
722  StatusCode sc = evtStore()->retrieve(T2VertexCountsCont,METTag);
723 
724  if (sc.isFailure())
725  ATH_MSG_INFO("failed to retrieve " << METTag);
726  else {
727  ATH_MSG_INFO("Accessing " << METTag << " with " << T2VertexCountsCont->size() << " elements");
728 
729  std::string s; char buff[380];
730  std::vector<float> fgetVec;
731  float fsum(0.);
732  std::vector<unsigned int> ugetVec;
733  unsigned int usum(0);
734 
735  // Loop over container content
736  for(uint i = 0; i < T2VertexCountsCont->size(); i++) {
737  ugetVec = T2VertexCountsCont->at(i)->vtxNtrks();
738  for (uint j = 0; j < ugetVec.size(); ++j) usum += ugetVec[j];
739  snprintf(buff, sizeof(buff), "REGTEST %s SUM of vtxNtrks() = %u ", s.c_str(), usum );
741 
742  fgetVec = T2VertexCountsCont->at(i)->vtxTrkPtSqSum();
743  for (uint j = 0; j < fgetVec.size(); ++j) fsum += fgetVec[j];
744  snprintf(buff, sizeof(buff), "REGTEST %s SUM of vtxTrkPtSqSum() = %10.2f ", s.c_str(), fsum );
746  }
747  }
748 }

◆ dumpxAODElectronContainer()

StatusCode TrigEDMChecker::dumpxAODElectronContainer ( )
private

Definition at line 1770 of file TrigEDMChecker.cxx.

1770  {
1771 
1772  ATH_MSG_DEBUG("In dumpxAODElectronContainer");
1773 
1774  ATH_MSG_INFO( "REGTEST ==========START of xAOD::ElectronContainer DUMP===========" );
1775 
1776  const xAOD::ElectronContainer* elCont=0;
1777  StatusCode sc = evtStore()->retrieve(elCont,"HLT_xAOD__ElectronContainer_egamma_Electrons");
1778  if (sc.isFailure()) {
1779  ATH_MSG_INFO("REGTEST No Electron container HLT_xAOD__ElectronContainer_egamma_Electrons");
1780  return StatusCode::SUCCESS;
1781  }
1782  float val_float=-99;
1783  unsigned int isEMbit=0;
1784  bool pid=false;
1785  //DEBUG output for Egamma container
1786  ATH_MSG_INFO(" REGTEST: xAOD Reconstruction variables: ");
1787  // //Cluster and ShowerShape info
1788  //
1789  static const SG::AuxElement::Accessor< float > accLH("LHValue");
1790  static const SG::AuxElement::Accessor< float > accLHCalo("LHCaloValue");
1791  for (const auto eg : *elCont){
1792  //REGTEST printout
1793  if (eg) {
1794  ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
1795  ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
1796  ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
1797  if(eg->selectionisEM(isEMbit,"isEMVLoose"))
1798  ATH_MSG_INFO(" REGTEST: isEMVLoose " << std::hex << isEMbit << std::dec);
1799  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1800  if(eg->selectionisEM(isEMbit,"isEMLoose"))
1801  ATH_MSG_INFO(" REGTEST: isEMLoose " << std::hex << isEMbit << std::dec);
1802  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1803  if(eg->selectionisEM(isEMbit,"isEMMedium"))
1804  ATH_MSG_INFO(" REGTEST: isEMMedium " << std::hex << isEMbit << std::dec);
1805  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1806  if(eg->selectionisEM(isEMbit,"isEMTight"))
1807  ATH_MSG_INFO(" REGTEST: isEMTight " << std::hex << isEMbit << std::dec);
1808  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1809  if(eg->selectionisEM(isEMbit,"isEMLHVLoose"))
1810  ATH_MSG_INFO(" REGTEST: isEMLHVLoose " << std::hex << isEMbit << std::dec);
1811  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1812  if(eg->selectionisEM(isEMbit,"isEMLHLoose"))
1813  ATH_MSG_INFO(" REGTEST: isEMLHLoose " << std::hex << isEMbit << std::dec);
1814  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1815  if(eg->selectionisEM(isEMbit,"isEMLHMedium"))
1816  ATH_MSG_INFO(" REGTEST: isEMLHMedium " << std::hex << isEMbit << std::dec);
1817  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1818  if(eg->selectionisEM(isEMbit,"isEMLHTight"))
1819  ATH_MSG_INFO(" REGTEST: isEMLHTight " << std::hex << isEMbit << std::dec);
1820  else ATH_MSG_WARNING(" REGTEST: Missing Aux info");
1821  if(accLH.isAvailable(*eg))
1822  ATH_MSG_INFO(" REGTEST: LHValue " << accLH(*eg));
1823  else
1824  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1825  if(accLHCalo.isAvailable(*eg))
1826  ATH_MSG_INFO(" REGTEST: LHValue " << accLHCalo(*eg));
1827  else
1828  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1829  if(eg->passSelection(pid,"LHVLoose"))
1830  ATH_MSG_INFO(" REGTEST: LHVLoose " << pid);
1831  else
1832  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1833  if(eg->passSelection(pid,"LHLoose"))
1834  ATH_MSG_INFO(" REGTEST: LHLoose " << pid);
1835  else
1836  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1837  if(eg->passSelection(pid,"LHMedium"))
1838  ATH_MSG_INFO(" REGTEST: LHMedium " << pid);
1839  else
1840  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1841  if(eg->passSelection(pid,"LHTight"))
1842  ATH_MSG_INFO(" REGTEST: LHTight " << pid);
1843  else
1844  ATH_MSG_WARNING(" REGTEST: Missing Aux info ");
1845  } else{
1846  ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
1847  return StatusCode::SUCCESS;
1848  }
1849  ATH_MSG_INFO(" REGTEST: caloCluster variables ");
1850  if (eg->caloCluster()) {
1851  ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
1852  ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
1853  ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
1854  double tmpeta = -999.;
1855  double tmpphi = -999.;
1856  eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
1857  eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi);
1858  ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta);
1859  ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
1860  } else{
1861  ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
1862  }
1863  ATH_MSG_INFO("REGTEST: Check the original (uncalibrated)");
1864  static const SG::AuxElement::Accessor<ElementLink<xAOD::CaloClusterContainer> > orig ("originalCaloCluster");
1865  if (!orig.isAvailable(*eg->caloCluster()) || !orig(*eg->caloCluster()).isValid()){
1866  ATH_MSG_INFO("Problem with original cluster link");
1867  }
1868  else {
1869  const xAOD::CaloCluster *origClus = *orig(*eg->caloCluster());
1870  ATH_MSG_INFO("REGTEST:: Compare new and old clusters");
1871  ATH_MSG_INFO("REGTEST:: Original Cluster e,eta,phi" << origClus->e() << " " << origClus->eta() << " " << origClus->phi());
1872  ATH_MSG_INFO("REGTEST:: MVA Cluster e,eta,phi" << eg->caloCluster()->e() << " " << eg->caloCluster()->eta() << " " << eg->caloCluster()->phi());
1873  }
1874  ATH_MSG_INFO(" REGTEST: trackmatch variables ");
1875  if(eg->trackParticle()){
1876  ATH_MSG_INFO(" REGTEST: pt= " << eg->trackParticle()->pt());
1877  ATH_MSG_INFO(" REGTEST: charge= " << eg->trackParticle()->charge());
1878  ATH_MSG_INFO(" REGTEST: E/p= " << eg->caloCluster()->et() / eg->trackParticle()->pt() );
1879  eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaEta1);
1880  ATH_MSG_INFO(" REGTEST: Delta eta 1st sampling= " << val_float);
1881  eg->trackCaloMatchValue(val_float,xAOD::EgammaParameters::deltaPhi2);
1882  ATH_MSG_INFO(" REGTEST: Delta phi 2nd sampling= " << val_float);
1883  } else{
1884  ATH_MSG_INFO(" REGTEST: no electron eg->trackParticle() pointer");
1885  }
1886 
1887  //msg() << MSG::VERBOSE << " REGTEST: cluster variables " << endmsg;
1888  //clus = eg->caloCluster();
1889  ATH_MSG_INFO(" REGTEST: EMShower variables ");
1890  eg->showerShapeValue(val_float,xAOD::EgammaParameters::ethad);
1891  ATH_MSG_INFO(" REGTEST: ethad = " << val_float);
1892  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e011);
1893  ATH_MSG_INFO(" REGTEST: e011 = " << val_float);
1894  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e132);
1895  ATH_MSG_INFO(" REGTEST: e132 = " << val_float);
1896  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e237);
1897  ATH_MSG_INFO(" REGTEST: e237 = " << val_float);
1898  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e335);
1899  ATH_MSG_INFO(" REGTEST: e335 = " << val_float);
1900  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2ts1);
1901  ATH_MSG_INFO(" REGTEST: e2ts1 = " << val_float);
1902  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2tsts1);
1903  ATH_MSG_INFO(" REGTEST: e2tsts1 = " << val_float);
1904  eg->isolationValue(val_float,xAOD::Iso::ptcone20);
1905  ATH_MSG_INFO(" REGTEST: ptcone20 = " << val_float);
1906  eg->isolationValue(val_float,xAOD::Iso::ptcone30);
1907  ATH_MSG_INFO(" REGTEST: ptcone30 = " << val_float);
1908  eg->isolationValue(val_float,xAOD::Iso::ptcone40);
1909  ATH_MSG_INFO(" REGTEST: ptcone40 = " << val_float);
1910  eg->isolationValue(val_float,xAOD::Iso::etcone20);
1911  ATH_MSG_INFO(" REGTEST: etcone20 = " << val_float);
1912  eg->isolationValue(val_float,xAOD::Iso::etcone30);
1913  ATH_MSG_INFO(" REGTEST: etcone30 = " << val_float);
1914  eg->isolationValue(val_float,xAOD::Iso::etcone40);
1915  ATH_MSG_INFO(" REGTEST: etcone40 = " << val_float);
1916  //DEBUG info for Electrons which by definition have a track match
1917 
1918  }
1919  ATH_MSG_INFO( "REGTEST ==========END of xAOD::ElectronContainer DUMP===========" );
1920 
1921  return StatusCode::SUCCESS;
1922 
1923 }

◆ dumpxAODJetContainer()

StatusCode TrigEDMChecker::dumpxAODJetContainer ( )
private

Definition at line 2539 of file TrigEDMChecker.cxx.

2539  {
2540 
2541  ATH_MSG_DEBUG("in dumpxAODJetContainer()");
2542 
2543  ATH_MSG_INFO("REGTEST ==========START of xAOD::JetContainer DUMP===========");
2544 
2545  std::string containerName[30] = {"HLT_xAOD__JetContainer_a4tcemjesFS",
2546  "HLT_xAOD__JetContainer_a4tcemsubFS",
2547  "HLT_xAOD__JetContainer_a4tcemsubjesFS",
2548  "HLT_xAOD__JetContainer_a4tcemnojcalibFS",
2549  "HLT_xAOD__JetContainer_a4tcemjesPS",
2550  "HLT_xAOD__JetContainer_a4tcemnojcalibPS",
2551  "HLT_xAOD__JetContainer_a4tclcwjesFS",
2552  "HLT_xAOD__JetContainer_a4tclcwsubFS",
2553  "HLT_xAOD__JetContainer_a4tclcwsubjesFS",
2554  "HLT_xAOD__JetContainer_a4tclcwnojcalibFS",
2555  "HLT_xAOD__JetContainer_a4tclcwjesPS",
2556  "HLT_xAOD__JetContainer_a4tclcwnojcalibPS",
2557  "HLT_xAOD__JetContainer_a4TTemnojcalibFS",
2558  "HLT_xAOD__JetContainer_a4TThadnojcalibFS",
2559  "HLT_xAOD__JetContainer_a10tcemjesFS",
2560  "HLT_xAOD__JetContainer_a10tcemsubFS",
2561  "HLT_xAOD__JetContainer_a10tcemsubjesFS",
2562  "HLT_xAOD__JetContainer_a10tcemnojcalibFS",
2563  "HLT_xAOD__JetContainer_a10tcemjesPS",
2564  "HLT_xAOD__JetContainer_a10tcemnojcalibPS",
2565  "HLT_xAOD__JetContainer_a10tclcwjesFS",
2566  "HLT_xAOD__JetContainer_a10tclcwsubFS",
2567  "HLT_xAOD__JetContainer_a10tclcwsubjesFS",
2568  "HLT_xAOD__JetContainer_a10tclcwnojcalibFS",
2569  "HLT_xAOD__JetContainer_a10tclcwjesPS",
2570  "HLT_xAOD__JetContainer_a10tclcwnojcalibPS",
2571  "HLT_xAOD__JetContainer_a10TTemnojcalibFS",
2572  "HLT_xAOD__JetContainer_a10TThadnojcalibFS",
2573  "HLT_xAOD__JetContainer_a10r_tcemsubjesFS",
2574  "HLT_xAOD__JetContainer_TrigHLTJetDSSelectorCollection"};
2575  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,
2576  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};
2577  int containerInputType[30] = {1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2,
2578  1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 2, 2, 1, 1};
2579  int containerSignalState[30] = {0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1,
2580  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0};
2581  bool onefilled = false;
2582 
2583  for (int icont=0; icont<30; ++icont) {
2584  //retrieve jet collection
2585  const xAOD::JetContainer* jetCont = 0;
2586  StatusCode sc = evtStore()->retrieve(jetCont, containerName[icont]) ;
2587 
2588  if (sc.isFailure()) {
2589  ATH_MSG_WARNING("REGTEST Cannot retrieve jet container");
2590  continue;
2591  }
2592 
2593  int jetContsize = jetCont->size();
2594  ATH_MSG_INFO("REGTEST Got jet container " << containerName[icont] << ", size: " << jetContsize);
2595  if (jetContsize != 0) {
2596  onefilled = true;
2597  int i = 0;
2598  for(const auto thisjet : *jetCont) {
2599  ++i;
2600  ATH_MSG_INFO( "REGTEST Looking at jet " << i);
2601  if (thisjet) {
2602  //checks jet variables
2603  ATH_MSG_DEBUG("REGTEST Checking jet variables");
2604  ATH_MSG_INFO( "REGTEST pt: " << thisjet->pt() );
2605  ATH_MSG_INFO( "REGTEST eta: " << thisjet->eta() );
2606  ATH_MSG_INFO( "REGTEST phi: " << thisjet->phi() );
2607  ATH_MSG_INFO( "REGTEST m: " << thisjet->m() );
2608  ATH_MSG_INFO( "REGTEST e: " << thisjet->e() );
2609  ATH_MSG_INFO( "REGTEST rapidity: " << thisjet->rapidity() );
2610  ATH_MSG_INFO( "REGTEST px: " << thisjet->px() );
2611  ATH_MSG_INFO( "REGTEST py: " << thisjet->py() );
2612  ATH_MSG_INFO( "REGTEST pz: " << thisjet->pz() );
2613  ATH_MSG_INFO( "REGTEST type: " << thisjet->type() );
2614  ATH_MSG_INFO( "REGTEST algorithm (kt: 0, cam: 1, antikt: 2, ...): " << thisjet->getAlgorithmType() << "; should be 2");
2615  if(thisjet->getAlgorithmType() != 2) ATH_MSG_WARNING("Jet algorithm different from container");
2616  ATH_MSG_INFO( "REGTEST size parameter: " << thisjet->getSizeParameter() << "; should be " << containerSizeParameter[icont]);
2617  if(thisjet->getSizeParameter() != containerSizeParameter[icont]) ATH_MSG_WARNING("Jet size different from container");
2618  ATH_MSG_INFO( "REGTEST input (LCTopo: 0, EMTopo: 1, TopoTower: 2, ...): " << thisjet->getInputType() << "; should be " << containerInputType[icont]);
2619  if(thisjet->getInputType() != containerInputType[icont]) ATH_MSG_WARNING("Jet input different from container");
2620  ATH_MSG_INFO( "REGTEST constituents signal state (uncalibrated: 0, calibrated: 1): " << thisjet->getConstituentsSignalState() << "; should be " << containerSignalState[icont]);
2621  if(thisjet->getConstituentsSignalState() != containerSignalState[icont]) ATH_MSG_WARNING("Jet constituents' signal state different from container");
2622  ATH_MSG_INFO( "REGTEST number of constituents: " << thisjet->numConstituents() );
2623 
2624 
2625  //checks the constituents
2626  ATH_MSG_DEBUG("REGTEST Checking jet constituents");
2627 
2628  xAOD::JetConstituentVector constitCont = thisjet->getConstituents();
2629  unsigned int constitContsize = constitCont.size();
2630  ATH_MSG_INFO("REGTEST Got constituent vector, size: " << constitContsize << "; should be " << thisjet->numConstituents());
2631  if(constitContsize != thisjet->numConstituents()) ATH_MSG_WARNING("Constituents container size different from number of constituents");
2632 
2633  if (constitContsize != 0) {
2634 // int j = 0;
2635  // for (const auto thisconstit : constitCont) {
2636  // ++j;
2637  // ATH_MSG_INFO( "REGTEST Looking at constituent " << j);
2638  // if(thisconstit){
2639  // ATH_MSG_INFO( "REGTEST constituent pt: " << thisconstit->pt() );
2640  // ATH_MSG_INFO( "REGTEST constituent eta: " << thisconstit->eta() );
2641  // ATH_MSG_INFO( "REGTEST constituent phi: " << thisconstit->phi() );
2642  // ATH_MSG_INFO( "REGTEST constituent m: " << thisconstit->m() );
2643  // ATH_MSG_INFO( "REGTEST constituent e: " << thisconstit->e() );
2644  // ATH_MSG_INFO( "REGTEST constituent type (CaloCluster: 1, Jet: 2, ...): " << thisconstit->type() );
2645  // }
2646  // else{
2647  // ATH_MSG_WARNING("REGTEST Problem with constituent pointer");
2648  // return StatusCode::SUCCESS;
2649  // }
2650  // }
2651  // ATH_MSG_INFO("REGTEST size of constituent vector == number of displayed constituents: "<< (constitContsize == j) );
2652  // if (constitContsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2653  }
2654  // else ATH_MSG_WARNING("REGTEST This jet has 0 constituents!");
2655 
2656  //checks int attributes
2657  ATH_MSG_DEBUG("REGTEST Checking int attributes");
2658  int valueint;
2659  if( thisjet->getAttribute(xAOD::JetAttribute::GhostMuonSegmentCount, valueint)) ATH_MSG_INFO("REGTEST GhostMuonSegmentCount: " << valueint);
2660  if( thisjet->getAttribute(xAOD::JetAttribute::GhostTrackCount, valueint)) ATH_MSG_INFO("REGTEST GhostTrackCount: " << valueint);
2661  if( thisjet->getAttribute(xAOD::JetAttribute::GhostTruthParticleCount, valueint)) ATH_MSG_INFO("REGTEST GhostTruthParticleCount: " << valueint);
2662  if( thisjet->getAttribute(xAOD::JetAttribute::FracSamplingMaxIndex, valueint)) ATH_MSG_INFO( "REGTEST FracSamplingMaxIndex: " << valueint);
2663 
2664 
2665  //checks float attributes
2666  ATH_MSG_DEBUG("REGTEST Checking float attributes");
2667  float value;
2668  if( thisjet->getAttribute(xAOD::JetAttribute::ActiveArea, value)) ATH_MSG_INFO( "REGTEST ActiveArea: " << value );
2669  // Four-vector type if( thisjet->getAttribute(xAOD::JetAttribute::ActiveArea4vec, value)) ATH_MSG_INFO( "REGTEST ActiveArea4vec: " << value );
2670  if( thisjet->getAttribute(xAOD::JetAttribute::AverageLArQF, value)) ATH_MSG_INFO( "REGTEST AverageLArQF: " << value );
2671  if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrCell, value)) ATH_MSG_INFO( "REGTEST BchCorrCell: " << value );
2672  if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrDotx, value)) ATH_MSG_INFO( "REGTEST BchCorrDotx: " << value );
2673  if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrJet, value)) ATH_MSG_INFO( "REGTEST BchCorrJet: " << value );
2674  if( thisjet->getAttribute(xAOD::JetAttribute::BchCorrJetForCell, value)) ATH_MSG_INFO( "REGTEST BchCorrJetForCell: " << value );
2675  if( thisjet->getAttribute(xAOD::JetAttribute::CentroidR, value)) ATH_MSG_INFO( "REGTEST CentroidR: " << value );
2676  if( thisjet->getAttribute(xAOD::JetAttribute::HECQuality, value)) ATH_MSG_INFO( "REGTEST HECQuality: " << value );
2677  if( thisjet->getAttribute(xAOD::JetAttribute::IsoKR20Par, value)) ATH_MSG_INFO( "REGTEST IsoKR20Par: " << value );
2678  if( thisjet->getAttribute(xAOD::JetAttribute::IsoKR20Perp, value)) ATH_MSG_INFO( "REGTEST IsoKR20Perp: " << value );
2679  // ElementLink<DataVector<xAOD::Vertex> > type if( thisjet->getAttribute(xAOD::JetAttribute::HighestJVFVtx, value)) ATH_MSG_INFO( "REGTEST HighestJVFVtx: " << value );
2680  // ??? type if( thisjet->getAttribute(xAOD::JetAttribute::JetLabel, value)) ATH_MSG_INFO( "REGTEST JetLabel: " << value );
2681  if( thisjet->getAttribute(xAOD::JetAttribute::KtDR, value)) ATH_MSG_INFO( "REGTEST KtDR: " << value );
2682  if( thisjet->getAttribute(xAOD::JetAttribute::LArBadHVEnergy, value)) ATH_MSG_INFO( "REGTEST LArBadHVEnergy: " << value );
2683  if( thisjet->getAttribute(xAOD::JetAttribute::LArBadHVRatio, value)) ATH_MSG_INFO( "REGTEST LArBadHVRatio: " << value );
2684  if( thisjet->getAttribute(xAOD::JetAttribute::LArQuality, value)) ATH_MSG_INFO( "REGTEST LArQuality: " << value );
2685  if( thisjet->getAttribute(xAOD::JetAttribute::NegativeE, value)) ATH_MSG_INFO( "REGTEST NegativeE: " << value );
2686  // no tools available yet if( thisjet->getAttribute(xAOD::JetAttribute::NumTowers, value)) ATH_MSG_INFO( "REGTEST NumTowers: " << value );
2687  if( thisjet->getAttribute(xAOD::JetAttribute::SamplingMax, value)) ATH_MSG_INFO( "REGTEST SamplingMax: " << value );
2688  if( thisjet->getAttribute(xAOD::JetAttribute::Timing, value)) ATH_MSG_INFO( "REGTEST Timing: " << value );
2689  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiArea, value)) ATH_MSG_INFO( "REGTEST VoronoiArea: " << value );
2690  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaE, value)) ATH_MSG_INFO( "REGTEST VoronoiAreaE: " << value );
2691  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPx, value)) ATH_MSG_INFO( "REGTEST VoronoiAreaPx: " << value );
2692  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPy, value)) ATH_MSG_INFO( "REGTEST VoronoiAreaPy: " << value );
2693  if( thisjet->getAttribute(xAOD::JetAttribute::VoronoiAreaPz, value)) ATH_MSG_INFO( "REGTEST VoronoiAreaPz: " << value );
2694  if( thisjet->getAttribute(xAOD::JetAttribute::Width, value)) ATH_MSG_INFO( "REGTEST WIDTH: " << value );
2695  if( thisjet->getAttribute(xAOD::JetAttribute::FracSamplingMax, value)) ATH_MSG_INFO( "REGTEST FracSamplingMax: " << value );
2696  if( thisjet->getAttribute(xAOD::JetAttribute::EMFrac, value)) ATH_MSG_INFO( "REGTEST EMFrac: " << value );
2697  if( thisjet->getAttribute(xAOD::JetAttribute::HECFrac, value)) ATH_MSG_INFO( "REGTEST HECFrac: " << value );
2698  if( thisjet->getAttribute(xAOD::JetAttribute::isBadLoose, value)) ATH_MSG_INFO( "REGTEST isBadLoose: " << value );
2699  if( thisjet->getAttribute(xAOD::JetAttribute::isBadMedium, value)) ATH_MSG_INFO( "REGTEST isBadMedium: " << value );
2700  if( thisjet->getAttribute(xAOD::JetAttribute::isBadTight, value)) ATH_MSG_INFO( "REGTEST isBadTight: " << value );
2701  // unknown attribute if( thisjet->getAttribute(xAOD::JetAttribute::isUgly, value)) ATH_MSG_INFO( "REGTEST isUgly: " << value );
2702  if( thisjet->getAttribute(xAOD::JetAttribute::N90Constituents, value)) ATH_MSG_INFO( "REGTEST N90Constituents: " << value );
2703  if( thisjet->getAttribute(xAOD::JetAttribute::N90Cells, value)) ATH_MSG_INFO( "REGTEST N90Cells: " << value );
2704  if( thisjet->getAttribute(xAOD::JetAttribute::OotFracClusters10, value)) ATH_MSG_INFO( "REGTEST OotFracClusters10: " << value );
2705  if( thisjet->getAttribute(xAOD::JetAttribute::OotFracClusters5, value)) ATH_MSG_INFO( "REGTEST OotFracClusters5: " << value );
2706  if( thisjet->getAttribute(xAOD::JetAttribute::OotFracCells5, value)) ATH_MSG_INFO( "REGTEST OotFracCells5: " << value );
2707  if( thisjet->getAttribute(xAOD::JetAttribute::OotFracCells10, value)) ATH_MSG_INFO( "REGTEST OotFracCells10: " << value );
2708  if( thisjet->getAttribute(xAOD::JetAttribute::PtTruth, value)) ATH_MSG_INFO( "REGTEST PtTruth: " << value );
2709  if( thisjet->getAttribute(xAOD::JetAttribute::Tau1, value)) ATH_MSG_INFO( "REGTEST Tau1: " << value );
2710  if( thisjet->getAttribute(xAOD::JetAttribute::Tau2, value)) ATH_MSG_INFO( "REGTEST Tau2: " << value );
2711  if( thisjet->getAttribute(xAOD::JetAttribute::Tau3, value)) ATH_MSG_INFO( "REGTEST Tau3: " << value );
2712  // unknown attribute if( thisjet->getAttribute(xAOD::JetAttribute::Split12, value)) ATH_MSG_INFO( "REGTEST Split12: " << value );
2713  // unknown attribute if( thisjet->getAttribute(xAOD::JetAttribute::Split23, value)) ATH_MSG_INFO( "REGTEST Split23: " << value );
2714  // unknown attribute if( thisjet->getAttribute(xAOD::JetAttribute::Split34, value)) ATH_MSG_INFO( "REGTEST Split34: " << value );
2715  if( thisjet->getAttribute(xAOD::JetAttribute::Dip12, value)) ATH_MSG_INFO( "REGTEST Dip12: " << value );
2716  if( thisjet->getAttribute(xAOD::JetAttribute::Dip13, value)) ATH_MSG_INFO( "REGTEST Dip13: " << value );
2717  if( thisjet->getAttribute(xAOD::JetAttribute::Dip23, value)) ATH_MSG_INFO( "REGTEST Dip23: " << value );
2718  if( thisjet->getAttribute(xAOD::JetAttribute::DipExcl12, value)) ATH_MSG_INFO( "REGTEST DipExcl12: " << value );
2719  if( thisjet->getAttribute(xAOD::JetAttribute::ThrustMin, value)) ATH_MSG_INFO( "REGTEST ThrustMin: " << value );
2720  if( thisjet->getAttribute(xAOD::JetAttribute::ThrustMaj, value)) ATH_MSG_INFO( "REGTEST ThrustMaj: " << value );
2721  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram0, value)) ATH_MSG_INFO( "REGTEST FoxWolfram0: " << value );
2722  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram1, value)) ATH_MSG_INFO( "REGTEST FoxWolfram1: " << value );
2723  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram2, value)) ATH_MSG_INFO( "REGTEST FoxWolfram2: " << value );
2724  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram3, value)) ATH_MSG_INFO( "REGTEST FoxWolfram3: " << value );
2725  if( thisjet->getAttribute(xAOD::JetAttribute::FoxWolfram4, value)) ATH_MSG_INFO( "REGTEST FoxWolfram4: " << value );
2726  if( thisjet->getAttribute(xAOD::JetAttribute::Sphericity, value)) ATH_MSG_INFO( "REGTEST Sphericity: " << value );
2727  if( thisjet->getAttribute(xAOD::JetAttribute::Aplanarity, value)) ATH_MSG_INFO( "REGTEST Aplanarity: " << value );
2728 
2729  //checks vector<int> attributes
2730  ATH_MSG_DEBUG("REGTEST Checking vector<int> attributes");
2731  std::vector<int> vecvalueint;
2732  if (thisjet->getAttribute(xAOD::JetAttribute::NumTrkPt1000, vecvalueint)) {
2733  int vecsize = vecvalueint.size();
2734  ATH_MSG_INFO("REGTEST Got NumTrkPt1000 vector, size: " << vecsize);
2735  if (vecsize != 0) {
2736  int j = 0;
2737  for(const auto & thisvalue : vecvalueint){
2738  ++j;
2739  ATH_MSG_INFO("REGTEST NumTrkPt1000 #" << j << ": " << thisvalue);
2740  }
2741  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2742  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2743  }
2744  }
2745  if (thisjet->getAttribute(xAOD::JetAttribute::NumTrkPt500, vecvalueint)) {
2746  int vecsize = vecvalueint.size();
2747  ATH_MSG_INFO("REGTEST Got Got NumTrkPt500 vector, size: " << vecsize);
2748  if (vecsize != 0) {
2749  int j = 0;
2750  for(const auto & thisvalue : vecvalueint){
2751  ++j;
2752  ATH_MSG_INFO("REGTEST NumTrkPt500 #" << j << ": " << thisvalue);
2753  }
2754  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2755  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2756  }
2757  }
2758 
2759  //checks vector<float> attributes
2760  ATH_MSG_DEBUG("REGTEST Checking vector<float> attributes");
2761  std::vector<float> vecvalue;
2762  if (thisjet->getAttribute(xAOD::JetAttribute::JVF, vecvalue)) {
2763  int vecsize = vecvalue.size();
2764  ATH_MSG_INFO("REGTEST Got JVF vector, size: " << vecsize);
2765  if (vecsize != 0) {
2766  int j = 0;
2767  for(const auto & thisvalue : vecvalue){
2768  ++j;
2769  ATH_MSG_INFO("REGTEST JVF #" << j << ": " << thisvalue);
2770  }
2771  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2772  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2773  }
2774  }
2775  if (thisjet->getAttribute(xAOD::JetAttribute::SumPtTrkPt1000, vecvalue)) {
2776  int vecsize = vecvalue.size();
2777  ATH_MSG_INFO("REGTEST Got SumPtTrkPt1000 vector, size: " << vecsize);
2778  if (vecsize != 0) {
2779  int j = 0;
2780  for(const auto & thisvalue : vecvalue){
2781  ++j;
2782  ATH_MSG_INFO("REGTEST SumPtTrkPt1000 #" << j << ": " << thisvalue);
2783  }
2784  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2785  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2786  }
2787  }
2788  if (thisjet->getAttribute(xAOD::JetAttribute::SumPtTrkPt500, vecvalue)) {
2789  int vecsize = vecvalue.size();
2790  ATH_MSG_INFO("REGTEST Got SumPtTrkPt500 vector, size: " << vecsize);
2791  if (vecsize != 0) {
2792  int j = 0;
2793  for(const auto & thisvalue : vecvalue){
2794  ++j;
2795  ATH_MSG_INFO("REGTEST SumPtTrkPt500 #" << j << ": " << thisvalue);
2796  }
2797  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2798  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2799  }
2800  }
2801  if (thisjet->getAttribute(xAOD::JetAttribute::TrackWidthPt1000, vecvalue)) {
2802  int vecsize = vecvalue.size();
2803  ATH_MSG_INFO("REGTEST Got TrackWidthPt1000 vector, size: " << vecsize);
2804  if (vecsize != 0) {
2805  int j = 0;
2806  for(const auto & thisvalue : vecvalue){
2807  ++j;
2808  ATH_MSG_INFO("REGTEST TrackWidthPt1000 #" << j << ": " << thisvalue);
2809  }
2810  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2811  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2812  }
2813  }
2814  if (thisjet->getAttribute(xAOD::JetAttribute::TrackWidthPt500, vecvalue)) {
2815  int vecsize = vecvalue.size();
2816  ATH_MSG_INFO("REGTEST Got TrackWidthPt500 vector, size: " << vecsize);
2817  if (vecsize != 0) {
2818  int j = 0;
2819  for(const auto & thisvalue : vecvalue){
2820  ++j;
2821  ATH_MSG_INFO("REGTEST TrackWidthPt500 #" << j << ": " << thisvalue);
2822  }
2823  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2824  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2825  }
2826  }
2827  if (thisjet->getAttribute(xAOD::JetAttribute::EnergyPerSampling, vecvalue)) {
2828  int vecsize = vecvalue.size();
2829  ATH_MSG_INFO("REGTEST Got EnergyPerSampling vector, size: " << vecsize);
2830  if (vecsize != 0) {
2831  int j = 0;
2832  for(const auto & thisvalue : vecvalue){
2833  ++j;
2834  ATH_MSG_INFO("REGTEST EnergyPerSampling #" << j << ": " << thisvalue);
2835  }
2836  ATH_MSG_INFO("REGTEST size of attribute vector == number of displayed attributes: " << (vecsize == j) );
2837  if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this attribute");
2838  }
2839  }
2840 
2841 
2842  //checks associated objects
2843  // ATH_MSG_DEBUG("REGTEST Checking associated objects");
2844  // std::vector<const xAOD::TrackParticle*> track;
2845  // if( thisjet->getAssociatedObjects(xAOD::JetAttribute::GhostTrack, track) ){
2846  // int vecsize = track.size();
2847  // ATH_MSG_INFO("REGTEST Got GhostTrack vector, size: " << vecsize);
2848  // if (vecsize != 0) {
2849  // int j = 0;
2850  // for(const auto & thistrack : track){
2851  // ++j;
2852  // //checks only one associated variable, just making sure getting the object worked
2853  // if (thistrack) ATH_MSG_INFO("REGTEST z0 for GhostTrack #" << j << ": " << thistrack->z0());
2854  // else{
2855  // ATH_MSG_WARNING("REGTEST Problem with attribute pointer");
2856  // return StatusCode::SUCCESS;
2857  // }
2858  // }
2859  // ATH_MSG_INFO("REGTEST size of associated object vector == number of displayed attributes: " << (vecsize == j) );
2860  // if (vecsize != j) ATH_MSG_WARNING("REGTEST Problem with displaying this associated object");
2861  // }
2862  // }
2863  }
2864  else{
2865  ATH_MSG_WARNING("REGTEST Problem with jet pointer");
2866  return StatusCode::SUCCESS;
2867  }
2868  }
2869 
2870  if (jetContsize == i) ATH_MSG_INFO("REGTEST size of jet container == number of displayed jets: " << (jetContsize == i) );
2871  else ATH_MSG_WARNING("REGTEST Problem with displaying jets");
2872  }
2873  }
2874 
2875  if (!onefilled) ATH_MSG_DEBUG("There was no filled jet containers");
2876 
2877  ATH_MSG_INFO("REGTEST ==========END of xAOD::JetContainer DUMP===========");
2878 
2879  ATH_MSG_DEBUG("leaving dumpxAODJetContainer()");
2880 
2881  return StatusCode::SUCCESS;
2882 }

◆ dumpxAODMuonContainer()

StatusCode TrigEDMChecker::dumpxAODMuonContainer ( )
private

Definition at line 1346 of file TrigEDMChecker.cxx.

1346  {
1347 
1348  ATH_MSG_DEBUG("In dumpxAODMuonContainer");
1349 
1350  ATH_MSG_INFO( "REGTEST ==========START of xAOD::MuonContainer DUMP===========" );
1351 
1352  const xAOD::MuonContainer* muonCont=0;
1353  StatusCode sc = evtStore()->retrieve(muonCont,"HLT_xAOD__MuonContainer_MuonEFInfo");
1354  if (sc.isFailure()) {
1355  ATH_MSG_INFO("REGTEST No muon container HLT_xAOD__MuonContainer_MuonEFInfo");
1356  return StatusCode::SUCCESS;
1357  }
1358 
1359  std::string output = m_muonPrinter->print( *muonCont );
1360  msg(MSG::INFO) << output << endmsg;
1361 
1362  ATH_MSG_INFO( "REGTEST ==========END of xAOD::MuonContainer DUMP===========" );
1363 
1364  return StatusCode::SUCCESS;
1365 
1366 }

◆ dumpxAODPhotonContainer()

StatusCode TrigEDMChecker::dumpxAODPhotonContainer ( )
private

Definition at line 1926 of file TrigEDMChecker.cxx.

1926  {
1927 
1928  ATH_MSG_DEBUG("In dumpxAODPhotonContainer");
1929 
1930  ATH_MSG_INFO( "REGTEST ==========START of xAOD::PhotonContainer DUMP===========" );
1931 
1932  const xAOD::PhotonContainer* phCont=0;
1933  StatusCode sc = evtStore()->retrieve(phCont,"HLT_xAOD__PhotonContainer_egamma_Photons");
1934  if (sc.isFailure()) {
1935  ATH_MSG_INFO("REGTEST No Photon container HLT_xAOD__PhotonContainer_egamma_Photons");
1936  return StatusCode::SUCCESS;
1937  }
1938 
1939  float val_float=-99;
1940  unsigned int isEMbit=0;
1941  //DEBUG output for xAOD::PhotonContainer
1942  ATH_MSG_INFO(" REGTEST: xAOD Reconstruction variables: ");
1943  // //Cluster and ShowerShape info
1944  for (const auto eg : *phCont){
1945  //REGTEST printout
1946  if (eg) {
1947  ATH_MSG_INFO(" REGTEST: egamma energy: " << eg->e() );
1948  ATH_MSG_INFO(" REGTEST: egamma eta: " << eg->eta() );
1949  ATH_MSG_INFO(" REGTEST: egamma phi: " << eg->phi() );
1950  ATH_MSG_INFO(" REGTEST: isEMLoose " << eg->selectionisEM(isEMbit,"isEMLoose"));
1951  ATH_MSG_INFO(" REGTEST: isEMLoose bit " << std::hex << isEMbit << std::dec);
1952  ATH_MSG_INFO(" REGTEST: isEMMedium " << eg->selectionisEM(isEMbit,"isEMMedium"));
1953  ATH_MSG_INFO(" REGTEST: isEMMedium bit " << std::hex << isEMbit << std::dec);
1954  ATH_MSG_INFO(" REGTEST: isEMTight " << eg->selectionisEM(isEMbit,"isEMTight"));
1955  ATH_MSG_INFO(" REGTEST: isEMTight bit " << std::hex << isEMbit << std::dec);
1956  } else{
1957  ATH_MSG_INFO(" REGTEST: problems with egamma pointer" );
1958  return StatusCode::SUCCESS;
1959  }
1960  ATH_MSG_INFO(" REGTEST: caloCluster variables ");
1961  if (eg->caloCluster()) {
1962  ATH_MSG_INFO(" REGTEST: egamma cluster transverse energy: " << eg->caloCluster()->et() );
1963  ATH_MSG_INFO(" REGTEST: egamma cluster eta: " << eg->caloCluster()->eta() );
1964  ATH_MSG_INFO(" REGTEST: egamma cluster phi: " << eg->caloCluster()->phi() );
1965  double tmpeta = -999.;
1966  double tmpphi = -999.;
1967  eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta);
1968  eg->caloCluster()->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi);
1969  ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. etaCalo = " << tmpeta);
1970  ATH_MSG_INFO(" REGTEST: egamma cluster calo-frame coords. phiCalo = " << tmpphi);
1971  } else{
1972  ATH_MSG_INFO(" REGTEST: problems with egamma cluster pointer" );
1973  }
1974  ATH_MSG_INFO("REGTEST: Check the original (uncalibrated)");
1975  static const SG::AuxElement::Accessor<ElementLink<xAOD::CaloClusterContainer> > orig ("originalCaloCluster");
1976  if (!orig.isAvailable(*eg->caloCluster()) || !orig(*eg->caloCluster()).isValid()){
1977  ATH_MSG_INFO("Problem with original cluster link");
1978  }
1979  else {
1980  const xAOD::CaloCluster *origClus = *orig(*eg->caloCluster());
1981  ATH_MSG_INFO("REGTEST:: Compare new and old clusters");
1982  ATH_MSG_INFO("REGTEST:: Original Cluster e,eta,phi" << origClus->e() << " " << origClus->eta() << " " << origClus->phi());
1983  ATH_MSG_INFO("REGTEST:: MVA Cluster e,eta,phi" << eg->caloCluster()->e() << " " << eg->caloCluster()->eta() << " " << eg->caloCluster()->phi());
1984  }
1985  //msg() << MSG::VERBOSE << " REGTEST: cluster variables " << endmsg;
1986  //clus = eg->caloCluster();
1987  ATH_MSG_INFO(" REGTEST: EMShower variables ");
1988  eg->showerShapeValue(val_float,xAOD::EgammaParameters::ethad);
1989  ATH_MSG_INFO(" REGTEST: ethad = " << val_float);
1990  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e011);
1991  ATH_MSG_INFO(" REGTEST: e011 = " << val_float);
1992  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e132);
1993  ATH_MSG_INFO(" REGTEST: e132 = " << val_float);
1994  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e237);
1995  ATH_MSG_INFO(" REGTEST: e237 = " << val_float);
1996  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e335);
1997  ATH_MSG_INFO(" REGTEST: e335 = " << val_float);
1998  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2ts1);
1999  ATH_MSG_INFO(" REGTEST: e2ts1 = " << val_float);
2000  eg->showerShapeValue(val_float,xAOD::EgammaParameters::e2tsts1);
2001  ATH_MSG_INFO(" REGTEST: e2tsts1 = " << val_float);
2002  eg->isolationValue(val_float,xAOD::Iso::etcone20);
2003  ATH_MSG_INFO(" REGTEST: etcone20 = " << val_float);
2004  eg->isolationValue(val_float,xAOD::Iso::etcone30);
2005  ATH_MSG_INFO(" REGTEST: etcone30 = " << val_float);
2006  eg->isolationValue(val_float,xAOD::Iso::etcone40);
2007  ATH_MSG_INFO(" REGTEST: etcone40 = " << val_float);
2008  //DEBUG info for Electrons which by definition have a track match
2009 
2010  }
2011  ATH_MSG_INFO( "REGTEST ==========END of xAOD::PhotonContainer DUMP===========" );
2012 
2013  return StatusCode::SUCCESS;
2014 
2015 }

◆ dumpxAODTrackParticle()

StatusCode TrigEDMChecker::dumpxAODTrackParticle ( )
private

Definition at line 3867 of file TrigEDMChecker.cxx.

3867  {
3868 
3869  ATH_MSG_DEBUG("In dumpxAODTrackParticle()");
3870 
3871  ATH_MSG_INFO("REGTEST ==========START of xAOD::TrackParticle DUMP===========");
3872 
3873  std::vector<std::string> SGkeys;
3874  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bjet_EFID");
3875  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Bphysics_EFID");
3876  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Electron_EFID");
3877  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_FullScan_EFID");
3878  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Muon_EFID");
3879  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Photon_EFID");
3880  SGkeys.push_back("HLT_xAOD__TrackParticleContainer_InDetTrigTrackingxAODCnv_Tau_EFID");
3881 
3882  StatusCode returnsc = StatusCode::SUCCESS;
3883 
3884  for (unsigned int SGkey = 0; SGkey < SGkeys.size(); ++SGkey) {
3885  const xAOD::TrackParticleContainer* trackParticleContainer=0;
3886  StatusCode sc = evtStore()->retrieve(trackParticleContainer,SGkeys.at(SGkey));
3887  if (sc.isFailure()) {
3888  ATH_MSG_INFO("REGTEST No track particle container found with key " << SGkeys.at(SGkey));
3889  continue;
3890  }
3891  ATH_MSG_INFO("REGTEST TrackParticleContainer retrieved with key " << SGkeys.at(SGkey)
3892  << " and size " << trackParticleContainer->size());
3893 
3894  xAOD::TrackParticleContainer::const_iterator trackParticleItr = trackParticleContainer->begin();
3895  xAOD::TrackParticleContainer::const_iterator trackParticleLast = trackParticleContainer->end();
3896 
3897  for (int index = 0; trackParticleItr != trackParticleLast; ++trackParticleItr, ++index) {
3898  ATH_MSG_INFO("REGTEST Looking at Track Particle " << index);
3899 
3900  ATH_MSG_INFO("REGTEST IParticle functions:");
3901  ATH_MSG_INFO("REGTEST pt: " << (*trackParticleItr)->pt()
3902  << "/eta: " << (*trackParticleItr)->eta()
3903  << "/phi: " << (*trackParticleItr)->phi()
3904  << "/m: " << (*trackParticleItr)->m()
3905  << "/e: " << (*trackParticleItr)->e()
3906  << "/rapidity: " << (*trackParticleItr)->rapidity());
3907 
3908  ATH_MSG_INFO("REGTEST Defining parameters functions:");
3909  ATH_MSG_INFO("REGTEST charge: " << (*trackParticleItr)->charge()
3910  << "/d0: " << (*trackParticleItr)->d0()
3911  << "/z0: " << (*trackParticleItr)->z0()
3912  << "/phi0: " << (*trackParticleItr)->phi0()
3913  << "/theta: " << (*trackParticleItr)->theta()
3914  << "/qOverP: " << (*trackParticleItr)->qOverP()
3915  << "/vx: " << (*trackParticleItr)->vx()
3916  << "/vy: " << (*trackParticleItr)->vy()
3917  << "/vz: " << (*trackParticleItr)->vz());
3918 
3919  // Curvilinear functions skipped
3920 
3921  ATH_MSG_INFO("REGTEST Fit quality functions:");
3922  ATH_MSG_INFO("REGTEST chiSquared: " << (*trackParticleItr)->chiSquared()
3923  << "/numberDoF: " << (*trackParticleItr)->numberDoF());
3924 
3925  // TrackInfo functions skipped
3926 
3927  ATH_MSG_INFO("REGTEST summaryValue variables:");
3928  msg() << MSG::INFO << "REGTEST ";
3930  if ( (*trackParticleItr)->summaryValue(numberOfBLayerHits, xAOD::numberOfBLayerHits) ) {
3931  msg() << "/numberOfBLayerHits: " << static_cast<int>(numberOfBLayerHits);
3932  } else {
3933  msg() << "/numberOfBLayerHits not found";
3934  }
3935 
3937  if ( (*trackParticleItr)->summaryValue(numberOfPixelHits, xAOD::numberOfPixelHits) ) {
3938  msg() << "/numberOfPixelHits: " << static_cast<int>(numberOfPixelHits);
3939  } else {
3940  msg() << "/numberOfPixelHits not found";
3941  }
3942 
3944  if ( (*trackParticleItr)->summaryValue(numberOfPixelHoles, xAOD::numberOfPixelHoles) ) {
3945  msg() << "/numberOfPixelHoles: " << static_cast<int>(numberOfPixelHoles);
3946  } else {
3947  msg() << "/numberOfPixelHoles not found";
3948  }
3949 
3951  if ( (*trackParticleItr)->summaryValue(numberOfSCTHits, xAOD::numberOfSCTHits) ) {
3952  msg() << "/numberOfSCTHits: " << static_cast<int>(numberOfSCTHits);
3953  } else {
3954  msg() << "/numberOfSCTHits not found";
3955  }
3956 
3958  if ( (*trackParticleItr)->summaryValue(numberOfSCTHoles, xAOD::numberOfSCTHoles) ) {
3959  msg() << "/numberOfSCTHoles: " << static_cast<int>(numberOfSCTHoles);
3960  } else {
3961  msg() << "/numberOfSCTHoles not found";
3962  }
3963 
3965  if ( (*trackParticleItr)->summaryValue(numberOfTRTHits, xAOD::numberOfTRTHits) ) {
3966  msg() << "/numberOfTRTHits: " << static_cast<int>(numberOfTRTHits);
3967  } else {
3968  msg() << "/numberOfTRTHits not found";
3969  }
3970 
3972  if ( (*trackParticleItr)->summaryValue(numberOfTRTHoles, xAOD::numberOfTRTHoles) ) {
3973  msg() << "/numberOfTRTHoles: " << static_cast<int>(numberOfTRTHoles);
3974  } else {
3975  msg() << "/numberOfTRTHoles not found";
3976  }
3977  msg() << endmsg;
3978  }
3979  }
3980 
3981  ATH_MSG_INFO("REGTEST ==========END of xAOD::TrackParticle DUMP===========");
3982  ATH_MSG_DEBUG("dumpxAODTrackParticles() succeeded");
3983 
3984  return returnsc;
3985 }

◆ dumpxAODTrigElectronContainer()

StatusCode TrigEDMChecker::dumpxAODTrigElectronContainer ( )
private

Definition at line 1669 of file TrigEDMChecker.cxx.

1669  {
1670 
1671  ATH_MSG_DEBUG("In dumpxAODElectronContainer");
1672 
1673  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigElectronContainer DUMP===========" );
1674 
1675  const xAOD::TrigElectronContainer* elCont=0;
1676  StatusCode sc = evtStore()->retrieve(elCont,"HLT_xAOD__TrigElectronContainer_L2ElectronFex");
1677  if (sc.isFailure()) {
1678  ATH_MSG_INFO("REGTEST No TrigElectron container HLT_xAOD__TrigElectronContainer_L2ElectronFex");
1679  return StatusCode::SUCCESS;
1680  }
1681 
1682  for (const auto eg : *elCont){
1683  ATH_MSG_INFO("REGTEST TrigElectron->Phi() returns " << eg->phi());
1684  ATH_MSG_INFO("REGTEST TrigElectron->Eta() returns " << eg->eta());
1685  ATH_MSG_INFO("REGTEST TrigElectron->rEta returns " << eg->rcore());
1686  ATH_MSG_INFO("REGTEST TrigElectron->eratio() returns " << eg->eratio());
1687  ATH_MSG_INFO("REGTEST TrigElectron->pt() returns " << eg->pt());
1688  ATH_MSG_INFO("REGTEST TrigElectron->etHad() returns " << eg->etHad());
1689  ATH_MSG_INFO("REGTEST TrigElectron->f1() returns " << eg->f1());
1690  ATH_MSG_INFO("REGTEST TrigElectron caloEta = " << eg->caloEta());
1691  ATH_MSG_INFO("REGTEST TrigElectron dPhiCalo" << eg->trkClusDphi());
1692  ATH_MSG_INFO("REGTEST TrigElectron dEtaCalo" << eg->trkClusDeta());
1693  ATH_MSG_INFO("REGTEST TrigElectron pTcalo" << eg->pt());
1694  ATH_MSG_INFO("REGTEST TrigElectron eTOverPt" << eg->etOverPt());
1695  ATH_MSG_INFO("REGTEST TrigElectron nTRTHits" << eg->nTRTHits());
1696  ATH_MSG_INFO("REGTEST TrigElectron nStrawHits" << eg->nTRTHiThresholdHits());
1697  ATH_MSG_INFO("REGTEST TrigElectron Check EMCluster");
1698  if(eg->emCluster()){
1699  ATH_MSG_INFO("REGTEST TrigElectron EMCluster retrieved");
1700  ATH_MSG_INFO("REGTEST TrigElectron emCluster->energy() returns " << eg->emCluster()->energy());
1701  ATH_MSG_INFO("REGTEST TrigElectron emCluster->phi() returns " << eg->emCluster()->phi());
1702  ATH_MSG_INFO("REGTEST TrigElectron emCluster->eta() returns " << eg->emCluster()->eta());
1703  ATH_MSG_INFO("REGTEST TrigElectron emCluster check Element Link");
1704  ATH_MSG_INFO("REGTEST TrigElectron emCluster energy = " << eg->emCluster()->energy());
1705  ATH_MSG_INFO("REGTEST TrigElectron ElementLink emCluster energy = " << (*eg->emClusterLink())->energy());
1706  }
1707  else ATH_MSG_INFO("REGTEST TrigElectron No EMCluster retrieved!");
1708  ATH_MSG_INFO("REGTEST TrigElectron Check TrackParticle");
1709  if(eg->trackParticle()){
1710  ATH_MSG_INFO("REGTEST TrigElectron TrackParticle retrieved");
1711  ATH_MSG_INFO("REGTEST TrigElectron trackParticle->pt() returns " << eg->trackParticle()->pt());
1712  ATH_MSG_INFO("REGTEST TrigElectron trackParticle->phi() returns " << eg->trackParticle()->phi());
1713  ATH_MSG_INFO("REGTEST TrigElectron trackParticle->eta() returns " << eg->trackParticle()->eta());
1714  ATH_MSG_INFO("REGTEST TrigElectron check TrackParticle Element Link");
1715  ATH_MSG_INFO("REGTEST TrigElectron TrackParticle pt = " << eg->trackParticle()->pt());
1716  ATH_MSG_INFO("REGTEST TrigElectron ElementLink TrackParticle pt = " << (*eg->trackParticleLink())->pt());
1717  }
1718  else ATH_MSG_INFO("REGTEST TrigElectron No TrackParticle retrieved!");
1719  }
1720  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigElectronContainer DUMP===========" );
1721 
1722  return StatusCode::SUCCESS;
1723 
1724 }

◆ dumpxAODTrigMinBias()

StatusCode TrigEDMChecker::dumpxAODTrigMinBias ( )
private

Definition at line 820 of file TrigEDMChecker.cxx.

820  {
821 
826 
827  return StatusCode::SUCCESS;
828 }

◆ dumpxAODTrigMissingET()

StatusCode TrigEDMChecker::dumpxAODTrigMissingET ( )
private

Definition at line 834 of file TrigEDMChecker.cxx.

834  {
835 
836  ATH_MSG_INFO("dumpxAODTrigMissingET()");
837 
838  int ntag=4;
839  std::string METTags[]={"HLT_xAOD__TrigMissingETContainer_EFJetEtSum","HLT_xAOD__TrigMissingETContainer_TrigEFMissingET", "HLT_xAOD__TrigMissingETContainer_TrigL2MissingET_FEB","HLT_xAOD__TrigMissingETContainer_TrigEFMissingET_topocl"};
840 
841  for(int itag=0; itag <ntag; itag++) {
842 
843  const xAOD::TrigMissingETContainer* MissingETCont=0;
844  StatusCode sc = evtStore()->retrieve(MissingETCont,METTags[itag]);
845  if (sc.isFailure())
846  ATH_MSG_INFO("failed to retrieve " << METTags[itag]);
847  else {
848  ATH_MSG_INFO("Accessing " << METTags[itag] << " with " << MissingETCont->size() << " elements");
849 
850  // Loop over container content
851  for(uint i = 0; i < MissingETCont->size(); i++) {
852 
853  std::string s; char buff[3000];
854 
855  snprintf(buff, sizeof(buff), "REGTEST %s Ex = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ex() );
857  snprintf(buff, sizeof(buff), "REGTEST %s Ey = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ey() );
859  snprintf(buff, sizeof(buff), "REGTEST %s Ez = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->ez() );
861  snprintf(buff, sizeof(buff), "REGTEST %s SumET = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->sumEt() );
863  snprintf(buff, sizeof(buff), "REGTEST %s SumE = %10.2f CLHEP::MeV", s.c_str(), MissingETCont->at(i)->sumE() );
865  snprintf(buff, sizeof(buff), "REGTEST %s Flag = %d", s.c_str(), MissingETCont->at(i)->flag() );
867  snprintf(buff, sizeof(buff), "REGTEST %s Flag = %d", s.c_str(), MissingETCont->at(i)->roiWord() );
869 
870  unsigned int Nc = MissingETCont->at(i)->getNumberOfComponents();
871  if (Nc > 0) {
872  s="REGTEST __name____status_usedChannels__sumOfSigns__calib1_calib0";
873  s+="/MeV__ex/MeV_____ey/MeV_____ez/MeV___sumE/MeV__sumEt/CLHEP::MeV";
874  ATH_MSG_INFO(s);
875  }
876 
877  for(uint j = 0; j < Nc; j++) {
878 
879  std::string name = MissingETCont->at(i)->nameOfComponent(j);
880  const short status = MissingETCont->at(i)->statusComponent(j);
881  const unsigned short usedChan = MissingETCont->at(i)->usedChannelsComponent(j);
882  const short sumOfSigns = MissingETCont->at(i)->sumOfSignsComponent(j);
883  const float calib0 = MissingETCont->at(i)->calib0Component(j);
884  const float calib1 = MissingETCont->at(i)->calib1Component(j);
885  const float ex = MissingETCont->at(i)->exComponent(j);
886  const float ey = MissingETCont->at(i)->eyComponent(j);
887  const float ez = MissingETCont->at(i)->ezComponent(j);
888  const float sumE = MissingETCont->at(i)->sumEComponent(j);
889  const float sumEt = MissingETCont->at(i)->sumEtComponent(j);
890 
891  snprintf(buff, sizeof(buff),
892  "REGTEST %s %6d %12d %10d %6.2f %6.3f %10.2f %10.2f %10.2f %10.2f %10.2f",
893  name.c_str(), status, usedChan, sumOfSigns, calib1, calib0,
894  ex, ey, ez, sumE, sumEt);
895  ATH_MSG_INFO(buff);
896  }
897  }
898  }
899  }
900 
901  return StatusCode::SUCCESS;
902 }

◆ dumpxAODTrigPhotonContainer()

StatusCode TrigEDMChecker::dumpxAODTrigPhotonContainer ( )
private

Definition at line 1727 of file TrigEDMChecker.cxx.

1727  {
1728 
1729  ATH_MSG_DEBUG("In dumpxAODTrigPhotonContainer");
1730 
1731  ATH_MSG_INFO( "REGTEST ==========START of xAOD::TrigPhotonContainer DUMP===========" );
1732 
1733  const xAOD::TrigPhotonContainer* phCont=0;
1734  StatusCode sc = evtStore()->retrieve(phCont,"HLT_xAOD__TrigPhotonContainer_L2PhotonFex");
1735  if (sc.isFailure()) {
1736  ATH_MSG_INFO("REGTEST No TrigPhoton container HLT_xAOD__TrigPhotonContainer_L2PhotonFex");
1737  return StatusCode::SUCCESS;
1738  }
1739 
1740  for (const auto eg : *phCont){
1741 
1742  ATH_MSG_INFO("REGTEST TrigPhoton->Phi() returns " << eg->phi());
1743  ATH_MSG_INFO("REGTEST TrigPhoton->Eta() returns " << eg->eta());
1744  ATH_MSG_INFO("REGTEST TrigPhoton->dPhi() returns " << eg->dPhi());
1745  ATH_MSG_INFO("REGTEST TrigPhoton->dEta() returns " << eg->dEta());
1746  ATH_MSG_INFO("REGTEST TrigPhoton->rEta returns " << eg->rcore());
1747  ATH_MSG_INFO("REGTEST TrigPhoton->eratio() returns " << eg->eratio());
1748  ATH_MSG_INFO("REGTEST TrigPhoton->pt() returns " << eg->pt());
1749  ATH_MSG_INFO("REGTEST TrigPhoton->etHad() returns " << eg->etHad());
1750  ATH_MSG_INFO("REGTEST TrigPhoton->f1() returns " << eg->f1());
1751  ATH_MSG_INFO("REGTEST TrigPhoton Check EMCluster");
1752  if(eg->emCluster()){
1753  ATH_MSG_INFO("REGTEST TrigPhoton EMCluster retrieved");
1754  ATH_MSG_INFO("REGTEST TrigPhoton emCluster->energy() returns " << eg->emCluster()->energy());
1755  ATH_MSG_INFO("REGTEST TrigPhoton emCluster->phi() returns " << eg->emCluster()->phi());
1756  ATH_MSG_INFO("REGTEST TrigPhoton emCluster->eta() returns " << eg->emCluster()->eta());
1757  ATH_MSG_INFO("REGTEST TrigPhoton emCluster check Element Link");
1758  ATH_MSG_INFO("REGTEST TrigPhoton emCluster energy = " << eg->emCluster()->energy());
1759  ATH_MSG_INFO("REGTEST TrigPhoton ElementLink emCluster energy = " << (*eg->emClusterLink())->energy());
1760  }
1761  else ATH_MSG_INFO("REGTEST TrigPhoton No EMCluster retrieved!");
1762  }
1763  ATH_MSG_INFO( "REGTEST ==========END of xAOD::TrigPhotonContainer DUMP===========" );
1764 
1765  return StatusCode::SUCCESS;
1766 
1767 }

◆ dumpxAODVertex()

StatusCode TrigEDMChecker::dumpxAODVertex ( )
private

Definition at line 3987 of file TrigEDMChecker.cxx.

3987  {
3988 
3989  ATH_MSG_DEBUG("In dumpxAODVertex()");
3990 
3991  ATH_MSG_INFO("REGTEST ==========START of xAOD::Vertex DUMP===========");
3992 
3993  const xAOD::VertexContainer* vertexContainer=0;
3994  StatusCode sc = evtStore()->retrieve(vertexContainer,"HLT_xAOD__VertexContainer_xPrimVx");
3995  if (sc.isFailure()) {
3996  ATH_MSG_INFO("REGTEST No vertex container");
3997  return StatusCode::FAILURE;
3998  }
3999  ATH_MSG_INFO("REGTEST VertexContainer retrieved");
4000 
4001  xAOD::VertexContainer::const_iterator vertexItr = vertexContainer->begin();
4002  xAOD::VertexContainer::const_iterator vertexLast = vertexContainer->end();
4003 
4004  for (int index = 0; vertexItr != vertexLast; ++vertexItr, ++index) {
4005  ATH_MSG_INFO("REGTEST Looking at Vertex " << index);
4006 
4007  ATH_MSG_INFO("REGTEST Public Member Functions:");
4008  ATH_MSG_INFO("REGTEST x: " << (*vertexItr)->x()
4009  << "/y: " << (*vertexItr)->y()
4010  << "/z: " << (*vertexItr)->z());
4011 
4012  ATH_MSG_INFO("REGTEST Public Member Functions:");
4013  ATH_MSG_INFO("REGTEST chiSquared: " << (*vertexItr)->chiSquared()
4014  << "/numberDoF: " << (*vertexItr)->numberDoF());
4015  }
4016 
4017  ATH_MSG_INFO("REGTEST ==========END of xAOD::Vertex DUMP===========");
4018  ATH_MSG_DEBUG("dumpxAODVertex() succeeded");
4019 
4020  return StatusCode::SUCCESS;
4021 }

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

251 {
252  // Build a 32 bit hash out of the name
253  const hash_t effHash = this->hash(effName);
254 
255  // See if this entry exists in the map
256  EffMap_t::const_iterator it = m_effMap.find( effHash );
257  if ( it == m_effMap.end() ) // It doesn't exist!
258  { // Let's see into the THistSvc if somebody else has registered the TEfficiency...
259 
260  // Need to copy the strings as we will massage them from here on
261  std::string effNameCopy = effName;
262  std::string tDirCopy = tDir;
263  std::string streamCopy = stream;
264 
265  // Massage the final string to book things
266  std::string bookingString("");
267  this->buildBookingString( bookingString, effNameCopy, tDirCopy, streamCopy ,false);
268 
269  TEfficiency* effPointer(NULL);
270  if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
271  {
272  // Massage the final string to book things
273  std::string bookingString("");
274  this->buildBookingString( bookingString, effNameCopy, tDirCopy, streamCopy, true );
275 
276  if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
277  {
278  m_msg << MSG::WARNING
279  << "Problem retrieving the TEfficiency with name (including pre- and post-fixes) "
280  << m_histNamePrefix + effNameCopy + m_histNamePostfix
281  << " or with name " << effNameCopy
282  << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
283  << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
284  return NULL;
285  }
286  // If we get to here, we actually found the TEfficiency in the THistSvc.
287  // So let's add it to the local cache map and return its pointer
288  m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
289  return effPointer;
290  }
291  // If we get to here, we actually found the TEfficiency in the THistSvc.
292  // So let's add it to the local cache map and return its pointer
293  m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
294  return effPointer;
295  }
296 
297  // Return the pointer to the TEfficiency that we got from the local cache map
298  return it->second;
299 }

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

122  {
123 
124  // Return gracefully:
125  return StatusCode::SUCCESS;
126 }

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

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

90 { return m_evtStore; }

◆ execute()

StatusCode TrigEDMChecker::execute ( )
overridevirtual

Definition at line 244 of file TrigEDMChecker.cxx.

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

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

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

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

139  {
140 
141  // Return gracefully:
142  return StatusCode::SUCCESS;
143 }

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

493 {
494  // Build a 32 bit hash out of the name
495  const hash_t graphHash = this->hash(graphName);
496 
497  // See if this entry exists in the map
498  GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
499  if ( it == m_graphMap.end() ) // It doesn't exist!
500  { // Let's see into the THistSvc if somebody else has registered the TGraph...
501 
502  // Need to copy the strings as we will massage them from here on
503  std::string graphNameCopy = graphName;
504  std::string tDirCopy = tDir;
505  std::string streamCopy = stream;
506 
507  // Massage the final string to book things
508  std::string bookingString("");
509  this->buildBookingString( bookingString, graphNameCopy, tDirCopy, streamCopy, true);
510 
511  TGraph* graphPointer(NULL);
512  if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
513  {
514  // Massage the final string to book things
515  std::string bookingString("");
516  this->buildBookingString( bookingString, graphNameCopy, tDirCopy, streamCopy, false );
517 
518  if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
519  {
520  m_msg << MSG::WARNING
521  << "Problem retrieving the TGraph with name (including pre- and post-fixes) "
522  << m_histNamePrefix + graphNameCopy + m_histNamePostfix
523  << " or with name " << graphNameCopy
524  << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
525  << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
526  return NULL;
527  }
528  // If we get to here, we actually found the TGraph in the THistSvc.
529  // So let's add it to the local cache map and return its pointer
530  m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
531  return graphPointer;
532  }
533  // If we get to here, we actually found the TGraph in the THistSvc.
534  // So let's add it to the local cache map and return its pointer
535  m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
536  return graphPointer;
537  }
538 
539 
540  // Return the pointer to the TGraph that we got from the local cache map
541  return it->second;
542 }

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

83  {
84 
85  // Tell the user what's happening:
86  ATH_MSG_VERBOSE( "Callback received with incident: " << inc.type() );
87 
88  // Call the appropriate member function:
89  if( inc.type() == IncidentType::BeginInputFile ) {
90  m_currentFile=0;
91  if( beginInputFile().isFailure() ) {
92  ATH_MSG_FATAL( "Failed to call beginInputFile()" );
93  throw std::runtime_error( "Couldn't call beginInputFile()" );
94  }
95  } else if(inc.type() == IncidentType::EndInputFile ) {
96  if( endInputFile().isFailure() ) {
97  ATH_MSG_FATAL( "Failed to call endInputFile()" );
98  throw std::runtime_error( "Couldn't call endInputFile()" );
99  }
100  } else if(inc.type() == "MetaDataStop" ) {
101  if( metaDataStop().isFailure() ) {
102  ATH_MSG_FATAL( "Failed to call metaDataStop()" );
103  throw std::runtime_error( "Couldn't call metaDataStop()" );
104  }
105  } else {
106  ATH_MSG_WARNING( "Unknown incident type received: " << inc.type() );
107  }
108 
109  return;
110 }

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

429 {
431  return (hash_t)(hash64 & 0xFFFFFFFF);
432 }

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

199 {
200  // Build a 32 bit hash out of the name
201  const hash_t histHash = this->hash(histName);
202 
203  // See if this entry exists in the map
204  HistMap_t::const_iterator it = m_histMap.find( histHash );
205  if ( it == m_histMap.end() ) // It doesn't exist!
206  { // Let's see into the THistSvc if somebody else has registered the histogram...
207 
208  // Need to copy the strings as we will massage them from here on
209  std::string histNameCopy = histName;
210  std::string tDirCopy = tDir;
211  std::string streamCopy = stream;
212 
213  // Massage the final string to book things
214  std::string bookingString("");
215  this->buildBookingString( bookingString, histNameCopy, tDirCopy, streamCopy ,false);
216 
217  TH1* histPointer(NULL);
218  if ( !((histSvc()->getHist(bookingString, histPointer)).isSuccess()) )
219  {
220  // Massage the final string to book things
221  std::string bookingString("");
222  this->buildBookingString( bookingString, histNameCopy, tDirCopy, streamCopy, true );
223 
224  if ( !((histSvc()->getHist(bookingString, histPointer)).isSuccess()) )
225  {
226  m_msg << MSG::WARNING
227  << "Problem retrieving the histogram with name (including pre- and post-fixes) "
228  << m_histNamePrefix + histNameCopy + m_histNamePostfix
229  << " or with name " << histNameCopy
230  << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
231  << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
232  return NULL;
233  }
234  // If we get to here, we actually found the histogram in the THistSvc.
235  // So let's add it to the local cache map and return its pointer
236  m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, histPointer ) );
237  return histPointer;
238  }
239  // If we get to here, we actually found the histogram in the THistSvc.
240  // So let's add it to the local cache map and return its pointer
241  m_histMap.insert( m_histMap.end(), std::pair< const hash_t, TH1* >( histHash, histPointer ) );
242  return histPointer;
243  }
244 
245 
246  // Return the pointer to the histogram that we got from the local cache map
247  return it->second;
248 }

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

370 {
371  // Get the TH1 pointer
372  TH1* th1Pointer = this->hist(histName, tDir, stream);
373  if ( !th1Pointer )
374  {
375  m_msg << MSG::ERROR
376  << "Cannot get a 2-d histogram with name " << histName
377  << "... will probably seg-fault!" << endmsg;
378  return NULL;
379  }
380  // If the TH1 pointer is valid, simply return the dynamic_cast
381  return dynamic_cast<TH2*>( th1Pointer );
382 }

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

387 {
388  // Get the TH1 pointer
389  TH1* th1Pointer = this->hist(histName, tDir, stream);
390  if ( !th1Pointer )
391  {
392  m_msg << MSG::ERROR
393  << "Cannot get a 3-d histogram with name " << histName
394  << "... will probably seg-fault!" << endmsg;
395  return NULL;
396  }
397  // If the TH1 pointer is valid, simply return the dynamic_cast
398  return dynamic_cast<TH3*>( th1Pointer );
399 }

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

114 {
115  return m_histSvc;
116 }

◆ initialize()

StatusCode TrigEDMChecker::initialize ( )
overridevirtual

Definition at line 172 of file TrigEDMChecker.cxx.

172  {
173 
174  ATH_CHECK( m_navigationHandleKey.initialize() );
175  ATH_CHECK( m_decisionsKey.initialize() );
176  ATH_CHECK( m_navigationTool.retrieve() );
177 
178  ATH_MSG_DEBUG("Initializing TrigEDMChecker");
179 
180  ATH_MSG_INFO("REGTEST Initializing...");
181  ATH_MSG_INFO("REGTEST m_doDumpAll = " << m_doDumpAll );
182  ATH_MSG_INFO("REGTEST m_doDumpLVL1_ROI = " << m_doDumpLVL1_ROI);
183  ATH_MSG_INFO("REGTEST m_doDumpTrigMissingET = " << m_doDumpTrigMissingET );
184  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigMissingET = " << m_doDumpxAODTrigMissingET );
185  ATH_MSG_INFO("REGTEST m_doDumpMuonFeature = " << m_doDumpMuonFeature );
186  ATH_MSG_INFO("REGTEST m_doDumpCombinedMuonFeature = " << m_doDumpCombinedMuonFeature );
187  ATH_MSG_INFO("REGTEST m_doDumpTileMuFeature = " << m_doDumpTileMuFeature);
188  ATH_MSG_INFO("REGTEST m_doDumpTileTrackMuFeature = " << m_doDumpTileTrackMuFeature);
189  ATH_MSG_INFO("REGTEST m_doDumpTrigPhotonContainer = " << m_doDumpTrigPhotonContainer );
190  ATH_MSG_INFO("REGTEST m_doDumpTrigL2BphysContainer = " << m_doDumpTrigL2BphysContainer );
191  ATH_MSG_INFO("REGTEST m_doDumpTrigEFBphysContainer = " << m_doDumpTrigEFBphysContainer );
192  ATH_MSG_INFO("REGTEST m_doDumpTrigEFBjetContainer = " << m_doDumpTrigEFBjetContainer );
193  ATH_MSG_INFO("REGTEST m_doDumpTrigL2BjetContainer = " << m_doDumpTrigL2BjetContainer );
194  ATH_MSG_INFO("REGTEST m_doDumpxAODJetContainer = " << m_doDumpxAODJetContainer );
195  ATH_MSG_INFO("REGTEST m_doDumpTrigMuonEFContainer = " << m_doDumpTrigMuonEFContainer );
196  ATH_MSG_INFO("REGTEST m_doDumpTrigMuonEFInfoContainer = " << m_doDumpTrigMuonEFInfoContainer );
197  ATH_MSG_INFO("REGTEST m_doDumpxAODMuonContainer = " << m_doDumpxAODMuonContainer );
198  ATH_MSG_INFO("REGTEST m_doDumpTrigElectronContainer = " << m_doDumpTrigElectronContainer );
199  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigElectronContainer= " << m_doDumpxAODTrigElectronContainer );
200  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigPhotonContainer = " << m_doDumpxAODTrigPhotonContainer );
201  ATH_MSG_INFO("REGTEST m_doDumpxAODElectronContainer = " << m_doDumpxAODElectronContainer );
202  ATH_MSG_INFO("REGTEST m_doDumpxAODPhotonContainer = " << m_doDumpxAODPhotonContainer );
203  ATH_MSG_INFO("REGTEST m_doDumpHLTResult = " << m_doDumpHLTResult );
204  ATH_MSG_INFO("REGTEST m_doDumpTrigTauContainer = " << m_doDumpTrigTauContainer );
205  ATH_MSG_INFO("REGTEST m_doDumpTrigTauTracksInfo = " << m_doDumpTrigTauTracksInfo );
206  ATH_MSG_INFO("REGTEST m_doDumpTrigInDetTrackCollection = " << m_doDumpTrigInDetTrackCollection );
207  ATH_MSG_INFO("REGTEST m_doDumpTrigVertexCollection = " << m_doDumpTrigVertexCollection );
208  ATH_MSG_INFO("REGTEST m_doDumpTrigEMCluster = " << m_doDumpTrigEMCluster );
209  ATH_MSG_INFO("REGTEST m_doDumpTrigEMClusterContainer = " << m_doDumpTrigEMClusterContainer );
210  ATH_MSG_INFO("REGTEST m_doDumpTrigTauClusterContainer = " << m_doDumpTrigTauClusterContainer );
211  ATH_MSG_INFO("REGTEST m_doDumpTrackParticleContainer = " << m_doDumpTrackParticleContainer );
212  ATH_MSG_INFO("REGTEST m_doDumpTauJetContainer = " << m_doDumpTauJetContainer );
213  ATH_MSG_INFO("REGTEST m_doDumpxAODTrackParticle = " << m_doDumpxAODTrackParticle );
214  ATH_MSG_INFO("REGTEST m_doDumpxAODVertex = " << m_doDumpxAODVertex );
215  ATH_MSG_INFO("REGTEST m_doDumpxAODTauJetContainer = " << m_doDumpxAODTauJetContainer );
216  ATH_MSG_INFO("REGTEST m_doDumpxAODTrigMinBias = " << m_doDumpxAODTrigMinBias );
217  ATH_MSG_INFO("REGTEST m_doDumpStoreGate = " << m_doDumpStoreGate );
218  ATH_MSG_INFO("REGTEST m_doDumpAllTrigComposite = " << m_doDumpAllTrigComposite );
219  ATH_MSG_INFO("REGTEST m_dumpTrigCompositeContainers = " << m_dumpTrigCompositeContainers );
220  ATH_MSG_INFO("REGTEST m_doDumpTrigCompsiteNavigation = " << m_doDumpTrigCompsiteNavigation );
221  ATH_MSG_INFO("REGTEST m_doTDTCheck = " << m_doTDTCheck );
222 
223  ATH_MSG_INFO("maxRepWarning = " << maxRepWarnings );
224 
226  ATH_CHECK( m_muonPrinter.retrieve() );
227  }
228  else m_muonPrinter.disable(); // to avoid auto-retrieval
229 
231  ATH_CHECK( m_clidSvc.retrieve() );
232  }
233 
235  ATH_CHECK( m_trigDec.retrieve() );
236  ATH_MSG_INFO("TDT Executing with navigation format: " << m_trigDec->getNavigationFormat());
237  }
239 
240  return StatusCode::SUCCESS;
241 }

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

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

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

130  {
131 
132  // Return gracefully:
133  return StatusCode::SUCCESS;
134 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

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

593 {
594  size_t pos = 0;
595  while((pos = str.find(oldStr, pos)) != std::string::npos)
596  {
597  str.replace(pos, oldStr.length(), newStr);
598  pos += newStr.length();
599  }
600 }

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

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

53 { return m_outputMetaStore; }

◆ printMuonTrk() [1/2]

void TrigEDMChecker::printMuonTrk ( const TrigMuonEFCbTrack muonTrack)
private

Definition at line 1567 of file TrigEDMChecker.cxx.

1567  {
1568  ATH_MSG_INFO(" POINTER TrigMuonEFCbTrack: " << muonTrack);
1569  //if(muonTrack) mLog << MSG::INFO << "REGTEST TrigMuonEFCbTrack: " << *muonTrack << endmsg;
1570 
1571 // printMuonTrk(mLog,(TrigMuonEFTrack*)muonTrack);
1572 // mLog <<MSG::INFO << "REGTEST TrigMuonEFCbTrack " << muonTrack << endmsg;
1573 // mLog <<MSG::INFO << "REGTEST NIdPixelHits() returns " << muonTrack->NIdPixelHits() << endmsg;
1574 // mLog <<MSG::INFO << "REGTEST NIdSctHits() returns " << muonTrack->NIdSctHits() << endmsg;
1575 // mLog <<MSG::INFO << "REGTEST NTrtHits() returns " << muonTrack->NTrtHits() << endmsg;
1576 // mLog <<MSG::INFO << "REGTEST matchChi2() returns " << muonTrack->matchChi2() << endmsg;
1577 }

◆ printMuonTrk() [2/2]

void TrigEDMChecker::printMuonTrk ( const TrigMuonEFTrack muonTrack)
private

Definition at line 1541 of file TrigEDMChecker.cxx.

1541  {
1542  ATH_MSG_INFO("POINTER TrigMuonEFTrack: " << muonTrack);
1543  //if(muonTrack) mLog << MSG::INFO << "REGTEST TrigMuonEFTrack: " << *muonTrack << endmsg;
1544 
1545 // mLog <<MSG::INFO << "REGTEST TrigMuonEFTrack->charge() returns " << muonTrack->Charge() << endmsg;
1546 // mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->iPt() returns " << muonTrack->iPt() << endmsg;
1547 // mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->CotTh() returns " << muonTrack->cotTh() << endmsg;
1548 // mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->Phi() returns " << muonTrack->phi() << endmsg;
1549 // mLog <<MSG::INFO << "REGTEST P4IPtCotThPhiM->m() returns " << muonTrack->m() << endmsg;
1550 // mLog <<MSG::INFO << "REGTEST chi2() returns " << muonTrack->chi2() << endmsg;
1551 // mLog <<MSG::INFO << "REGTEST chi2prob() returns " << muonTrack->chi2prob() << endmsg;
1552 // mLog <<MSG::INFO << "REGTEST posX() returns " << muonTrack->posX() << endmsg;
1553 // mLog <<MSG::INFO << "REGTEST posY() returns " << muonTrack->posY() << endmsg;
1554 // mLog <<MSG::INFO << "REGTEST posZ() returns " << muonTrack->posZ() << endmsg;
1555 // mLog <<MSG::INFO << "REGTEST NCscHitsEta() returns " << muonTrack->NCscHitsEta() << endmsg;
1556 // mLog <<MSG::INFO << "REGTEST NCscHitsPhi() returns " << muonTrack->NCscHitsPhi() << endmsg;
1557 // mLog <<MSG::INFO << "REGTEST NTgcHitsEta() returns " << muonTrack->NTgcHitsEta() << endmsg;
1558 // mLog <<MSG::INFO << "REGTEST NTgcHitsPhi() returns " << muonTrack->NTgcHitsPhi() << endmsg;
1559 // mLog <<MSG::INFO << "REGTEST NMdtHitsEta() returns " << muonTrack->NMdtHitsEta() << endmsg;
1560 // mLog <<MSG::INFO << "REGTEST NMdtHitsPhi() returns " << muonTrack->NMdtHitsPhi() << endmsg;
1561 // mLog <<MSG::INFO << "REGTEST NRpcHitsEta() returns " << muonTrack->NRpcHitsEta() << endmsg;
1562 // mLog <<MSG::INFO << "REGTEST NRpcHitsPhi() returns " << muonTrack->NRpcHitsPhi() << endmsg;
1563 // mLog <<MSG::INFO << "REGTEST d0() returns " << muonTrack->d0() << endmsg;
1564 // mLog <<MSG::INFO << "REGTEST z0() returns " << muonTrack->z0() << endmsg;
1565 }

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

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

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

364  {
365  handlesArray.renounce();
366  }

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

65  {
66  try {
68  } catch(std::exception& e) {
69  ATH_MSG_WARNING(e.what());
70  return StatusCode::FAILURE;
71  }
72  }

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

76  {
77  try {
79  } catch(std::exception& e) {
80  ATH_MSG_WARNING(e.what());
81  return StatusCode::FAILURE;
82  }
83  }

◆ sysExecute()

StatusCode AthAnalysisAlgorithm::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

override to do firstEvent method

Definition at line 72 of file AthAnalysisAlgorithm.cxx.

72  {
73  if(!m_doneFirstEvent) {
74  m_doneFirstEvent=true;
75  if( firstExecute().isFailure() ) {
76  ATH_MSG_FATAL("Failure in firstEvent method");
77  return StatusCode::FAILURE;
78  }
79  }
80  return AthHistogramAlgorithm::sysExecute(ctx);
81 }

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

50  {
51 
52  // Connect to the IncidentSvc:
53  ServiceHandle< IIncidentSvc > incSvc( "IncidentSvc", name() );
54  ATH_CHECK( incSvc.retrieve() );
55 
56  // Set up the right callbacks: //but ensure we don't double-register if sysInitialize called twice (appears to be the case)
57  incSvc->removeListener( this, IncidentType::BeginInputFile );
58  incSvc->addListener( this, IncidentType::BeginInputFile, 0, true );
59  incSvc->removeListener( this, IncidentType::EndInputFile );
60  incSvc->addListener( this, IncidentType::EndInputFile, 0, true );
61  incSvc->removeListener( this, "MetaDataStop" );
62  incSvc->addListener( this, "MetaDataStop", 0, true );
63 
64 
65  // Let the base class do its thing:
67 
68  // Return gracefully:
69  return StatusCode::SUCCESS;
70 }

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

379 {
380  // Build a 32 bit hash out of the name
381  const hash_t treeHash = this->hash(treeName);
382 
383  // See if this entry exists in the map
384  TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
385  if ( it == m_treeMap.end() ) // It doesn't exist!
386  { // Let's see into the THistSvc if somebody else has registered the TTree...
387 
388  // Need to copy the strings as we will massage them from here on
389  std::string treeNameCopy = treeName;
390  std::string tDirCopy = tDir;
391  std::string streamCopy = stream;
392 
393  // Massage the final string to book things
394  std::string bookingString("");
395  this->buildBookingString( bookingString, treeNameCopy, tDirCopy, streamCopy );
396 
397  TTree* treePointer(NULL);
398  if ( !((histSvc()->getTree(bookingString, treePointer)).isSuccess()) )
399  {
400  m_msg << MSG::WARNING
401  << "Problem retrieving the TTree with name " << treeNameCopy
402  << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
403  << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
404  return NULL;
405  }
406  // If we get to here, we actually found the TTree in the THistSvc.
407  // So let's add it to the local cache map and return its pointer
408  m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treePointer ) );
409  return treePointer;
410  }
411 
412  // Return the pointer to the TTree that we got from the local cache map
413  return it->second;
414 }

◆ TrigCompositeNavigationToDot()

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

Construct graph of HLT navigation in Run-3.

Parameters
returnValueString to populate with dot graph.
passWhen 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 4220 of file TrigEDMChecker.cxx.

4220  {
4221 
4222  using namespace TrigCompositeUtils;
4223 
4224  // This constexpr is evaluated at compile time
4225  const CLID TrigCompositeCLID = static_cast<CLID>( ClassID_traits< xAOD::TrigCompositeContainer >::ID() );
4226  std::vector<std::string> keys;
4227  if ( m_dumpTrigCompositeContainers.size() == 0 ) {
4228  evtStore()->keys(TrigCompositeCLID, keys);
4229  }
4230  else {
4232  }
4233  std::string typeNameTC;
4234  ATH_CHECK(m_clidSvc->getTypeNameOfID(TrigCompositeCLID, typeNameTC));
4235  ATH_MSG_DEBUG("Got " << keys.size() << " keys for " << typeNameTC);
4236 
4238  DecisionIDContainer chainIDs;
4239  chainIDs.insert( chainID.numeric() );
4240 
4241  std::set<int> converted;
4242 
4243  const Trig::ChainGroup* cg = m_trigDec->getChainGroup(m_dumpNavForChain);
4244  pass = cg->isPassed(TrigDefs::requireDecision);
4245  std::vector<std::string> chains = cg->getListOfTriggers();
4246  for (const std::string& chain : chains) {
4247  const TrigConf::HLTChain* hltChain = m_trigDec->ExperimentalAndExpertMethods().getChainConfigurationDetails(chain);
4248  const HLT::Identifier chainID_tmp( hltChain->chain_name() );
4249  chainIDs.insert( chainID_tmp.numeric() );
4250  const std::vector<size_t> legMultiplicites = hltChain->leg_multiplicities();
4251  if (legMultiplicites.size() == 0) {
4252  ATH_MSG_ERROR("chain " << chainID_tmp << " has invalid configuration, no multiplicity data.");
4253  } else if (legMultiplicites.size() > 1) {
4254  // For multi-leg chains, the DecisionIDs are handled per leg.
4255  // We don't care here exactly how many objects are required per leg, just that there are two-or-more legs
4256  for (size_t legNumeral = 0; legNumeral < legMultiplicites.size(); ++legNumeral) {
4257  const HLT::Identifier legID = TrigCompositeUtils::createLegName(chainID_tmp, legNumeral);
4258  chainIDs.insert( legID.numeric() );
4259  }
4260  }
4261  }
4262 
4263  // First retrieve them all (this should not be needed in future)
4264  const DecisionContainer* container = nullptr;
4265  for (const std::string& key : keys) ATH_CHECK( evtStore()->retrieve( container, key ) );
4266 
4267  std::stringstream ss;
4268  ss << "digraph {" << std::endl;
4269  ss << " node [shape=rectangle]" << std::endl;
4270  ss << " rankdir = BT" << std::endl;
4271 
4272  // Now process them
4273  for (const std::string& key : keys) {
4274  if ( not m_doDumpAllTrigComposite ) {
4275  if ( not CxxUtils::starts_with (key, "HLTNav_") ) { // Nav containers should always start with HLTNav_
4276  continue;
4277  }
4278  }
4279  ATH_CHECK( evtStore()->retrieve( container, key ) );
4280  ATH_MSG_DEBUG("Processing collection " << key << " to be added to the navigation graph");
4281  // ss << " rank=same" << std::endl; // dot cannot handle this is seems
4282  bool writtenHeader = false;
4283  for (const Decision* tc : *container ) {
4284  // Output my ID in the graph.
4285  const DecisionContainer* container = dynamic_cast<const DecisionContainer*>( tc->container() );
4286  const ElementLink<DecisionContainer> selfEL = ElementLink<DecisionContainer>(*container, tc->index());
4287  std::vector<ElementLink<DecisionContainer>> seedELs = tc->objectCollectionLinks<DecisionContainer>("seed");
4288  const bool isHypoAlgNode = tc->name() == "H";
4289  const bool isComboHypoAlgNode = tc->name() == "CH";
4290  const std::vector<DecisionID>& decisions = tc->decisions();
4291  const uint32_t selfKey = selfEL.key();
4292  const uint32_t selfIndex = selfEL.index();
4293  if (m_dumpNavForChain != "") {
4294  bool doDump = false;
4295  // Check me
4296  for (DecisionID id : decisions) {
4297  if (chainIDs.count(id) == 1) {
4298  doDump = true;
4299  break;
4300  }
4301  }
4302  // Check my seeds
4303  if (!doDump and (isHypoAlgNode or isComboHypoAlgNode) and not m_excludeFailedHypoNodes) {
4304  for (const ElementLink<DecisionContainer>& s : seedELs) {
4305  const std::vector<DecisionID>& seedDecisions = (*s)->decisions();
4306  for (DecisionID id : seedDecisions) {
4307  if (chainIDs.count(id) == 1) {
4308  doDump = true;
4309  break;
4310  }
4311  }
4312  }
4313  }
4314  if (!doDump) {
4315  continue;
4316  }
4317  }
4318  if (!writtenHeader) {
4319  writtenHeader = true;
4320  ss << " subgraph " << key << " {" << std::endl;
4321  ss << " label=\"" << key << "\"" << std::endl;
4322  }
4323  const std::string scheme = "rdpu9";
4324  std::string color = "1";
4325  if (tc->name() == "L1") { color = "1"; }
4326  else if (tc->name() == "F") { color = "2"; }
4327  else if (tc->name() == "IM") { color = "3"; }
4328  else if (tc->name() == "H") { color = "4"; }
4329  else if (tc->name() == "CH") { color = "5"; }
4330  else if (tc->name() == "SF") { color = "6"; }
4331  else if (tc->name() == "HLTPassRaw") { color = "7"; }
4332  ss << " \"" << selfKey << "_" << selfIndex << "\" [colorscheme="<<scheme<<",style=filled,fillcolor="<<color<<",label=<<B>Container</B>=" << typeNameTC;
4333  if (tc->name() != "") ss << " <B>Name</B>=" << tc->name();
4334  ss << "<BR/><B>Key</B>=" << key << "<BR/><B>Index</B>=" << selfIndex;
4335  const bool isRemapped = tc->isRemapped();
4336  if (isHypoAlgNode) ss << " <B>linksRemapped</B>=" << (isRemapped ? "Y" : "N");
4337  if (decisions.size() > 0) {
4338  ss << "<BR/><B>Pass</B>=";
4339  size_t c = 0;
4340  for (unsigned decisionID : decisions) {
4341  HLT::Identifier dID(decisionID);
4342  std::string highlight = (dID.numeric() == chainID.numeric() ? "<B>[CHAIN:" : "");
4343  if (highlight == "" and chainIDs.count(dID.numeric()) == 1 and TrigCompositeUtils::isLegId(dID)) {
4344  highlight = "<B>[LEG" + std::to_string(TrigCompositeUtils::getIndexFromLeg(dID)) + ":";
4345  }
4346  ss << std::hex << highlight << decisionID << (!highlight.empty() ? "]</B>" : "") << std::dec << ",";
4347  if (c++ == 5) {
4348  ss << "<BR/>";
4349  c = 0;
4350  }
4351  }
4352  }
4353  ss << ">]" << std::endl;
4354  // Output all the things I link to
4355  size_t seedCount = 0;
4356  for (size_t i = 0; i < tc->linkColNames().size(); ++i) {
4357  const std::string link = tc->linkColNames().at(i);
4358  if (link == "seed" || link == "seed__COLL") {
4359  ElementLink<DecisionContainer> seedEL = seedELs.at(seedCount++);
4360  const uint32_t seedKey = tc->linkColKeys().at(i);
4361  const uint32_t seedIndex = tc->linkColIndices().at(i);
4362  ATH_CHECK( seedKey == seedEL.key() );
4363  ATH_CHECK( seedIndex == seedEL.index() );
4364  if (m_dumpNavForChain != "") { // Only print "seed" link to nodes we include in our search
4365  const std::vector<DecisionID> seedDecisions = (*seedEL)->decisions();
4366  bool doSeedLink = false;
4367  for (DecisionID id : seedDecisions) {
4368  if (chainIDs.count(id) == 1) {
4369  doSeedLink = true;
4370  break;
4371  }
4372  }
4373  if (!doSeedLink) {
4374  continue;
4375  }
4376  }
4377  ss << " \"" << selfKey << "_" << selfIndex << "\" -> \"" << seedKey << "_" << seedIndex << "\" [colorscheme="<<scheme<<",color=9,fontcolor=8,label=\"seed\"]" << std::endl;
4378  } else {
4379  // Start with my class ID
4380  std::string linkColour = "12";
4381  std::string linkBackground = "11";
4382  const std::string extScheme = "paired12";
4383  if (link == "roi") { linkColour="2"; linkBackground="1"; }
4384  else if (link == "initialRoI") { linkColour="2"; linkBackground="1"; }
4385  else if (link == "initialRecRoI") { linkColour="8"; linkBackground="7"; }
4386  else if (link == "feature") { linkColour="4"; linkBackground="3"; }
4387  else if (link == "view") { linkColour="10"; linkBackground="9"; }
4388  const CLID linkCLID = static_cast<CLID>( tc->linkColClids().at(i) );
4389  // Use it to get my class name
4390  std::string tname;
4391  ATH_CHECK(m_clidSvc->getTypeNameOfID(linkCLID, tname));
4392  // Now get the sgkey I'm linking to & the index
4393  const SG::sgkey_t key = (isRemapped ? static_cast<SG::sgkey_t>( tc->linkColKeysRemap().at(i) ) : static_cast<SG::sgkey_t>( tc->linkColKeys().at(i) ));
4394  const unsigned index = (isRemapped ? tc->linkColIndicesRemap().at(i) : tc->linkColIndices().at(i));
4395  // Look it up
4396  CLID checkCLID;
4397  const std::string* keyStr = evtStore()->keyToString(key, checkCLID); // I don't own this str
4398  if (keyStr != nullptr && checkCLID != linkCLID) {
4399  std::string tnameOfCheck;
4400  m_clidSvc->getTypeNameOfID(checkCLID, tnameOfCheck).ignore(); // Might be invalid. But we don't care.
4401  ATH_MSG_ERROR("Inconsistent CLID " << checkCLID << " [" << tnameOfCheck << "] stored in storegate for key " << key
4402  << ". We were expecting " << linkCLID << " [" << tname << "]");
4403  }
4404 
4405  std::string tnameEscape;
4406  for (std::string::const_iterator i = tname.begin(); i != tname.end(); ++i) {
4407  unsigned char c = *i;
4408  if (c == '<') {
4409  tnameEscape += "&lt;";
4410  } else if (c == '>') {
4411  tnameEscape += "&gt;";
4412  } else {
4413  tnameEscape += c;
4414  }
4415  }
4416 
4417  // Print
4418  ss << " \"" << selfKey << "_" << selfIndex << "\" -> \"" << key << "_" << index << "\" ";
4419  ss << "[colorscheme="<<extScheme<<",color="<<linkColour<<",fontcolor="<<linkColour<<",arrowhead=empty,label=\"" << link << "\"]" << std::endl;
4420 
4421  // Check if we are linking to self (e.g. a dummy-feature), don't output a new box for this
4422  const bool linkToSelf = (selfKey == key and selfIndex == index);
4423 
4424  if (converted.count(key + index) == 0 and not linkToSelf) {
4425  ss << " \"" << key << "_" << index << "\" [colorscheme="<<extScheme<<",style=filled,fillcolor="<<linkBackground<<",label=<<B>Container</B>=" << tnameEscape << "<BR/><B>Key</B>=";
4426  if (keyStr != nullptr) ss << *keyStr;
4427  else ss << "[<I>KEY "<< key <<" NOT IN STORE</I>] ";
4428  ss << "<BR/><B>Index</B>=" << index << ">]";
4429  }
4430 
4431  converted.insert(key + index);
4432  }
4433  }
4434  }
4435  if (writtenHeader) {
4436  ss << " }" << std::endl;
4437  }
4438  }
4439 
4440  ss << "}" << std::endl;
4441 
4442  returnValue.assign( ss.str() );
4443  return StatusCode::SUCCESS;
4444 }

◆ updateEvtStore()

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

Definition at line 45 of file AthAnalysisAlgorithm.cxx.

45  {
46  evtStore().release().ignore();
47  evtStore().setTypeAndName(prop.toString());
48 }

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_clidSvc

ServiceHandle< ::IClassIDSvc > TrigEDMChecker::m_clidSvc
private

Definition at line 218 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 222 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 50 of file TrigEDMChecker.h.

◆ m_doDumpAllTrigComposite

bool TrigEDMChecker::m_doDumpAllTrigComposite
private

Definition at line 182 of file TrigEDMChecker.h.

◆ m_doDumpCombinedMuonFeature

bool TrigEDMChecker::m_doDumpCombinedMuonFeature
private

Definition at line 97 of file TrigEDMChecker.h.

◆ m_doDumpHLTResult

bool TrigEDMChecker::m_doDumpHLTResult
private

Definition at line 148 of file TrigEDMChecker.h.

◆ m_doDumpLVL1_ROI

bool TrigEDMChecker::m_doDumpLVL1_ROI
private

Definition at line 54 of file TrigEDMChecker.h.

◆ m_doDumpMuonFeature

bool TrigEDMChecker::m_doDumpMuonFeature
private

Definition at line 101 of file TrigEDMChecker.h.

◆ m_doDumpNavigation

bool TrigEDMChecker::m_doDumpNavigation
private

Definition at line 185 of file TrigEDMChecker.h.

◆ m_doDumpStoreGate

bool TrigEDMChecker::m_doDumpStoreGate
private

Definition at line 169 of file TrigEDMChecker.h.

◆ m_doDumpTauJetContainer

bool TrigEDMChecker::m_doDumpTauJetContainer
private

Definition at line 160 of file TrigEDMChecker.h.

◆ m_doDumpTileMuFeature

bool TrigEDMChecker::m_doDumpTileMuFeature
private

Definition at line 104 of file TrigEDMChecker.h.

◆ m_doDumpTileTrackMuFeature

bool TrigEDMChecker::m_doDumpTileTrackMuFeature
private

Definition at line 107 of file TrigEDMChecker.h.

◆ m_doDumpTrackParticleContainer

bool TrigEDMChecker::m_doDumpTrackParticleContainer
private

Definition at line 57 of file TrigEDMChecker.h.

◆ m_doDumpTrigCompsiteNavigation

bool TrigEDMChecker::m_doDumpTrigCompsiteNavigation
private

Definition at line 205 of file TrigEDMChecker.h.

◆ m_doDumpTrigEFBjetContainer

bool TrigEDMChecker::m_doDumpTrigEFBjetContainer
private

Definition at line 75 of file TrigEDMChecker.h.

◆ m_doDumpTrigEFBphysContainer

bool TrigEDMChecker::m_doDumpTrigEFBphysContainer
private

Definition at line 72 of file TrigEDMChecker.h.

◆ m_doDumpTrigElectronContainer

bool TrigEDMChecker::m_doDumpTrigElectronContainer
private

Definition at line 127 of file TrigEDMChecker.h.

◆ m_doDumpTrigEMCluster

bool TrigEDMChecker::m_doDumpTrigEMCluster
private

Definition at line 84 of file TrigEDMChecker.h.

◆ m_doDumpTrigEMClusterContainer

bool TrigEDMChecker::m_doDumpTrigEMClusterContainer
private

Definition at line 87 of file TrigEDMChecker.h.

◆ m_doDumpTrigInDetTrackCollection

bool TrigEDMChecker::m_doDumpTrigInDetTrackCollection
private

Definition at line 151 of file TrigEDMChecker.h.

◆ m_doDumpTrigL2BjetContainer

bool TrigEDMChecker::m_doDumpTrigL2BjetContainer
private

Definition at line 78 of file TrigEDMChecker.h.

◆ m_doDumpTrigL2BphysContainer

bool TrigEDMChecker::m_doDumpTrigL2BphysContainer
private

Definition at line 69 of file TrigEDMChecker.h.

◆ m_doDumpTrigMissingET

bool TrigEDMChecker::m_doDumpTrigMissingET
private

Definition at line 60 of file TrigEDMChecker.h.

◆ m_doDumpTrigMuonEFContainer

bool TrigEDMChecker::m_doDumpTrigMuonEFContainer
private

Definition at line 113 of file TrigEDMChecker.h.

◆ m_doDumpTrigMuonEFInfoContainer

bool TrigEDMChecker::m_doDumpTrigMuonEFInfoContainer
private

Definition at line 116 of file TrigEDMChecker.h.

◆ m_doDumpTrigMuonEFIsolationContainer

bool TrigEDMChecker::m_doDumpTrigMuonEFIsolationContainer
private

Definition at line 124 of file TrigEDMChecker.h.

◆ m_doDumpTrigPassBits

bool TrigEDMChecker::m_doDumpTrigPassBits
private

Definition at line 52 of file TrigEDMChecker.h.

◆ m_doDumpTrigPhotonContainer

bool TrigEDMChecker::m_doDumpTrigPhotonContainer
private

Definition at line 110 of file TrigEDMChecker.h.

◆ m_doDumpTrigTauClusterContainer

bool TrigEDMChecker::m_doDumpTrigTauClusterContainer
private

Definition at line 81 of file TrigEDMChecker.h.

◆ m_doDumpTrigTauContainer

bool TrigEDMChecker::m_doDumpTrigTauContainer
private

Definition at line 142 of file TrigEDMChecker.h.

◆ m_doDumpTrigTauTracksInfo

bool TrigEDMChecker::m_doDumpTrigTauTracksInfo
private

Definition at line 145 of file TrigEDMChecker.h.

◆ m_doDumpTrigVertexCollection

bool TrigEDMChecker::m_doDumpTrigVertexCollection
private

Definition at line 154 of file TrigEDMChecker.h.

◆ m_doDumpxAODElectronContainer

bool TrigEDMChecker::m_doDumpxAODElectronContainer
private

Definition at line 136 of file TrigEDMChecker.h.

◆ m_doDumpxAODJetContainer

bool TrigEDMChecker::m_doDumpxAODJetContainer
private

Definition at line 66 of file TrigEDMChecker.h.

◆ m_doDumpxAODMuonContainer

bool TrigEDMChecker::m_doDumpxAODMuonContainer
private

Definition at line 121 of file TrigEDMChecker.h.

◆ m_doDumpxAODPhotonContainer

bool TrigEDMChecker::m_doDumpxAODPhotonContainer
private

Definition at line 139 of file TrigEDMChecker.h.

◆ m_doDumpxAODTauJetContainer

bool TrigEDMChecker::m_doDumpxAODTauJetContainer
private

Definition at line 157 of file TrigEDMChecker.h.

◆ m_doDumpxAODTrackParticle

bool TrigEDMChecker::m_doDumpxAODTrackParticle
private

Definition at line 163 of file TrigEDMChecker.h.

◆ m_doDumpxAODTrigElectronContainer

bool TrigEDMChecker::m_doDumpxAODTrigElectronContainer
private

Definition at line 130 of file TrigEDMChecker.h.

◆ m_doDumpxAODTrigEMCluster

bool TrigEDMChecker::m_doDumpxAODTrigEMCluster
private

Definition at line 91 of file TrigEDMChecker.h.

◆ m_doDumpxAODTrigEMClusterContainer

bool TrigEDMChecker::m_doDumpxAODTrigEMClusterContainer
private

Definition at line 94 of file TrigEDMChecker.h.

◆ m_doDumpxAODTrigMinBias

bool TrigEDMChecker::m_doDumpxAODTrigMinBias
private

Definition at line 175 of file TrigEDMChecker.h.

◆ m_doDumpxAODTrigMissingET

bool TrigEDMChecker::m_doDumpxAODTrigMissingET
private

Definition at line 63 of file TrigEDMChecker.h.

◆ m_doDumpxAODTrigPhotonContainer

bool TrigEDMChecker::m_doDumpxAODTrigPhotonContainer
private

Definition at line 133 of file TrigEDMChecker.h.

◆ m_doDumpxAODVertex

bool TrigEDMChecker::m_doDumpxAODVertex
private

Definition at line 166 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 172 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 187 of file TrigEDMChecker.h.

◆ m_dumpTrigCompositeContainers

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

Definition at line 183 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 188 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 216 of file TrigEDMChecker.h.

◆ m_muonTracksKey

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

Definition at line 220 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 221 of file TrigEDMChecker.h.

◆ m_navigationTool

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

Definition at line 223 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 226 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 224 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 227 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:
AthHistogramming::m_rootDir
std::string m_rootDir
Name of the ROOT directory.
Definition: AthHistogramming.h:229
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TrigEDMChecker::m_navigationHandleKey
SG::ReadHandleKey< xAOD::TrigNavigation > m_navigationHandleKey
Definition: TrigEDMChecker.h:221
AthHistogramming::histSvc
const ServiceHandle< ITHistSvc > & histSvc() const
The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a...
Definition: AthHistogramming.h:421
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition: CaloCluster_v1.cxx:256
Trk::numberOfPixelHits
@ numberOfPixelHits
number of pixel layers on track with absence of hits
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:57
xAOD::JetAttribute::BchCorrCell
@ BchCorrCell
Definition: JetAttributes.h:94
TrigEDMChecker::m_excludeFailedHypoNodes
Gaudi::Property< bool > m_excludeFailedHypoNodes
Definition: TrigEDMChecker.h:188
xAOD::numberOfPixelHoles
@ numberOfPixelHoles
number of pixel layers on track with absence of hits [unit8_t].
Definition: TrackingPrimitives.h:261
get_hdefs.buff
buff
Definition: get_hdefs.py:64
AthAnalysisAlgorithm::m_currentFile
TFile * m_currentFile
Definition: AthAnalysisAlgorithm.h:120
Trk::py
@ py
Definition: ParamDefs.h:66
xAOD::JetAttribute::GhostTruthParticleCount
@ GhostTruthParticleCount
Definition: JetAttributes.h:54
TrigEDMChecker::m_doDumpTrigEMCluster
bool m_doDumpTrigEMCluster
Definition: TrigEDMChecker.h:84
TrigEDMChecker::m_doDumpxAODJetContainer
bool m_doDumpxAODJetContainer
Definition: TrigEDMChecker.h:66
TrigInDetTrackFitPar::ez0
double ez0() const
variance of longitudinal impact parameter
Definition: TrigInDetTrackFitPar.h:243
ConvertOldHistosToNewHistos.converted
converted
Definition: ConvertOldHistosToNewHistos.py:40
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
xAOD::JetAttribute::Sphericity
@ Sphericity
Definition: JetAttributes.h:174
AthHistogramming::myReplace
void myReplace(std::string &str, const std::string &oldStr, const std::string &newStr)
Helper method to replace sub-string.
Definition: AthHistogramming.cxx:590
TrigEDMChecker::m_doDumpNavigation
bool m_doDumpNavigation
Definition: TrigEDMChecker.h:185
color
Definition: jFexInputByteStreamTool.cxx:25
Trk::TrackParticleBase::charge
double charge() const
Return charge of the particle.
Definition: TrackParticleBase.h:200
AthHistogramming::m_msg
MsgStream m_msg
Cached Message Stream.
Definition: AthHistogramming.h:248
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
AthHistogramming::m_histMap
HistMap_t m_histMap
The map of histogram names to their pointers.
Definition: AthHistogramming.h:201
AthAnalysisAlgorithm::endInputFile
virtual StatusCode endInputFile()
Function called as an input file is being closed.
Definition: AthAnalysisAlgorithm.cxx:122
CxxUtils::starts_with
bool starts_with(const char *s, const char *prefix)
Test whether one null-terminated byte string starts with another.
HLT::TrigNavStructure::getAll
void getAll(std::vector< TriggerElement * > &output, const bool activeOnly=true) const
The query returning a collection of all TriggerElements.
Definition: TrigNavStructure.cxx:363
test_pyathena.px
px
Definition: test_pyathena.py:18
xAOD::JetAttribute::LArQuality
@ LArQuality
Definition: JetAttributes.h:83
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
TrigEDMChecker::m_muonPrinter
ToolHandle< Rec::IMuonPrintingTool > m_muonPrinter
Definition: TrigEDMChecker.h:216
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
xAOD::JetAttribute::Dip23
@ Dip23
Definition: JetAttributes.h:153
TrigEDMChecker::m_doDumpTrigInDetTrackCollection
bool m_doDumpTrigInDetTrackCollection
Definition: TrigEDMChecker.h:151
HLT::HLTResult::isPassThrough
bool isPassThrough() const
forced-accepted (FA) event configuration the FA request(s) are set per chain and hlt level by the tig...
Definition: HLTResult.h:152
TrigCompositeUtils::DecisionID
unsigned int DecisionID
Definition: TrigComposite_v1.h:27
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
AthAnalysisAlgorithm::firstExecute
virtual StatusCode firstExecute()
Function called when first execute is encountered user can read event information with evtStore()
Definition: AthAnalysisAlgorithm.cxx:139
AddEmptyComponent.histName
string histName
Definition: AddEmptyComponent.py:64
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
xAOD::JetAttribute::FracSamplingMax
@ FracSamplingMax
Definition: JetAttributes.h:116
AthHistogramAlgorithm::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Default constructor: AthHistogramAlgorithm();.
Definition: AthHistogramAlgorithm.h:83
TrigCompositeUtils::passed
bool passed(DecisionID id, const DecisionIDContainer &idSet)
checks if required decision ID is in the set of IDs in the container
Definition: TrigCompositeUtilsRoot.cxx:117
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ID
std::vector< Identifier > ID
Definition: CalibHitIDCheck.h:24
TrigEDMChecker::m_doDumpxAODTrigMissingET
bool m_doDumpxAODTrigMissingET
Definition: TrigEDMChecker.h:63
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
TrigEDMChecker::m_doTDTCheck
bool m_doTDTCheck
Definition: TrigEDMChecker.h:172
ParticleTest.eg
eg
Definition: ParticleTest.py:29
HLT::TrigNavStructure::label
std::string label(class_id_type clid, const index_or_label_type &sti_or_label) const
Definition: TrigNavStructure.cxx:775
Trk::Track
The ATLAS Track class.
Definition: Tracking/TrkEvent/TrkTrack/TrkTrack/Track.h:73
TrigConf::HLTChain::chain_name
const std::string & chain_name() const
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:72
xAOD::JetAttribute::DipExcl12
@ DipExcl12
Definition: JetAttributes.h:154
HLT::Identifier::numeric
TrigCompositeUtils::DecisionID numeric() const
numeric ID
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:47
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
xAOD::JetAttribute::BchCorrJetForCell
@ BchCorrJetForCell
Definition: JetAttributes.h:205
xAOD::EgammaParameters::e2ts1
@ e2ts1
2nd max in strips calc by summing 3 strips
Definition: EgammaEnums.h:105
xAOD::JetAttribute::FoxWolfram2
@ FoxWolfram2
Definition: JetAttributes.h:171
TBReadH8ByteStream-Monitor_jobOptions.SGkey
SGkey
Definition: TBReadH8ByteStream-Monitor_jobOptions.py:53
xAOD::JetAttribute::isBadMedium
@ isBadMedium
Definition: JetAttributes.h:191
AthHistogramming::book
StatusCode book(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition: AthHistogramming.h:303
SG::Accessor
Helper class to provide type-safe access to aux data.
Definition: Control/AthContainers/AthContainers/Accessor.h:66
TrigEDMChecker::m_doDumpTrigMuonEFContainer
bool m_doDumpTrigMuonEFContainer
Definition: TrigEDMChecker.h:113
TrigEDMChecker::m_doDumpTrigElectronContainer
bool m_doDumpTrigElectronContainer
Definition: TrigEDMChecker.h:127
TrigEDMChecker::m_doDumpTrigL2BphysContainer
bool m_doDumpTrigL2BphysContainer
Definition: TrigEDMChecker.h:69
TrigInDetTrackFitPar::surfaceCoordinate
void surfaceCoordinate(double c)
Setter: surface reference coordinate for non-perigee surfaces.
Definition: TrigInDetTrackFitPar.h:227
TrigInDetTrackCollection
Definition: TrigInDetTrackCollection.h:13
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
xAOD::TrigComposite_v1::objectLink
ElementLink< CONTAINER > objectLink(const std::string &name) const
Get the link with the requested name.
xAOD::JetAttribute::OotFracCells10
@ OotFracCells10
Definition: JetAttributes.h:89
TrigCompositeUtils::newDecisionIn
Decision * newDecisionIn(DecisionContainer *dc, const std::string &name)
Helper method to create a Decision object, place it in the container and return a pointer to it.
Definition: TrigCompositeUtilsRoot.cxx:46
TrigEDMChecker::m_dumpNavForChain
Gaudi::Property< std::string > m_dumpNavForChain
Definition: TrigEDMChecker.h:187
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
xAOD::JetAttribute::Dip13
@ Dip13
Definition: JetAttributes.h:152
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
xAOD::JetAttribute::BchCorrJet
@ BchCorrJet
Definition: JetAttributes.h:204
TrigInDetTrackFitPar
Definition: TrigInDetTrackFitPar.h:67
TrigCompositeUtils::addDecisionID
void addDecisionID(DecisionID id, Decision *d)
Appends the decision (given as ID) to the decision object.
Definition: TrigCompositeUtilsRoot.cxx:61
TrigEDMChecker::m_dumpTrigCompositeContainers
std::vector< std::string > m_dumpTrigCompositeContainers
Definition: TrigEDMChecker.h:183
theta
Scalar theta() const
theta method
Definition: AmgMatrixBasePlugin.h:71
xAOD::JetAttribute::N90Cells
@ N90Cells
Definition: JetAttributes.h:92
I4Momentum::p
virtual double p() const =0
momentum magnitude
HLT::NavigationCore::deserialize
bool deserialize(const std::vector< uint32_t > &input)
Definition: NavigationCore.cxx:151
xAOD::TrigBphys_v1::particleType
pType particleType() const
accessor method: particle Type
TrigEDMChecker::m_trackWarningNum
int m_trackWarningNum
Definition: TrigEDMChecker.h:226
AthAnalysisAlgorithm::m_inputMetaStore
ServiceHandle< StoreGateSvc > m_inputMetaStore
Object accessing the input metadata store.
Definition: AthAnalysisAlgorithm.h:116
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
xAOD::JetAttribute::FoxWolfram4
@ FoxWolfram4
Definition: JetAttributes.h:173
Trk::TrackParticleBase::trackSummary
const TrackSummary * trackSummary() const
accessor function for TrackSummary.
Definition: TrackParticleBase.h:247
skel.it
it
Definition: skel.GENtoEVGEN.py:423
HLT::TriggerElement::getId
te_id_type getId() const
reset internals.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:43
xAOD::Iso::ptcone30
@ ptcone30
Definition: IsolationType.h:41
HLT::TriggerElement::FeatureAccessHelper::getCLID
class_id_type getCLID() const
Class ID of object.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:208
test_pyathena.pt
pt
Definition: test_pyathena.py:11
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
HLT::TrigNavStructure::isTerminalNode
static bool isTerminalNode(const TriggerElement *te)
queries if node is terminal (no more TriggerElement are seeded by it)
Definition: TrigNavStructure.cxx:517
xAOD::Iso::ptcone20
@ ptcone20
Track isolation.
Definition: IsolationType.h:40
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::Iso::etcone40
@ etcone40
Definition: IsolationType.h:34
TrigInDetTrackFitPar::eta
void eta(const double eta)
Setter: pseudorapidity.
Definition: TrigInDetTrackFitPar.h:219
Trk::z0
@ z0
Definition: ParamDefs.h:70
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
xAOD::JetConstituentVector::size
size_t size() const
number of constituents
Definition: JetConstituentVector.cxx:102
TrigEDMChecker::m_doDumpxAODTauJetContainer
bool m_doDumpxAODTauJetContainer
Definition: TrigEDMChecker.h:157
TrigEDMChecker::m_doDumpMuonFeature
bool m_doDumpMuonFeature
Definition: TrigEDMChecker.h:101
athena.value
value
Definition: athena.py:122
TrigInDetTrackFitPar::epT
double epT() const
variance of transverse momentum
Definition: TrigInDetTrackFitPar.h:249
TrigInDetTrackFitPar::z0
void z0(const double z0)
Setter: longitudinal impact parameter.
Definition: TrigInDetTrackFitPar.h:215
TrigCompositeUtils::createAndStore
SG::WriteHandle< DecisionContainer > createAndStore(const SG::WriteHandleKey< DecisionContainer > &key, const EventContext &ctx)
Creates and right away records the DecisionContainer with the key.
Definition: TrigCompositeUtilsRoot.cxx:30
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
xAOD::JetAttribute::VoronoiArea
@ VoronoiArea
Definition: JetAttributes.h:45
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition: TrackingPrimitives.h:275
xAOD::TrigBphys_v1::mass
float mass() const
accessor method: mass
xAOD::Iso::etcone30
@ etcone30
Definition: IsolationType.h:33
xAOD::JetAttribute::EnergyPerSampling
@ EnergyPerSampling
Definition: JetAttributes.h:115
AthAnalysisAlgorithm::inputMetaStore
const ServiceHandle< StoreGateSvc > & inputMetaStore() const
Const accessor for the input metadata store.
Definition: AthAnalysisAlgorithm.h:49
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
beamspotman.tokens
tokens
Definition: beamspotman.py:1284
TrigConf::HLTChain
HLT chain configuration information.
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:35
xAOD::TrigBphys_v1::secondaryDecay
const TrigBphys_v1 * secondaryDecay() const
accessor method: secondary decay particle
xAOD::JetAttribute::CentroidR
@ CentroidR
Definition: JetAttributes.h:131
AthAnalysisAlgorithm::AthAnalysisAlgorithm
AthAnalysisAlgorithm(const std::string &name)
Constructor taking just a name.
Definition: AthAnalysisAlgorithm.cxx:19
xAOD::JetAttribute::SamplingMax
@ SamplingMax
Definition: JetAttributes.h:119
TrigEDMChecker::m_doDumpTrackParticleContainer
bool m_doDumpTrackParticleContainer
Definition: TrigEDMChecker.h:57
AthHistogramming::m_histNamePostfix
std::string m_histNamePostfix
The postfix for the histogram THx name.
Definition: AthHistogramming.h:235
xAOD::JetAttribute::OotFracClusters10
@ OotFracClusters10
Definition: JetAttributes.h:86
xAOD::JetAttribute::BchCorrDotx
@ BchCorrDotx
Definition: JetAttributes.h:203
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
H5Utils::getTree
std::string getTree(const std::string &file_name)
Definition: getTree.cxx:36
xAOD::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the first pixel layer, i.e.
Definition: TrackingPrimitives.h:231
xAOD::TrigComposite_v1::linkColClids
const std::vector< uint32_t > & linkColClids() const
Raw access to the persistent link CLIDs.
xAOD::TrigNavigation_v1::serialized
const std::vector< unsigned int > & serialized() const
expose the navigation information (in serialized form)
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
xAOD::JetAttribute::LArBadHVEnergy
@ LArBadHVEnergy
Definition: JetAttributes.h:81
Trk::RecVertex
Trk::RecVertex inherits from Trk::Vertex.
Definition: RecVertex.h:44
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
Trk::numberOfBLayerHits
@ numberOfBLayerHits
these are the hits in the 0th pixel layer?
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:51
HLT::TriggerElement::getRelated
const std::vector< TriggerElement * > & getRelated(Relation rel) const
returns reference to the likns to other TriggerElements related by relation r
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:127
TrigEDMChecker::m_doDumpxAODTrigEMCluster
bool m_doDumpxAODTrigEMCluster
Definition: TrigEDMChecker.h:91
AthAnalysisAlgorithm::m_doneFirstEvent
bool m_doneFirstEvent
Definition: AthAnalysisAlgorithm.h:122
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TrigEDMChecker::m_doDumpxAODVertex
bool m_doDumpxAODVertex
Definition: TrigEDMChecker.h:166
runBeamSpotCalibration.helper
helper
Definition: runBeamSpotCalibration.py:112
TrigEDMChecker::m_doDumpTrigMuonEFInfoContainer
bool m_doDumpTrigMuonEFInfoContainer
Definition: TrigEDMChecker.h:116
TrigEDMChecker::m_doDumpxAODTrigEMClusterContainer
bool m_doDumpxAODTrigEMClusterContainer
Definition: TrigEDMChecker.h:94
TrigEDMChecker::m_doDumpxAODTrigElectronContainer
bool m_doDumpxAODTrigElectronContainer
Definition: TrigEDMChecker.h:130
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
TrigEDMChecker::m_doDumpTrigEMClusterContainer
bool m_doDumpTrigEMClusterContainer
Definition: TrigEDMChecker.h:87
ClassID_traits::ID
static const CLID & ID()
the CLID of T
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:50
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
xAOD::JetAttribute::ThrustMin
@ ThrustMin
Definition: JetAttributes.h:167
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
xAOD::EgammaParameters::ethad
@ ethad
ET leakage into hadronic calorimeter with exclusion of energy in CaloSampling::TileGap3.
Definition: EgammaEnums.h:45
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
xAOD::JetAttribute::HECQuality
@ HECQuality
Definition: JetAttributes.h:80
TrigEDMChecker::m_doDumpAllTrigComposite
bool m_doDumpAllTrigComposite
Definition: TrigEDMChecker.h:182
TrigEDMChecker::m_doDumpHLTResult
bool m_doDumpHLTResult
Definition: TrigEDMChecker.h:148
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
convertTimingResiduals.sum
sum
Definition: convertTimingResiduals.py:55
xAOD::TrigPassBits_v1::containerClid
uint32_t containerClid() const
CLID of the target container.
TrigConf::HLTUtils::string2hash
static HLTHash string2hash(const std::string &, const std::string &category="TE")
hash function translating TE names into identifiers
xAOD::JetAttribute::FoxWolfram3
@ FoxWolfram3
Definition: JetAttributes.h:172
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
lumiFormat.i
int i
Definition: lumiFormat.py:92
TrigEDMChecker::m_doDumpxAODElectronContainer
bool m_doDumpxAODElectronContainer
Definition: TrigEDMChecker.h:136
xAOD::JetAttribute::NumTrkPt1000
@ NumTrkPt1000
Definition: JetAttributes.h:105
TrigEDMChecker::m_doDumpTrigCompsiteNavigation
bool m_doDumpTrigCompsiteNavigation
Definition: TrigEDMChecker.h:205
TrigEDMChecker::m_doDumpTrigPhotonContainer
bool m_doDumpTrigPhotonContainer
Definition: TrigEDMChecker.h:110
xAOD::JetAttribute::Tau2
@ Tau2
Definition: JetAttributes.h:136
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
xAOD::Iso::etcone20
@ etcone20
Calorimeter isolation.
Definition: IsolationType.h:32
Trk::theta
@ theta
Definition: ParamDefs.h:72
xAOD::JetAttribute::EMFrac
@ EMFrac
Definition: JetAttributes.h:112
TrigInDetTrackFitPar::surfaceType
void surfaceType(TrigSurfaceType s)
Setter: surface type PERIGEE=0, BARREL=1, ENDCAP=2.
Definition: TrigInDetTrackFitPar.h:225
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Trk::numberOfSCTHits
@ numberOfSCTHits
number of SCT holes
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:71
SG::WriteHandle::ptr
pointer_type ptr()
Dereference the pointer.
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TrigEDMChecker::m_doDumpStoreGate
bool m_doDumpStoreGate
Definition: TrigEDMChecker.h:169
xAOD::JetAttribute::GhostTrackCount
@ GhostTrackCount
Definition: JetAttributes.h:53
HLT::TriggerElement
TriggerElement is the basic ingreedient of the interface between HLT algorithms and the navigation It...
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:27
xAOD::TrigPassBits_v1::size
uint32_t size() const
The size of the target container.
xAOD::TrigPassBits_v1
Type describing which elements in a container passed a trigger chain.
Definition: TrigPassBits_v1.h:38
TH3
Definition: rootspy.cxx:440
xAOD::JetAttribute::KtDR
@ KtDR
Definition: JetAttributes.h:134
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
xAOD::JetAttribute::SumPtTrkPt1000
@ SumPtTrkPt1000
Definition: JetAttributes.h:107
calibdata.exception
exception
Definition: calibdata.py:496
TrigInDetTrackTruthMap
Definition: TrigInDetTrackTruthMap.h:38
xAOD::TrigBphys_v1::roiId
uint32_t roiId() const
accessor method: ID of L1 RoI
xAOD::EgammaParameters::e011
@ e011
uncalibrated energy (sum of cells) in presampler in a 1x1 window in cells in eta X phi
Definition: EgammaEnums.h:30
xAOD::JetAttribute::FoxWolfram0
@ FoxWolfram0
Definition: JetAttributes.h:169
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
checkCorrelInHIST.prefix
dictionary prefix
Definition: checkCorrelInHIST.py:391
Trk::px
@ px
Definition: ParamDefs.h:65
xAOD::JetAttribute::Timing
@ Timing
Definition: JetAttributes.h:90
xAOD::JetAttribute::Tau1
@ Tau1
Definition: JetAttributes.h:135
TrigEDMChecker::dumpTrigT2MBTSBits
void dumpTrigT2MBTSBits()
Definition: TrigEDMChecker.cxx:682
dumpFileToPlots.treeName
string treeName
Definition: dumpFileToPlots.py:20
TrigEDMChecker::m_doDumpTrigEFBphysContainer
bool m_doDumpTrigEFBphysContainer
Definition: TrigEDMChecker.h:72
TrigEDMChecker::dumpTrigTrackCounts
void dumpTrigTrackCounts()
Definition: TrigEDMChecker.cxx:750
JetTagCalibConfig.scheme
scheme
Definition: JetTagCalibConfig.py:10
TrigEDMChecker::m_doDumpxAODPhotonContainer
bool m_doDumpxAODPhotonContainer
Definition: TrigEDMChecker.h:139
I4Momentum::eta
virtual double eta() const =0
pseudo rapidity
TrigInDetTrackFitPar::cov
void cov(const std::vector< double > *cov)
Setter: covariance matrix of track parameters.
Definition: TrigInDetTrackFitPar.h:223
xAOD::uint64_t
uint64_t
Definition: EventInfo_v1.cxx:123
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::JetAttribute::Tau3
@ Tau3
Definition: JetAttributes.h:137
xAOD::JetAttribute::JVF
@ JVF
Definition: JetAttributes.h:99
AthAnalysisAlgorithm::metaDataStop
virtual StatusCode metaDataStop()
Function called before finalize user can read output metadata from outputMetaStore()
Definition: AthAnalysisAlgorithm.cxx:130
TrigEDMChecker::m_doDumpxAODMuonContainer
bool m_doDumpxAODMuonContainer
Definition: TrigEDMChecker.h:121
HLT::Navigation
The Navigation class, organizes TriggerElements into the tree structure.
Definition: Navigation.h:100
AthHistogramming::m_graphMap
GraphMap_t m_graphMap
The map of TGraph names to their pointers.
Definition: AthHistogramming.h:222
drawFromPickle.tan
tan
Definition: drawFromPickle.py:36
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
Trk::ParametersBase
Definition: ParametersBase.h:55
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TrigEDMChecker::m_doDumpxAODTrackParticle
bool m_doDumpxAODTrackParticle
Definition: TrigEDMChecker.h:163
Trk::Vertex::position
const Amg::Vector3D & position() const
return position of vertex
Definition: Vertex.cxx:72
AthHistogramming::m_streamName
std::string m_streamName
Name of the ROOT output stream (file)
Definition: AthHistogramming.h:226
HLT::HLTResult
HLT::HLTResult is sumarising result of trigger decision evaluation (online/offline) It contains basic...
Definition: HLTResult.h:57
xAOD::JetAttribute::IsoKR20Par
@ IsoKR20Par
Definition: JetAttributes.h:196
xAOD::numberOfSCTHoles
@ numberOfSCTHoles
number of SCT holes [unit8_t].
Definition: TrackingPrimitives.h:270
xAOD::TrigComposite_v1
Class used to describe composite objects in the HLT.
Definition: TrigComposite_v1.h:52
TrigEDMChecker::m_doDumpCombinedMuonFeature
bool m_doDumpCombinedMuonFeature
Definition: TrigEDMChecker.h:97
xAOD::TrigBphys_v1::fitmass
float fitmass() const
accessor method: mass from vertex fit
HLT::HLTResult::isAccepted
bool isAccepted() const
gets HLT decision
Definition: HLTResult.h:137
TrigEDMChecker::m_doDumpTrigTauContainer
bool m_doDumpTrigTauContainer
Definition: TrigEDMChecker.h:142
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
AthHistogramming::hash_t
uint32_t hash_t
typedef for the internal hash
Definition: AthHistogramming.h:169
TH2
Definition: rootspy.cxx:373
HLT::Identifier
Definition: TrigCompositeUtils/TrigCompositeUtils/HLTIdentifier.h:20
xAOD::JetAttribute::N90Constituents
@ N90Constituents
Definition: JetAttributes.h:91
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
CxxUtils::crc64
uint64_t crc64(const CRCTable &table, const char *data, size_t data_len)
Find the CRC-64 of a string,.
Definition: crc64.cxx:696
I4Momentum::phi
virtual double phi() const =0
phi in [-pi,pi[
xAOD::decisions
decisions
Definition: TrigComposite_v1.cxx:81
AthHistogramming::m_histTitlePostfix
std::string m_histTitlePostfix
The postfix for the histogram THx title.
Definition: AthHistogramming.h:241
HLT::HLTResult::isEmpty
bool isEmpty() const
true if result is empty
Definition: HLTResult.cxx:628
LVL1_ROI
Top level AOD object storing LVL1 RoIs.
Definition: LVL1_ROI.h:43
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
TrigInDetTrackTruth
Definition: TrigInDetTrackTruth.h:36
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
merge.output
output
Definition: merge.py:17
Trig::ChainGroup
Definition: Trigger/TrigAnalysis/TrigDecisionTool/TrigDecisionTool/ChainGroup.h:51
xAOD::JetAttribute::OotFracCells5
@ OotFracCells5
Definition: JetAttributes.h:88
TrigInDetTrackFitPar::eeta
double eeta() const
variance of pseudorapidity
Definition: TrigInDetTrackFitPar.h:247
TrigInDetTrackFitPar::ea0
double ea0() const
variance of transverse impact parameter
Definition: TrigInDetTrackFitPar.h:241
TrigEDMChecker::m_doDumpTrigEFBjetContainer
bool m_doDumpTrigEFBjetContainer
Definition: TrigEDMChecker.h:75
xAOD::JetAttribute::IsoKR20Perp
@ IsoKR20Perp
Definition: JetAttributes.h:197
TrigEDMChecker::m_doDumpTileTrackMuFeature
bool m_doDumpTileTrackMuFeature
Definition: TrigEDMChecker.h:107
Trig::ChainGroup::isPassed
bool isPassed(unsigned int condition=TrigDefs::Physics) const
tells if chain group passed
Definition: Trigger/TrigAnalysis/TrigDecisionTool/Root/ChainGroup.cxx:208
TrigEDMChecker::m_clidSvc
ServiceHandle< ::IClassIDSvc > m_clidSvc
Definition: TrigEDMChecker.h:218
Trk::numberOfTRTHits
@ numberOfTRTHits
number of TRT outliers
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:79
Amg::py
@ py
Definition: GeoPrimitives.h:39
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
xAOD::JetAttribute::AverageLArQF
@ AverageLArQF
Definition: JetAttributes.h:85
TrigEDMChecker::dumpTrigVertexCounts
void dumpTrigVertexCounts()
Definition: TrigEDMChecker.cxx:716
Trk::TrackParticleBase::reconstructedVertex
const VxCandidate * reconstructedVertex() const
Get a pointer to the primary vertex.
Definition: TrackParticleBase.h:215
Trk::TrackSummary
A summary of the information contained by a track.
Definition: Tracking/TrkEvent/TrkTrackSummary/TrkTrackSummary/TrackSummary.h:287
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
TrigInDetTrackFitPar::ephi0
double ephi0() const
variance of azimuthal angle of the momentum
Definition: TrigInDetTrackFitPar.h:245
Trk::d0
@ d0
Definition: ParamDefs.h:69
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
Trk::perigeeParameters
@ perigeeParameters
Definition: MeasurementType.h:19
xAOD::TrigPassBits_v1::passBits
const std::vector< uint32_t > & passBits() const
The internal bitmap created with the hypo decisions.
xAOD::JetAttribute::SumPtTrkPt500
@ SumPtTrkPt500
Definition: JetAttributes.h:108
TrigEDMChecker::m_muonTracksKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_muonTracksKey
Definition: TrigEDMChecker.h:220
Rec::TrackParticleContainer
Definition: Reconstruction/Particle/Particle/TrackParticleContainer.h:33
xAOD::JetAttribute::ThrustMaj
@ ThrustMaj
Definition: JetAttributes.h:168
xAOD::EgammaParameters::deltaPhi2
@ deltaPhi2
difference between the cluster phi (second sampling) and the phi of the track extrapolated to the sec...
Definition: EgammaEnums.h:204
AthHistogramming::hash
hash_t hash(const std::string &histName) const
Method to calculate a 32-bit hash from a string.
Definition: AthHistogramming.h:428
xAOD::JetAttribute::Aplanarity
@ Aplanarity
Definition: JetAttributes.h:175
xAOD::JetAttribute::TrackWidthPt1000
@ TrackWidthPt1000
Definition: JetAttributes.h:109
item
Definition: ItemListSvc.h:43
module_driven_slicing.getHist
def getHist(name, makehist)
Definition: module_driven_slicing.py:121
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
AthHistogramAlgorithm::sysInitialize
virtual StatusCode sysInitialize()
Initialization method invoked by the framework.
Definition: AthHistogramAlgorithm.cxx:75
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
xAOD::TrigBphys_v1::phi
float phi() const
accessor method: phi
TrigEDMChecker::m_doDumpTrigMuonEFIsolationContainer
bool m_doDumpTrigMuonEFIsolationContainer
Definition: TrigEDMChecker.h:124
xAOD::TrigComposite_v1::linkColNames
const std::vector< std::string > & linkColNames() const
Raw access to the persistent link names.
xAOD::JetAttribute::FoxWolfram1
@ FoxWolfram1
Definition: JetAttributes.h:170
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma)
Definition: CaloCluster_v1.h:188
TrigCompositeUtils::createLegName
HLT::Identifier createLegName(const HLT::Identifier &chainIdentifier, size_t counter)
Generate the HLT::Identifier which corresponds to a specific leg of a given chain.
Definition: TrigCompositeUtilsRoot.cxx:166
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
xAOD::JetAttribute::PtTruth
@ PtTruth
Definition: JetAttributes.h:194
Rec::TrackParticle
Definition: Reconstruction/Particle/Particle/TrackParticle.h:47
Rec::TrackParticle::measuredPerigee
const Trk::Perigee * measuredPerigee() const
Accessor method for Perigee.
Definition: Reconstruction/Particle/Particle/TrackParticle.h:180
python.copyTCTOutput.chains
chains
Definition: copyTCTOutput.py:81
xxh3::hash64
std::uint64_t hash64(const void *data, std::size_t size)
Passthrough to XXH3_64bits.
Definition: XXH.cxx:9
xAOD::Iso::ptcone40
@ ptcone40
Definition: IsolationType.h:42
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TrigEDMChecker::dumpTrigSpacePointCounts
void dumpTrigSpacePointCounts()
Definition: TrigEDMChecker.cxx:614
SG::WriteHandle
Definition: StoreGate/StoreGate/WriteHandle.h:76
TrigCompositeUtils::linkToPrevious
void linkToPrevious(Decision *d, const std::string &previousCollectionKey, size_t previousIndex)
Links to the previous object, location of previous 'seed' decision supplied by hand.
Definition: TrigCompositeUtilsRoot.cxx:139
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
TrigInDetTrackFitPar::a0
void a0(const double a0)
Setter: transverse impact parameter.
Definition: TrigInDetTrackFitPar.h:213
TrigEDMChecker::m_doDumpTrigVertexCollection
bool m_doDumpTrigVertexCollection
Definition: TrigEDMChecker.h:154
TrigCompositeUtils::isLegId
bool isLegId(const HLT::Identifier &legIdentifier)
Recognise whether the chain ID is a leg ID.
Definition: TrigCompositeUtilsRoot.cxx:204
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
DeMoScan.index
string index
Definition: DeMoScan.py:362
AthAnalysisAlgorithm::beginInputFile
virtual StatusCode beginInputFile()
Function called when a new input file is opened user can read input metadata from inputMetaStore()
Definition: AthAnalysisAlgorithm.cxx:114
TrigCompositeUtils::LinkInfo< xAOD::IParticleContainer >
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigCompositeUtils::getIndexFromLeg
int32_t getIndexFromLeg(const HLT::Identifier &legIdentifier)
Extract the numeric index of a leg identifier.
Definition: TrigCompositeUtilsRoot.cxx:191
AthHistogramming::m_effMap
EffMap_t m_effMap
The map of histogram names to their pointers.
Definition: AthHistogramming.h:208
TrigCompositeUtils::DecisionIDContainer
std::set< DecisionID > DecisionIDContainer
Definition: TrigComposite_v1.h:28
xAOD::JetAttribute::LArBadHVRatio
@ LArBadHVRatio
Definition: JetAttributes.h:82
HLT::TriggerElement::FeatureAccessHelper::getIndex
const ObjectIndex & getIndex() const
index in the external ojects array
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:209
h
TrigEDMChecker::m_doDumpLVL1_ROI
bool m_doDumpLVL1_ROI
Definition: TrigEDMChecker.h:54
AthHistogramming::m_histTitlePrefix
std::string m_histTitlePrefix
The prefix for the histogram THx title.
Definition: AthHistogramming.h:238
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
HLT::TriggerElement::FeatureAccessHelper
the FeatureAccessHelper is a class used to keep track of features attached to this TE.
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:192
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TrigRoiDescriptorCollection
Definition: TrigRoiDescriptorCollection.h:21
xAOD::JetAttribute::VoronoiAreaPy
@ VoronoiAreaPy
Definition: JetAttributes.h:48
TrigEDMChecker::m_doDumpxAODTrigPhotonContainer
bool m_doDumpxAODTrigPhotonContainer
Definition: TrigEDMChecker.h:133
Trk::VxCandidate
Definition: VxCandidate.h:27
TH1
Definition: rootspy.cxx:268
xAOD::JetAttribute::GhostMuonSegmentCount
@ GhostMuonSegmentCount
Definition: JetAttributes.h:52
AthHistogramming::m_treeMap
TreeMap_t m_treeMap
The map of TTree names to their pointers.
Definition: AthHistogramming.h:215
python.TriggerAPI.TriggerAPISession.chainName
chainName
Definition: TriggerAPISession.py:353
AthCommonMsg< Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
xAOD::JetAttribute::TrackWidthPt500
@ TrackWidthPt500
Definition: JetAttributes.h:110
AthHistogramming::m_histNamePrefix
std::string m_histNamePrefix
The prefix for the histogram THx name.
Definition: AthHistogramming.h:232
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:73
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
TrigEDMChecker::m_doDumpTrigTauClusterContainer
bool m_doDumpTrigTauClusterContainer
Definition: TrigEDMChecker.h:81
TrigEDMChecker::m_doDumpTauJetContainer
bool m_doDumpTauJetContainer
Definition: TrigEDMChecker.h:160
xAOD::JetAttribute::Width
@ Width
Definition: JetAttributes.h:122
xAOD::JetAttribute::OotFracClusters5
@ OotFracClusters5
Definition: JetAttributes.h:87
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
TrigEDMChecker::m_navigationTool
ToolHandle< HLT::Navigation > m_navigationTool
Definition: TrigEDMChecker.h:223
TrigEDMChecker::checkTrigCompositeElementLink
StatusCode checkTrigCompositeElementLink(const xAOD::TrigComposite *tc, size_t element)
Dump details on element links within TrigComposites.
Definition: TrigEDMChecker.cxx:4155
TrigCompositeUtils
Definition: Event/xAOD/xAODTrigger/xAODTrigger/TrigComposite.h:19
CaloCondBlobAlgs_fillNoiseFromASCII.folder
folder
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:56
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
HLT::HLTResult::size
unsigned int size() const
Definition: HLTResult.cxx:614
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
AthHistogramming::hist
TH1 * hist(const std::string &histName, const std::string &tDir="", const std::string &stream="")
Simplify the retrieval of registered histograms of any type.
Definition: AthHistogramming.cxx:198
xAOD::TrigNavigation_v1
Interface to the raw trigger navigation information of the event.
Definition: TrigNavigation_v1.h:34
TrigEDMChecker::m_decisionsKey
SG::WriteHandleKey< TrigCompositeUtils::DecisionContainer > m_decisionsKey
Definition: TrigEDMChecker.h:222
xAOD::JetAttribute::isBadLoose
@ isBadLoose
Definition: JetAttributes.h:190
AthHistogramming::m_histSvc
ServiceHandle< ITHistSvc > m_histSvc
Pointer to the THistSvc (event store by default)
Definition: AthHistogramming.h:194
xAOD::JetAttribute::HECFrac
@ HECFrac
Definition: JetAttributes.h:113
HLT::TriggerElement::getFeatureAccessHelpers
const std::vector< FeatureAccessHelper > & getFeatureAccessHelpers() const
returns all features which ara attached to this TE
Definition: TrigNavStructure/TrigNavStructure/TriggerElement.h:238
dqt_zlumi_alleff_HIST.eff
int eff
Definition: dqt_zlumi_alleff_HIST.py:113
xAOD::JetConstituentVector
A vector of jet constituents at the scale used during jet finding.
Definition: JetConstituentVector.h:117
Trk::phi
@ phi
Definition: ParamDefs.h:81
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
merge.status
status
Definition: merge.py:17
xAOD::EgammaParameters::e132
@ e132
uncalibrated energy (sum of cells) in strips in a 3x2 window in cells in eta X phi
Definition: EgammaEnums.h:36
xAOD::JetAttribute::ActiveArea
@ ActiveArea
Definition: JetAttributes.h:42
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
xAOD::EgammaParameters::e237
@ e237
uncalibrated energy (sum of cells) of the middle sampling in a rectangle of size 3x7
Definition: EgammaEnums.h:77
AthAnalysisAlgorithm::m_outputMetaStore
ServiceHandle< StoreGateSvc > m_outputMetaStore
Object accessing the output metadata store.
Definition: AthAnalysisAlgorithm.h:118
TrigInDetTrackTruth::nrMatches
unsigned int nrMatches() const
returns number of matching particles
Definition: TrigInDetTrackTruth.cxx:244
xAOD::JetAttribute::FracSamplingMaxIndex
@ FracSamplingMaxIndex
Definition: JetAttributes.h:117
LVL1_ROI::getEmTauROIs
const emtaus_type & getEmTauROIs() const
Get all the em/tau RoIs in the event.
Definition: LVL1_ROI.h:65
xAOD::EgammaParameters::deltaEta1
@ deltaEta1
difference between the cluster eta (first sampling) and the eta of the track extrapolated to the firs...
Definition: EgammaEnums.h:184
Trig::ChainGroup::getListOfTriggers
std::vector< std::string > getListOfTriggers() const
Definition: Trigger/TrigAnalysis/TrigDecisionTool/Root/ChainGroup.cxx:467
xAOD::TrigBphys_v1::eta
float eta() const
accessor method: eta
TrigEDMChecker::m_doDumpTrigMissingET
bool m_doDumpTrigMissingET
Definition: TrigEDMChecker.h:60
xAOD::EgammaParameters::e2tsts1
@ e2tsts1
energy of the cell corresponding to second energy maximum in the first sampling
Definition: EgammaEnums.h:108
xAOD::JetAttribute::isBadTight
@ isBadTight
Definition: JetAttributes.h:192
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma)
Definition: CaloCluster_v1.h:187
xAOD::JetAttribute::VoronoiAreaPz
@ VoronoiAreaPz
Definition: JetAttributes.h:49
AthHistogramming::m_name
std::string m_name
Instance name.
Definition: AthHistogramming.h:245
TrigInDetTrackFitPar::phi0
void phi0(const double phi0)
Setter: azimuthal angle of the momentum.
Definition: TrigInDetTrackFitPar.h:217
jet::ExtendedBool::UNSET
@ UNSET
Definition: UncertaintyEnum.h:232
xAOD::JetAttribute::NumTrkPt500
@ NumTrkPt500
Definition: JetAttributes.h:106
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
TrigEDMChecker::m_trigDec
PublicToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: TrigEDMChecker.h:224
INACTIVE
@ INACTIVE
Definition: ZdcID.h:21
xAOD::numberOfTRTHoles
@ numberOfTRTHoles
number of TRT holes [unit8_t].
Definition: TrackingPrimitives.h:277
xAOD::EgammaParameters::e335
@ e335
uncalibrated energy (sum of cells) of the third sampling in a rectangle of size 3x5
Definition: EgammaEnums.h:86
TrigEDMChecker::m_doDumpxAODTrigMinBias
bool m_doDumpxAODTrigMinBias
Definition: TrigEDMChecker.h:175
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
Trk::TrackParticleBase::originalTrack
const Track * originalTrack() const
Return pointer to associated track.
Definition: TrackParticleBase.h:205
python.compressB64.c
def c
Definition: compressB64.py:93
TrigEDMChecker::m_doDumpTrigTauTracksInfo
bool m_doDumpTrigTauTracksInfo
Definition: TrigEDMChecker.h:145
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrigConf::HLTChain::leg_multiplicities
const std::vector< size_t > leg_multiplicities() const
Definition: TrigConfHLTData/TrigConfHLTData/HLTChain.h:82
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
python.TriggerConfig.testMenu
def testMenu(flags)
Definition: TriggerConfig.py:831
TrigEDMChecker::m_doDumpTrigL2BjetContainer
bool m_doDumpTrigL2BjetContainer
Definition: TrigEDMChecker.h:78
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
TrigEDMChecker::m_doDumpTileMuFeature
bool m_doDumpTileMuFeature
Definition: TrigEDMChecker.h:104
TrigInDetTrackFitPar::pT
void pT(const double pT)
Setter: transverse momentum.
Definition: TrigInDetTrackFitPar.h:221
xAOD::TrigBphys_v1
Class describing a Bphysics online composite object.
Definition: TrigBphys_v1.h:44
xAOD::JetAttribute::VoronoiAreaE
@ VoronoiAreaE
Definition: JetAttributes.h:46
xAOD::JetAttribute::NegativeE
@ NegativeE
Definition: JetAttributes.h:84
checkFileSG.ind
list ind
Definition: checkFileSG.py:118
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
AthAnalysisHelper::retrieveMetadata
static std::string retrieveMetadata(const std::string &folder, const std::string &key, const ServiceHandle< StoreGateSvc > &inputMetaStore)
method that always returns as a string you can use from, e.g, pyROOT with evt = ROOT....
Definition: AthAnalysisHelper.h:254
AthHistogramming::buildBookingString
void buildBookingString(std::string &bookingString, std::string &histName, std::string &tDir, std::string &stream, bool usePrefixPostfix=false)
Method to build individual booking string.
Definition: AthHistogramming.cxx:560
ServiceHandle< IIncidentSvc >
xAOD::JetAttribute::Dip12
@ Dip12
Definition: JetAttributes.h:151
TrigEDMChecker::m_doDumpAll
bool m_doDumpAll
a handle on Store Gate for access to the Event Store
Definition: TrigEDMChecker.h:50
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
TrigEDMChecker::m_vertexWarningNum
int m_vertexWarningNum
Definition: TrigEDMChecker.h:227
AthHistogramming::bookGetPointer
TH1 * bookGetPointer(const TH1 &hist, const std::string &tDir="", const std::string &stream="")
Simplify the booking and registering (into THistSvc) of histograms.
Definition: AthHistogramming.h:260
xAOD::JetAttribute::VoronoiAreaPx
@ VoronoiAreaPx
Definition: JetAttributes.h:47
ViewContainer
Definition: View.h:161
TrigEDMChecker::m_doDumpTrigPassBits
bool m_doDumpTrigPassBits
Definition: TrigEDMChecker.h:52
SCT_Monitoring::summary
@ summary
Definition: SCT_MonitoringNumbers.h:65