ATLAS Offline Software
Public Types | Public Member Functions | Public Attributes | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
TrigMETMonitorAlgorithm Class Reference

#include <TrigMETMonitorAlgorithm.h>

Inheritance diagram for TrigMETMonitorAlgorithm:
Collaboration diagram for TrigMETMonitorAlgorithm:

Public Types

enum  Environment_t {
  Environment_t::user = 0, Environment_t::online, Environment_t::tier0, Environment_t::tier0Raw,
  Environment_t::tier0ESD, Environment_t::AOD, Environment_t::altprod
}
 Specifies the processing environment. More...
 
enum  DataType_t {
  DataType_t::userDefined = 0, DataType_t::monteCarlo, DataType_t::collisions, DataType_t::cosmics,
  DataType_t::heavyIonCollisions
}
 Specifies what type of input data is being monitored. More...
 

Public Member Functions

 TrigMETMonitorAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~TrigMETMonitorAlgorithm ()
 
virtual StatusCode initialize () override
 initialize More...
 
virtual StatusCode fillHistograms (const EventContext &ctx) const override
 adds event to the monitoring histograms More...
 
virtual StatusCode execute (const EventContext &ctx) const override
 Applies filters and trigger requirements. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by reference. More...
 
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by reference. More...
 
template<typename... T>
void fill (const ToolHandle< GenericMonitoringTool > &groupHandle, T &&... variables) const
 Fills a variadic list of variables to a group by reference. More...
 
void fill (const std::string &groupName, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
 Fills a vector of variables to a group by name. More...
 
void fill (const std::string &groupName, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &variables) const
 Fills a vector of variables to a group by name. More...
 
template<typename... T>
void fill (const std::string &groupName, T &&... variables) const
 Fills a variadic list of variables to a group by name. More...
 
Environment_t environment () const
 Accessor functions for the environment. More...
 
Environment_t envStringToEnum (const std::string &str) const
 Convert the environment string from the python configuration to an enum object. More...
 
DataType_t dataType () const
 Accessor functions for the data type. More...
 
DataType_t dataTypeStringToEnum (const std::string &str) const
 Convert the data type string from the python configuration to an enum object. More...
 
const ToolHandle< GenericMonitoringTool > & getGroup (const std::string &name) const
 Get a specific monitoring tool from the tool handle array. More...
 
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool () const
 Get the trigger decision tool member. More...
 
bool trigChainsArePassed (const std::vector< std::string > &vTrigNames) const
 Check whether triggers are passed. More...
 
SG::ReadHandle< xAOD::EventInfoGetEventInfo (const EventContext &) const
 Return a ReadHandle for an EventInfo object (get run/event numbers, etc.) More...
 
virtual float lbAverageInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average mu, i.e. More...
 
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate instantaneous number of interactions, i.e. More...
 
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1). More...
 
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the instantaneous luminosity per bunch crossing. More...
 
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the duration of the luminosity block (in seconds) More...
 
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average luminosity livefraction. More...
 
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the live fraction per bunch crossing ID. More...
 
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average integrated luminosity multiplied by the live fraction. More...
 
virtual StatusCode parseList (const std::string &line, std::vector< std::string > &result) const
 Parse a string into a vector. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual bool isClonable () const override
 Specify if the algorithm is clonable. More...
 
virtual unsigned int cardinality () const override
 Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...
 
virtual StatusCode sysExecute (const EventContext &ctx) override
 Execute an algorithm. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
virtual bool filterPassed (const EventContext &ctx) const
 
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Public Attributes

 nightly
 
 file
 
 flags
 
 Files
 
 isMC
 
 HISTFileName
 
 cfg
 
 trigMETMonitorAcc
 
 withDetails
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

ToolHandleArray< GenericMonitoringToolm_tools {this,"GMTools",{}}
 Array of Generic Monitoring Tools. More...
 
PublicToolHandle< Trig::TrigDecisionToolm_trigDecTool {this, "TrigDecisionTool",""}
 Tool to tell whether a specific trigger is passed. More...
 
ToolHandleArray< IDQFilterToolm_DQFilterTools {this,"FilterTools",{}}
 Array of Data Quality filter tools. More...
 
SG::ReadCondHandleKey< LuminosityCondDatam_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
 
SG::ReadCondHandleKey< LBDurationCondDatam_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
 
SG::ReadCondHandleKey< TrigLiveFractionCondDatam_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}
 
AthMonitorAlgorithm::Environment_t m_environment
 Instance of the Environment_t enum. More...
 
AthMonitorAlgorithm::DataType_t m_dataType
 Instance of the DataType_t enum. More...
 
Gaudi::Property< std::string > m_environmentStr {this,"Environment","user"}
 Environment string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_dataTypeStr {this,"DataType","userDefined"}
 DataType string pulled from the job option and converted to enum. More...
 
Gaudi::Property< std::string > m_triggerChainString {this,"TriggerChain",""}
 Trigger chain string pulled from the job option and parsed into a vector. More...
 
std::vector< std::string > m_vTrigChainNames
 Vector of trigger chain names parsed from trigger chain string. More...
 
Gaudi::Property< std::string > m_fileKey {this,"FileKey",""}
 Internal Athena name for file. More...
 
Gaudi::Property< bool > m_useLumi {this,"EnableLumi",false}
 Allows use of various luminosity functions. More...
 
Gaudi::Property< float > m_defaultLBDuration {this,"DefaultLBDuration",60.}
 Default duration of one lumi block. More...
 
Gaudi::Property< int > m_detailLevel {this,"DetailLevel",0}
 Sets the level of detail used in the monitoring. More...
 
SG::ReadHandleKey< xAOD::EventInfom_EventInfoKey {this,"EventInfoKey","EventInfo"}
 Key for retrieving EventInfo from StoreGate. More...
 

Private Types

typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
 
typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

double signed_log (double e, double epsilon) const
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

SG::ReadHandleKey< xAOD::MissingETContainerm_offline_met_key {this, "offline_met_key", "MET_Reference_AntiKt4EMPFlow", "Offline met container name"}
 
SG::ReadHandleKey< xAOD::ElectronContainerm_hlt_electron_key {this, "hlt_electron_key", "HLT_egamma_Electrons_GSF", "HLT electron container name"}
 
SG::ReadHandleKey< xAOD::MuonContainerm_hlt_muon_key {this, "hlt_muon_key", "HLT_MuonsCB_FS", "HLT muon container name"}
 
SG::ReadHandleKey< xAOD::CaloClusterContainerm_topoclusters_key {this, "topoclusters_key", "HLT_TopoCaloClustersLCFS", "HLT topoclusters container name"}
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_tracks_key {this, "tracks_key", "HLT_IDTrack_FS_FTF", "HLT tracks container name"}
 
SG::ReadHandleKey< xAOD::VertexContainerm_vertex_key {this, "vertex_key", "HLT_IDVertex_FS", "HLT vertex container name"}
 
SG::ReadHandleKey< xAOD::VertexContainerm_offline_vertex_key {this, "offline_vertex_key", "PrimaryVertices", "Offline vertex container name"}
 
SG::ReadHandleKey< xAOD::EnergySumRoIm_lvl1_roi_key {this, "l1_roi_key", "LVL1EnergySumRoI", "L1 energy sum ROI container name"}
 
SG::ReadHandleKey< xAOD::jFexMETRoIContainerm_l1_jFexMet_key {this, "l1_jFexMet_key", "L1_jFexMETRoI", "L1 jFex MET container name"}
 
SG::ReadHandleKey< xAOD::jFexSumETRoIContainerm_l1_jFexSumEt_key {this, "l1_jFexSumEt_key", "L1_jFexSumETRoI", "L1 jFex sumEt container name"}
 
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainerm_l1_gFexJwojScalar_key {this, "l1_gFexJwojScalar_key", "L1_gScalarEJwoj", "L1 gFex JWOJ Et and sumEt container name"}
 
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainerm_l1_gFexJwojMETComponents_key {this, "l1_gFexJwojMETComponents_key", "L1_gMETComponentsJwoj", "L1 gFex JWOJ Ex and Ey container name"}
 
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainerm_l1_gFexJwojMHTComponents_key {this, "l1_gFexJwojMHTComponents_key", "L1_gMHTComponentsJwoj", "L1 gFex JWOJ Hard Term Ex and Ey container name"}
 
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainerm_l1_gFexJwojMSTComponents_key {this, "l1_gFexJwojMSTComponents_key", "L1_gMSTComponentsJwoj", "L1 gFex JWOJ Soft Term Ex and Ey container name"}
 
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainerm_l1_gFexNCMETScalar_key {this, "l1_gFexNCMETScalar_key", "L1_gScalarENoiseCut", "L1 gFex NC Et and sumEt container name"}
 
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainerm_l1_gFexNCMETComponents_key {this, "l1_gFexNCMETComponents_key", "L1_gMETComponentsNoiseCut", "L1 gFex NC Ex and Ey container name"}
 
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainerm_l1_gFexRhoMETScalar_key {this, "l1_gFexRhoMETScalar_key", "L1_gScalarERms", "L1 gFex Rho Et and sumEt container name"}
 
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainerm_l1_gFexRhoMETComponents_key {this, "l1_gFexRhoMETComponents_key", "L1_gMETComponentsRms", "L1 gFex Rho Ex and Ey container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_cell_met_key {this, "hlt_cell_key", "HLT_MET_cell", "HLT Cell MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_mht_met_key {this, "hlt_mht_key", "HLT_MET_mht", "HLT MHT MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_tc_met_key {this, "hlt_tc_key", "HLT_MET_tc", "HLT TC MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_tc_em_met_key {this, "hlt_tc_em_key", "HLT_MET_tc_em", "HLT TC EM MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_tcpufit_met_key {this, "hlt_tcpufit_key", "HLT_MET_tcpufit", "HLT TCPufit MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_tcpufit_sig30_met_key {this, "hlt_tcpufit_sig30_key", "HLT_MET_tcpufit_sig30", "HLT TCPufit sig30 MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_trkmht_met_key {this, "hlt_trkmht_key", "HLT_MET_trkmht", "HLT TrkMht MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_pfsum_met_key {this, "hlt_pfsum_key", "HLT_MET_pfsum", "HLT Pfsum MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_pfsum_cssk_met_key {this, "hlt_pfsum_cssk_key", "HLT_MET_pfsum_cssk", "HLT Pfsum CSSK MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_pfsum_vssk_met_key {this, "hlt_pfsum_vssk_key", "HLT_MET_pfsum_vssk", "HLT Pfsum VSSK MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_pfopufit_met_key {this, "hlt_pfopufit_key", "HLT_MET_pfopufit", "HLT PfoPufit MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_pfopufit_sig30_met_key {this, "hlt_pfopufit_sig30_key", "HLT_MET_pfopufit_sig30", "HLT PfoPufit sig30 MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_cvfpufit_met_key {this, "hlt_cvfpufit_key", "HLT_MET_cvfpufit", "HLT CvfPufit MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_mhtpufit_pf_met_key {this, "hlt_mhtpufit_pf_key", "HLT_MET_mhtpufit_pf", "HLT MhtPufitPf MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_mhtpufit_em_met_key {this, "hlt_mhtpufit_em_key", "HLT_MET_mhtpufit_em", "HLT MhtPufitEm MET container name"}
 
SG::ReadHandleKey< xAOD::TrigMissingETContainerm_hlt_met_nn_key {this, "hlt_met_nn_key", "HLT_MET_nn", "HLT MET NN container name"}
 
Gaudi::Property< std::vector< std::string > > m_l1Chains {this, "L1Chains", {}, "The L1 chains to monitor"}
 
Gaudi::Property< std::vector< std::string > > m_hltChains {this, "HLTChains", {}, "The HLT shifter chains to monitor"}
 
Gaudi::Property< std::vector< std::string > > m_hltChainsVal {this, "HLTChainsVal", {}, "The HLT val chains to monitor"}
 
Gaudi::Property< std::vector< std::string > > m_hltChainsT0 {this, "HLTChainsT0", {}, "The HLT t0 chains to monitor"}
 
Gaudi::Property< std::vector< std::string > > m_hltChainEl {this, "HLTChainEl", {}, "The HLT Electron primary chain to use for monitoring plots"}
 
Gaudi::Property< std::vector< std::string > > m_hltChainMu {this, "HLTChainMu", {}, "The HLT Muon primary chain to use for monitoring plots"}
 
Gaudi::Property< std::vector< std::string > > m_algsL1 {this, "algsL1", {}, "L1 algorithms to monitor"}
 
Gaudi::Property< std::vector< std::string > > m_algsHLT {this, "algsHLT", {}, "HLT algorithms to monitor"}
 
Gaudi::Property< std::vector< std::string > > m_algsHLTPreSel {this, "algsHLTPreSel", {}, "HLTPreSel algorithms to monitor"}
 
Gaudi::Property< std::vector< std::string > > m_LArNoiseBurstVetoAlgs {this, "LArNoiseBurstVetoAlgs", {}, "MET histograms with LAr NoiseBurst Veto Applied"}
 
Gaudi::Property< std::vector< std::string > > m_algsHLT2d {this, "algsHLT2d", {}, "HLT algorithms for 2d eta-phi plots"}
 
Gaudi::Property< std::vector< std::string > > m_algsHLTExpert {this, "algsHLTExpert", {}, "HLT algorithms for Expert"}
 
Gaudi::Property< std::vector< std::string > > m_algsMET2d_tcpufit {this, "algsMET2d_tcpufit", {}, "HLT algorithms for 2D MET wrt tcpufit"}
 
Gaudi::Property< std::vector< std::string > > m_compNames {this, "compNames", {}, "Calorimeter component names"}
 
Gaudi::Property< std::vector< std::string > > m_bitNames {this, "bitNames", {}, "Status bit names"}
 
Gaudi::Property< int > m_L1MetAlg {this, "L1MetAlg", 1, "L1 MET algorithm for PreSel"}
 
Gaudi::Property< double > m_L1MetCut {this, "L1MetCut", 50.0, "L1 MET cut for PreSel"}
 
Gaudi::Property< double > m_electronPtCut {this, "electronPtCut", 0.0, "Electron pt cut for leading electron"}
 
Gaudi::Property< double > m_electronEtaCut {this, "electronEtaCut", 0.0, "Electron eta cut for leading electron"}
 
Gaudi::Property< double > m_muonPtCut {this, "muonPtCut", 0.0, "Muon pt cut for leading muon"}
 
Gaudi::Property< double > m_muonEtaCut {this, "muonEtaCut", 0.0, "Muon eta cut for leading muon"}
 
Gaudi::Property< std::vector< std::string > > m_signalLepAlgs {this, "signalLepAlgs", {}, "Signal lepton MET histograms"}
 
std::string m_name
 
std::unordered_map< std::string, size_t > m_toolLookupMap
 
const ToolHandle< GenericMonitoringToolm_dummy
 
Gaudi::Property< bool > m_enforceExpressTriggers
 
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 37 of file TrigMETMonitorAlgorithm.h.

Member Typedef Documentation

◆ MonVarVec_t

typedef std::vector<std::reference_wrapper<Monitored::IMonitoredVariable> > AthMonitorAlgorithm::MonVarVec_t
privateinherited

Definition at line 365 of file AthMonitorAlgorithm.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataType_t

enum AthMonitorAlgorithm::DataType_t
stronginherited

Specifies what type of input data is being monitored.

An enumeration of the different types of data the monitoring application may be running over. This can be used to select which histograms to produce, e.g. to prevent the production of colliding-beam histograms when running on cosmic-ray data. Strings of the same names may be given as jobOptions.

Enumerator
userDefined 
monteCarlo 
collisions 
cosmics 
heavyIonCollisions 

Definition at line 191 of file AthMonitorAlgorithm.h.

191  {
192  userDefined = 0,
193  monteCarlo,
194  collisions,
195  cosmics,
196  heavyIonCollisions,
197  };

◆ Environment_t

enum AthMonitorAlgorithm::Environment_t
stronginherited

Specifies the processing environment.

The running environment may be used to select which histograms are produced, and where they are located in the output. For example, the output paths of the histograms are different for the "user", "online" and the various offline flags. Strings of the same names may be given as jobOptions.

Enumerator
user 
online 
tier0 
tier0Raw 
tier0ESD 
AOD 
altprod 

Definition at line 172 of file AthMonitorAlgorithm.h.

172  {
173  user = 0,
174  online,
175  tier0,
176  tier0Raw,
177  tier0ESD,
178  AOD,
179  altprod,
180  };

Constructor & Destructor Documentation

◆ TrigMETMonitorAlgorithm()

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

Definition at line 10 of file TrigMETMonitorAlgorithm.cxx.

11  : AthMonitorAlgorithm(name,pSvcLocator)
12 {
13 }

◆ ~TrigMETMonitorAlgorithm()

TrigMETMonitorAlgorithm::~TrigMETMonitorAlgorithm ( )
virtual

Definition at line 16 of file TrigMETMonitorAlgorithm.cxx.

16 {}

Member Function Documentation

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality
overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

64 {
65  return 0;
66 }

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

Returns
the current value of the class's DataType_t instance.

Definition at line 221 of file AthMonitorAlgorithm.h.

221 { return m_dataType; }

◆ dataTypeStringToEnum()

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::dataTypeStringToEnum ( const std::string &  str) const
inherited

Convert the data type string from the python configuration to an enum object.

Returns
a value in the DataType_t enumeration which matches the input string.

Definition at line 140 of file AthMonitorAlgorithm.cxx.

140  {
141  // convert the string to all lowercase
142  std::string lowerCaseStr = str;
143  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
144 
145  // check if it matches one of the enum choices
146  if( lowerCaseStr == "userdefined" ) {
148  } else if( lowerCaseStr == "montecarlo" ) {
149  return DataType_t::monteCarlo;
150  } else if( lowerCaseStr == "collisions" ) {
151  return DataType_t::collisions;
152  } else if( lowerCaseStr == "cosmics" ) {
153  return DataType_t::cosmics;
154  } else if( lowerCaseStr == "heavyioncollisions" ) {
156  } else { // otherwise, warn the user and return "userDefined"
157  ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
158  <<str<<", returning userDefined.");
160  }
161 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > &  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< Gaudi::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; }

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

Returns
the current value of the class's Environment_t instance.

Definition at line 205 of file AthMonitorAlgorithm.h.

205 { return m_environment; }

◆ envStringToEnum()

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::envStringToEnum ( const std::string &  str) const
inherited

Convert the environment string from the python configuration to an enum object.

Returns
a value in the Environment_t enumeration which matches the input string.

Definition at line 112 of file AthMonitorAlgorithm.cxx.

112  {
113  // convert the string to all lowercase
114  std::string lowerCaseStr = str;
115  std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
116 
117  // check if it matches one of the enum choices
118  if( lowerCaseStr == "user" ) {
119  return Environment_t::user;
120  } else if( lowerCaseStr == "online" ) {
121  return Environment_t::online;
122  } else if( lowerCaseStr == "tier0" ) {
123  return Environment_t::tier0;
124  } else if( lowerCaseStr == "tier0raw" ) {
126  } else if( lowerCaseStr == "tier0esd" ) {
128  } else if( lowerCaseStr == "aod" ) {
129  return Environment_t::AOD;
130  } else if( lowerCaseStr == "altprod" ) {
131  return Environment_t::altprod;
132  } else { // otherwise, warn the user and return "user"
133  ATH_MSG_WARNING("AthMonitorAlgorithm::envStringToEnum(): Unknown environment "
134  <<str<<", returning user.");
135  return Environment_t::user;
136  }
137 }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::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 AthMonitorAlgorithm::execute ( const EventContext &  ctx) const
overridevirtualinherited

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 73 of file AthMonitorAlgorithm.cxx.

73  {
74 
75  // Checks that all of the DQ filters are passed. If any one of the filters
76  // fails, return SUCCESS code and do not fill the histograms with the event.
77  for ( const auto& filterItr : m_DQFilterTools ) {
78  if (!filterItr->accept()) {
79  ATH_MSG_DEBUG("Event rejected due to filter tool.");
80  return StatusCode::SUCCESS;
81  }
82  }
83 
84  // Trigger: If there is a decision tool and the chains fail, skip the event.
86  ATH_MSG_DEBUG("Event rejected due to trigger filter.");
87  return StatusCode::SUCCESS;
88  }
89 
90  ATH_MSG_DEBUG("Event accepted!");
91  return fillHistograms(ctx);
92 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

90 {
91  // If we didn't find any symlinks to add, just return the collection
92  // from the base class. Otherwise, return the extended collection.
93  if (!m_extendedExtraObjects.empty()) {
95  }
96  return BaseAlg::extraOutputDeps();
97 }

◆ fillHistograms()

StatusCode TrigMETMonitorAlgorithm::fillHistograms ( const EventContext &  ctx) const
overridevirtual

adds event to the monitoring histograms

User will overwrite this function. Histogram booking is no longer done in C++. This function is called in execute once the filters are all passed.

Parameters
ctxforwarded from execute
Returns
StatusCode

Implements AthMonitorAlgorithm.

Definition at line 60 of file TrigMETMonitorAlgorithm.cxx.

60  {
61  using namespace Monitored;
62 
63 
64  if(m_trigDecTool->ExperimentalAndExpertMethods().isHLTTruncated()){
65  ATH_MSG_WARNING("HLTResult truncated, skip trigger analysis");
66  return StatusCode::SUCCESS;
67  } // ATR-31454
68 
69 
70  // access event info container
72  if (! eventInfo.isValid() ){
73  ATH_MSG_DEBUG("Container "<< eventInfo << " does not exist");
74  }
75 
76  // access lepton containers
78  if (! hlt_electron_cont.isValid() ) {
79  ATH_MSG_DEBUG("Container "<< m_hlt_electron_key << " does not exist");
80  }
81 
83  if (! hlt_muon_cont.isValid() ) {
84  ATH_MSG_DEBUG("Container "<< m_hlt_muon_key << " does not exist");
85  }
86 
87  // access topoclusters container
89  if (! hlt_topoclusters_cont.isValid() ) {
90  ATH_MSG_DEBUG("Container "<< m_topoclusters_key << " does not exist");
91  }
92 
93  // access tracks container
95  if (! hlt_tracks_cont.isValid() ) {
96  ATH_MSG_DEBUG("Container "<< m_tracks_key << " does not exist");
97  }
98 
99  // access vertex container
101  if (! hlt_vertex_cont.isValid() ) {
102  ATH_MSG_DEBUG("Container "<< m_vertex_key << " does not exist");
103  }
104 
106  if (! offline_vertex_cont.isValid() ) {
107  ATH_MSG_DEBUG("Container "<< m_offline_vertex_key << " does not exist");
108  }
109 
110  // access offline met containers
112  if (! offline_met_cont.isValid() ) {
113  ATH_MSG_DEBUG("Container "<< m_offline_met_key << " does not exist");
114  }
115 
116  // access L1 met containers
118  if (! l1_roi_cont.isValid() ) {
119  ATH_MSG_DEBUG("Container "<< m_lvl1_roi_key << " does not exist");
120  }
121 
122  // access L1 Fex met containers
124  if (! l1_jFexMet_cont.isValid() ) {
125  ATH_MSG_DEBUG("Container "<< m_l1_jFexMet_key << " does not exist");
126  }
128  if (! l1_jFexSumEt_cont.isValid() ) {
129  ATH_MSG_DEBUG("Container "<< m_l1_jFexSumEt_key << " does not exist");
130  }
132  if (! l1_gFexJwojScalar_cont.isValid() ) {
133  ATH_MSG_DEBUG("Container "<< m_l1_gFexJwojScalar_key << " does not exist");
134  }
136  if (! l1_gFexJwojMETComponents_cont.isValid() ) {
137  ATH_MSG_DEBUG("Container "<< m_l1_gFexJwojMETComponents_key << " does not exist");
138  }
140  if (! l1_gFexJwojMHTComponents_cont.isValid() ) {
141  ATH_MSG_DEBUG("Container "<< m_l1_gFexJwojMHTComponents_key << " does not exist");
142  }
144  if (! l1_gFexJwojMSTComponents_cont.isValid() ) {
145  ATH_MSG_DEBUG("Container "<< m_l1_gFexJwojMSTComponents_key << " does not exist");
146  }
148  if (! l1_gFexNCMETScalar_cont.isValid() ) {
149  ATH_MSG_DEBUG("Container "<< m_l1_gFexNCMETScalar_key << " does not exist");
150  }
152  if (! l1_gFexNCMETComponents_cont.isValid() ) {
153  ATH_MSG_DEBUG("Container "<< m_l1_gFexNCMETComponents_key << " does not exist");
154  }
156  if (! l1_gFexRhoMETScalar_cont.isValid() ) {
157  ATH_MSG_DEBUG("Container "<< m_l1_gFexRhoMETScalar_key << " does not exist");
158  }
160  if (! l1_gFexRhoMETComponents_cont.isValid() ) {
161  ATH_MSG_DEBUG("Container "<< m_l1_gFexRhoMETComponents_key << " does not exist");
162  }
163 
164  // access HLT met containers
166  if (! hlt_cell_met_cont.isValid() ) {
167  ATH_MSG_DEBUG("Container "<< m_hlt_cell_met_key << " does not exist");
168  }
169 
171  if (! hlt_mht_met_cont.isValid() ) {
172  ATH_MSG_DEBUG("Container "<< m_hlt_mht_met_key << " does not exist");
173  }
174 
176  if (! hlt_tc_met_cont.isValid() ) {
177  ATH_MSG_DEBUG("Container "<< m_hlt_tc_met_key << " does not exist");
178  }
179 
181  if (! hlt_tc_em_met_cont.isValid() ) {
182  ATH_MSG_DEBUG("Container "<< m_hlt_tc_em_met_key << " does not exist");
183  }
184 
186  if (! hlt_tcpufit_met_cont.isValid() ) {
187  ATH_MSG_DEBUG("Container "<< m_hlt_tcpufit_met_key << " does not exist");
188  }
189 
191  if (! hlt_tcpufit_sig30_met_cont.isValid() ) {
192  ATH_MSG_DEBUG("Container "<< m_hlt_tcpufit_sig30_met_key << " does not exist");
193  }
194 
196  if (! hlt_trkmht_met_cont.isValid() ) {
197  ATH_MSG_DEBUG("Container "<< m_hlt_trkmht_met_key << " does not exist");
198  }
199 
201  if (! hlt_pfsum_met_cont.isValid() ) {
202  ATH_MSG_DEBUG("Container "<< m_hlt_pfsum_met_key << " does not exist");
203  }
204 
206  if (! hlt_pfsum_cssk_met_cont.isValid() ) {
207  ATH_MSG_DEBUG("Container "<< m_hlt_pfsum_cssk_met_key << " does not exist");
208  }
209 
211  if (! hlt_pfsum_vssk_met_cont.isValid() ) {
212  ATH_MSG_DEBUG("Container "<< m_hlt_pfsum_vssk_met_key << " does not exist");
213  }
214 
216  if (! hlt_pfopufit_met_cont.isValid() ) {
217  ATH_MSG_DEBUG("Container "<< m_hlt_pfopufit_met_key << " does not exist");
218  }
219 
221  if (! hlt_pfopufit_sig30_met_cont.isValid() ) {
222  ATH_MSG_DEBUG("Container "<< m_hlt_pfopufit_sig30_met_key << " does not exist");
223  }
224 
226  if (! hlt_cvfpufit_met_cont.isValid() ) {
227  ATH_MSG_DEBUG("Container "<< m_hlt_cvfpufit_met_key << " does not exist");
228  }
229 
231  if (! hlt_mhtpufit_pf_met_cont.isValid() ) {
232  ATH_MSG_DEBUG("Container "<< m_hlt_mhtpufit_pf_met_key << " does not exist");
233  }
234 
236  if (! hlt_mhtpufit_em_met_cont.isValid() ) {
237  ATH_MSG_DEBUG("Container "<< m_hlt_mhtpufit_em_met_key << " does not exist");
238  }
239 
241  if (! hlt_met_nn_cont.isValid() ) {
242  ATH_MSG_DEBUG("Container "<< m_hlt_met_nn_key << " does not exist");
243  }
244 
245  // define variables
246  auto act_IPBC = Monitored::Scalar<float>("act_IPBC",0.0);
247  auto hlt_el_mult = Monitored::Scalar<int>("hlt_el_mult",0.0);
248  auto hlt_el_pt = Monitored::Scalar<float>("hlt_el_pt",0.0);
249  auto hlt_mu_mult = Monitored::Scalar<int>("hlt_mu_mult",0.0);
250  auto hlt_mu_pt = Monitored::Scalar<float>("hlt_mu_pt",0.0);
251 
252  auto hlt_topoclusters_mult = Monitored::Scalar<int>("hlt_topoclusters_mult",0.0);
253  auto hlt_topoclusters_pt = Monitored::Scalar<float>("hlt_topoclusters_pt",0.0);
254  auto hlt_tracks_mult = Monitored::Scalar<int>("hlt_tracks_mult",0.0);
255  auto hlt_tracks_pt = Monitored::Scalar<float>("hlt_tracks_pt",0.0);
256  auto hlt_tracks_phi = Monitored::Scalar<float>("hlt_tracks_phi",0.0);
257  auto hlt_tracks_eta = Monitored::Scalar<float>("hlt_tracks_eta",0.0);
258  auto hlt_tracks_leading_pt = Monitored::Scalar<float>("hlt_tracks_leading_pt",0.0);
259  auto hlt_tracks_vec_sumPt = Monitored::Scalar<float>("hlt_tracks_vec_sumPt",0.0);
260  auto hlt_tracks_sca_sumPt = Monitored::Scalar<float>("hlt_tracks_sca_sumPt",0.0);
261  auto hlt_vertex_mult = Monitored::Scalar<int>("hlt_vertex_mult",0.0);
262  auto hlt_vertex_mult_mu = Monitored::Scalar<int>("hlt_vertex_mult_mu",0.0);
263  auto hlt_vertex_z = Monitored::Scalar<float>("hlt_vertex_z",0.0);
264  auto hlt_vertex_z_diff = Monitored::Scalar<float>("hlt_vertex_z_diff",0.0);
265 
266  auto offline_Ex = Monitored::Scalar<float>("offline_Ex",0.0);
267  auto offline_Ey = Monitored::Scalar<float>("offline_Ey",0.0);
268  auto offline_Et = Monitored::Scalar<float>("offline_Et",0.0);
269  auto offline_sumEt = Monitored::Scalar<float>("offline_sumEt",0.0);
270  auto offline_Et_eff = Monitored::Scalar<float>("offline_Et_eff",0.0);
271  auto offline_NoMu_Ex = Monitored::Scalar<float>("offline_NoMu_Ex",0.0);
272  auto offline_NoMu_Ey = Monitored::Scalar<float>("offline_NoMu_Ey",0.0);
273  auto offline_NoMu_Et = Monitored::Scalar<float>("offline_NoMu_Et",0.0);
274  auto offline_NoMu_sumEt = Monitored::Scalar<float>("offline_NoMu_sumEt",0.0);
275  auto offline_NoMu_Et_eff = Monitored::Scalar<float>("offline_NoMu_Et_eff",0.0);
276 
277  auto HLT_MET_status = Monitored::Scalar<int>("HLT_MET_status",0.0);
278  auto MET_status = Monitored::Scalar<float>("MET_status",0.0);
279  auto HLT_MET_component = Monitored::Scalar<int>("HLT_MET_component",0.0);
280  auto component_Et = Monitored::Scalar<float>("component_Et",0.0);
281  auto component = Monitored::Scalar<int>("component",0.0);
282  auto component_status = Monitored::Scalar<int>("component_status",0.0);
283  auto component_status_weight = Monitored::Scalar<int>("component_status_weight",0.0);
284 
285  // constant floor for log plots
286  double epsilon = 1.189;
287 
288  // for histogram filling
289  // Fill. First argument is the tool (GMT) name as defined in the py file,
290  // all others are the variables to be saved.
291  auto tool = getGroup("TrigMETMonitor");
292 
293  // access pileup <mu>
294  act_IPBC = eventInfo->actualInteractionsPerCrossing();
295 
296  // access lepton values
297  // access events with electron passing primary single electron chain
298  bool passedPrimaryEl = false;
299  for (const std::string& chain : m_hltChainEl){
300  if(getTrigDecisionTool()->isPassed(chain)){
301  passedPrimaryEl = true;
302  break;
303  }
304  }
305  if ( hlt_electron_cont.isValid() && passedPrimaryEl ){
306  hlt_el_mult = hlt_electron_cont->size();
307  fill(tool,hlt_el_mult);
308  if( hlt_electron_cont->size() > 0 ) {
309  for (auto Electron: *hlt_electron_cont) {
310  hlt_el_pt = Electron->pt()/Gaudi::Units::GeV;
311  fill(tool, hlt_el_pt);
312  }
313  }
314  }
315 
316  // access events with muon passing primary single muon chain
317  bool passedPrimaryMu = false;
318  for (const std::string& chain : m_hltChainMu){
319  if(getTrigDecisionTool()->isPassed(chain)){
320  passedPrimaryMu = true;
321  break;
322  }
323  }
324  if( hlt_muon_cont.isValid() &&passedPrimaryMu ){
325  hlt_mu_mult = hlt_muon_cont->size();
326  fill(tool,hlt_mu_mult);
327  if ( hlt_muon_cont->size() > 0 ){
328  for(auto Muon : *hlt_muon_cont){
329  hlt_mu_pt = Muon->pt()/Gaudi::Units::GeV;
330  fill(tool, hlt_mu_pt);
331  }
332  }
333  }
334 
335  // access topoclusters container
336  if(hlt_topoclusters_cont.isValid() && hlt_topoclusters_cont->size() > 0){
337  hlt_topoclusters_mult = hlt_topoclusters_cont->size();
338  for(auto topoclusters : *hlt_topoclusters_cont){
339  hlt_topoclusters_pt = topoclusters->pt()/Gaudi::Units::GeV;
340  if(hlt_topoclusters_pt > 0){
341  fill(tool, hlt_topoclusters_pt);
342  }
343  }
344 
345  if(hlt_topoclusters_mult > 0){
346  fill(tool, hlt_topoclusters_mult);
347  }
348  }
349 
350  // access tracks container
351  if( hlt_tracks_cont.isValid() && hlt_tracks_cont->size() > 0){
352  hlt_tracks_mult = hlt_tracks_cont->size();
353  float scalarSumPt = 0.0;
354  float scalarSumPx = 0.0;
355  float scalarSumPy = 0.0;
356  for(auto tracks : *hlt_tracks_cont){
357  float i_track_pt = tracks->pt()/Gaudi::Units::GeV;
358  hlt_tracks_pt = i_track_pt;
359  scalarSumPt += i_track_pt;
360  scalarSumPx += (tracks->p4().Px());
361  scalarSumPy += (tracks->p4().Py());
362 
363  if(hlt_tracks_pt > hlt_tracks_leading_pt){
364  hlt_tracks_leading_pt = i_track_pt;
365  }
366 
367  if(hlt_tracks_pt > 0){
368  fill(tool, hlt_tracks_pt);
369  }
370 
371  if(hlt_tracks_pt > 3){
372  hlt_tracks_eta = (tracks->eta());
373  hlt_tracks_phi = (tracks->phi());
374  fill(tool, hlt_tracks_eta, hlt_tracks_phi);
375  }
376  }
377 
378  hlt_tracks_vec_sumPt = std::sqrt(scalarSumPx*scalarSumPx + scalarSumPy*scalarSumPy)/Gaudi::Units::GeV;
379  hlt_tracks_sca_sumPt = scalarSumPt;
380 
381  fill(tool, hlt_tracks_mult, hlt_tracks_leading_pt, hlt_tracks_vec_sumPt, hlt_tracks_sca_sumPt);
382  }
383 
384  // access vertex container
385  if(hlt_vertex_cont.isValid() && hlt_vertex_cont->size() > 0){
386  hlt_vertex_mult = hlt_vertex_cont->size();
387  hlt_vertex_mult_mu = hlt_vertex_cont->size();
388  const xAOD::Vertex_v1* hlt_vertex = nullptr;
389  for(auto vertex : *hlt_vertex_cont){
390  if(vertex->vertexType() == xAOD::VxType::VertexType::PriVtx){
391  hlt_vertex = vertex;
392  break;
393  }
394  }
395 
396  if(hlt_vertex){
397  hlt_vertex_z = hlt_vertex->z();
398  fill(tool, hlt_vertex_z);
399 
400  if(offline_vertex_cont.isValid() && offline_vertex_cont->size() > 0){
401  const xAOD::Vertex_v1* offline_vertex = nullptr;
402  for(auto vertex : *offline_vertex_cont){
403  if(vertex->vertexType() == xAOD::VxType::VertexType::PriVtx){
404  offline_vertex = vertex;
405  break;
406  }
407  }
408 
409  if(offline_vertex){
410  hlt_vertex_z_diff = hlt_vertex_z - offline_vertex->z();
411  fill(tool, hlt_vertex_z_diff);
412  }
413  }
414  }
415  }else{
416  hlt_vertex_mult = -1;
417  hlt_vertex_mult_mu = 1;
418  act_IPBC = -1.;
419  }
420  fill(tool, hlt_vertex_mult);
421  fill(tool, act_IPBC, hlt_vertex_mult_mu);
422 
423  // access offline MET values
424  const xAOD::MissingET *finalTrkMET = 0;
425  const xAOD::MissingET *muonsMET = 0;
426  if ( offline_met_cont.isValid() && offline_met_cont->size() > 0 ) {
427  finalTrkMET = ((*offline_met_cont)["FinalTrk"]);
428  muonsMET = ((*offline_met_cont)["Muons"]);
429 
430  if(finalTrkMET) {
431  offline_Ex = - finalTrkMET->mpx()/Gaudi::Units::GeV;
432  offline_Ey = - finalTrkMET->mpy()/Gaudi::Units::GeV;
433  offline_sumEt = finalTrkMET->sumet()/Gaudi::Units::GeV;
434  offline_Et = std::sqrt(offline_Ex*offline_Ex + offline_Ey*offline_Ey);
435  offline_Et_eff = std::sqrt(offline_Ex*offline_Ex + offline_Ey*offline_Ey);
436  fill(tool,offline_Ex,offline_Ey,offline_Et,offline_sumEt);
437 
438  if(muonsMET){
439  xAOD::MissingET finalTrkNoMuMET = *finalTrkMET - *muonsMET;
440  offline_NoMu_Ex = - finalTrkNoMuMET.mpx()/Gaudi::Units::GeV;
441  offline_NoMu_Ey = - finalTrkNoMuMET.mpy()/Gaudi::Units::GeV;
442  offline_NoMu_sumEt = finalTrkNoMuMET.sumet()/Gaudi::Units::GeV;
443  offline_NoMu_Et = std::sqrt(offline_NoMu_Ex*offline_NoMu_Ex + offline_NoMu_Ey*offline_NoMu_Ey);
444  offline_NoMu_Et_eff = std::sqrt(offline_NoMu_Ex*offline_NoMu_Ex + offline_NoMu_Ey*offline_NoMu_Ey);
445  fill(tool,offline_NoMu_Ex,offline_NoMu_Ey,offline_NoMu_Et,offline_NoMu_sumEt);
446  }
447  }
448  }
449 
450  // access L1 MET values
451  for (const std::string& alg : m_algsL1) {
453  if (alg == "roi" && l1_roi_cont.isValid()) {
454  l1_met_cont = l1_roi_cont;
455  }
456 
457  if ( l1_met_cont.isValid() ) {
458  if ((l1_met_cont->energyX())>-9e12 && (l1_met_cont->energyX())<9e12 && (l1_met_cont->energyY())>-9e12 && (l1_met_cont->energyY())<9e12) {
459  float L1_met_Ex = - l1_met_cont->energyX()/Gaudi::Units::GeV;
460  float L1_met_Ey = - l1_met_cont->energyY()/Gaudi::Units::GeV;
461  float L1_met_Et = std::sqrt(L1_met_Ex*L1_met_Ex + L1_met_Ey*L1_met_Ey);
462  float L1_met_sumEt = l1_met_cont->energyT()/Gaudi::Units::GeV;
463  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
464  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
465  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
466  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
467  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
468  float L1_met_phi = v.Phi();
469 
470  auto L1_Ex = Monitored::Scalar<float>("L1_"+alg+"_Ex", static_cast<float>(L1_met_Ex));
471  auto L1_Ey = Monitored::Scalar<float>("L1_"+alg+"_Ey", static_cast<float>(L1_met_Ey));
472  auto L1_Et = Monitored::Scalar<float>("L1_"+alg+"_Et", static_cast<float>(L1_met_Et));
473  auto L1_sumEt = Monitored::Scalar<float>("L1_"+alg+"_sumEt", static_cast<float>(L1_met_sumEt));
474  auto L1_Ex_log = Monitored::Scalar<float>("L1_"+alg+"_Ex_log", static_cast<float>(L1_met_Ex_log));
475  auto L1_Ey_log = Monitored::Scalar<float>("L1_"+alg+"_Ey_log", static_cast<float>(L1_met_Ey_log));
476  auto L1_Et_log = Monitored::Scalar<float>("L1_"+alg+"_Et_log", static_cast<float>(L1_met_Et_log));
477  auto L1_sumEt_log = Monitored::Scalar<float>("L1_"+alg+"_sumEt_log", static_cast<float>(L1_met_sumEt_log));
478  auto L1_phi = Monitored::Scalar<float>("L1_"+alg+"_phi", static_cast<float>(L1_met_phi));
479  fill(tool, L1_Ex, L1_Ey, L1_Et, L1_sumEt,
480  L1_Ex_log, L1_Ey_log, L1_Et_log, L1_sumEt_log, L1_phi);
481  }
482  }
483  }
484 
485  // access L1 jFex MET values
486  if (l1_jFexMet_cont.isValid() && l1_jFexMet_cont->size() > 0) {
487  float L1_met_Ex = 0;
488  float L1_met_Ey = 0;
489  for (const auto l1_jmet: *l1_jFexMet_cont) {
490  L1_met_Ex += l1_jmet->Ex()/Gaudi::Units::GeV;
491  L1_met_Ey += l1_jmet->Ey()/Gaudi::Units::GeV;
492  }
493  float L1_met_Et = std::sqrt(L1_met_Ex*L1_met_Ex + L1_met_Ey*L1_met_Ey);
494  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
495  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
496  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
497  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
498  float L1_met_phi = v.Phi();
499  auto L1_Ex = Monitored::Scalar<float>("L1_jFex_Ex", static_cast<float>(L1_met_Ex));
500  auto L1_Ey = Monitored::Scalar<float>("L1_jFex_Ey", static_cast<float>(L1_met_Ey));
501  auto L1_Et = Monitored::Scalar<float>("L1_jFex_Et", static_cast<float>(L1_met_Et));
502  auto L1_Ex_log = Monitored::Scalar<float>("L1_jFex_Ex_log", static_cast<float>(L1_met_Ex_log));
503  auto L1_Ey_log = Monitored::Scalar<float>("L1_jFex_Ey_log", static_cast<float>(L1_met_Ey_log));
504  auto L1_Et_log = Monitored::Scalar<float>("L1_jFex_Et_log", static_cast<float>(L1_met_Et_log));
505  auto L1_phi = Monitored::Scalar<float>("L1_jFex_phi", static_cast<float>(L1_met_phi));
506  fill(tool, L1_Ex, L1_Ey, L1_Et, L1_Ex_log, L1_Ey_log, L1_Et_log, L1_phi);
507  }
508  if (l1_jFexSumEt_cont.isValid() && l1_jFexSumEt_cont->size() > 0) {
509  float L1_met_sumEt = 0;
510  for (const auto l1_jsumEt: *l1_jFexSumEt_cont) {
511  L1_met_sumEt += l1_jsumEt->Et_lower()/Gaudi::Units::GeV + l1_jsumEt->Et_upper()/Gaudi::Units::GeV;
512  }
513  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
514  auto L1_sumEt = Monitored::Scalar<float>("L1_jFex_sumEt", static_cast<float>(L1_met_sumEt));
515  auto L1_sumEt_log = Monitored::Scalar<float>("L1_jFex_sumEt_log", static_cast<float>(L1_met_sumEt_log));
516  fill(tool, L1_sumEt, L1_sumEt_log);
517  }
518 
519  // define L1 gFex MET object
520  const xAOD::gFexGlobalRoI *l1_gmet;
521 
522  // access L1 gFex MET values
523  // This will be properly implemented when it's ready
524  if (l1_gFexJwojScalar_cont.isValid() && l1_gFexJwojScalar_cont->size() > 0) {
525  l1_gmet = l1_gFexJwojScalar_cont->at(0);
526  float L1_met_Et = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
527  float L1_met_sumEt = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
528  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
529  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
530  auto L1_Et = Monitored::Scalar<float>("L1_gFexJwoj_Et", static_cast<float>(L1_met_Et));
531  auto L1_Et_log = Monitored::Scalar<float>("L1_gFexJwoj_Et_log", static_cast<float>(L1_met_Et_log));
532  auto L1_sumEt = Monitored::Scalar<float>("L1_gFexJwoj_sumEt", static_cast<float>(L1_met_sumEt));
533  auto L1_sumEt_log = Monitored::Scalar<float>("L1_gFexJwoj_sumEt_log", static_cast<float>(L1_met_sumEt_log));
534  fill(tool, L1_Et, L1_Et_log, L1_sumEt, L1_sumEt_log);
535  }
536 
537  if (l1_gFexJwojMETComponents_cont.isValid() && l1_gFexJwojMETComponents_cont->size() > 0) {
538  l1_gmet = l1_gFexJwojMETComponents_cont->at(0);
539  float L1_met_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
540  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
541  float L1_met_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
542  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
543  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
544  float L1_met_phi = v.Phi();
545  auto L1_Ex = Monitored::Scalar<float>("L1_gFexJwoj_Ex", static_cast<float>(L1_met_Ex));
546  auto L1_Ey = Monitored::Scalar<float>("L1_gFexJwoj_Ey", static_cast<float>(L1_met_Ey));
547  auto L1_Ex_log = Monitored::Scalar<float>("L1_gFexJwoj_Ex_log", static_cast<float>(L1_met_Ex_log));
548  auto L1_Ey_log = Monitored::Scalar<float>("L1_gFexJwoj_Ey_log", static_cast<float>(L1_met_Ey_log));
549  auto L1_phi = Monitored::Scalar<float>("L1_gFexJwoj_phi", static_cast<float>(L1_met_phi));
550  fill(tool, L1_Ex, L1_Ey, L1_Ex_log, L1_Ey_log, L1_phi);
551  }
552 
553  if (l1_gFexJwojMHTComponents_cont.isValid() && l1_gFexJwojMHTComponents_cont->size() > 0) {
554  l1_gmet = l1_gFexJwojMHTComponents_cont->at(0);
555  float L1_met_HT_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
556  float L1_met_HT_Ex_log = signed_log(L1_met_HT_Ex, epsilon);
557  float L1_met_HT_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
558  float L1_met_HT_Ey_log = signed_log(L1_met_HT_Ey, epsilon);
559  TVector3 v(L1_met_HT_Ex, L1_met_HT_Ey, 0.0);
560  float L1_met_HT_phi = v.Phi();
561  auto L1_HT_Ex = Monitored::Scalar<float>("L1_gFexJwoj_HT_Ex", static_cast<float>(L1_met_HT_Ex));
562  auto L1_HT_Ey = Monitored::Scalar<float>("L1_gFexJwoj_HT_Ey", static_cast<float>(L1_met_HT_Ey));
563  auto L1_HT_Ex_log = Monitored::Scalar<float>("L1_gFexJwoj_HT_Ex_log", static_cast<float>(L1_met_HT_Ex_log));
564  auto L1_HT_Ey_log = Monitored::Scalar<float>("L1_gFexJwoj_HT_Ey_log", static_cast<float>(L1_met_HT_Ey_log));
565  auto L1_HT_phi = Monitored::Scalar<float>("L1_gFexJwoj_HT_phi", static_cast<float>(L1_met_HT_phi));
566  fill(tool, L1_HT_Ex, L1_HT_Ey, L1_HT_Ex_log, L1_HT_Ey_log, L1_HT_phi);
567  }
568 
569  if (l1_gFexJwojMSTComponents_cont.isValid() && l1_gFexJwojMSTComponents_cont->size() > 0) {
570  l1_gmet = l1_gFexJwojMSTComponents_cont->at(0);
571  float L1_met_ST_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
572  float L1_met_ST_Ex_log = signed_log(L1_met_ST_Ex, epsilon);
573  float L1_met_ST_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
574  float L1_met_ST_Ey_log = signed_log(L1_met_ST_Ey, epsilon);
575  TVector3 v(L1_met_ST_Ex, L1_met_ST_Ey, 0.0);
576  float L1_met_ST_phi = v.Phi();
577  auto L1_ST_Ex = Monitored::Scalar<float>("L1_gFexJwoj_ST_Ex", static_cast<float>(L1_met_ST_Ex));
578  auto L1_ST_Ey = Monitored::Scalar<float>("L1_gFexJwoj_ST_Ey", static_cast<float>(L1_met_ST_Ey));
579  auto L1_ST_Ex_log = Monitored::Scalar<float>("L1_gFexJwoj_ST_Ex_log", static_cast<float>(L1_met_ST_Ex_log));
580  auto L1_ST_Ey_log = Monitored::Scalar<float>("L1_gFexJwoj_ST_Ey_log", static_cast<float>(L1_met_ST_Ey_log));
581  auto L1_ST_phi = Monitored::Scalar<float>("L1_gFexJwoj_ST_phi", static_cast<float>(L1_met_ST_phi));
582  fill(tool, L1_ST_Ex, L1_ST_Ey, L1_ST_Ex_log, L1_ST_Ey_log, L1_ST_phi);
583  }
584 
585  if (l1_gFexNCMETScalar_cont.isValid() && l1_gFexNCMETScalar_cont->size() > 0) {
586  l1_gmet = l1_gFexNCMETScalar_cont->at(0);
587  float L1_met_Et = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
588  float L1_met_sumEt = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
589  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
590  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
591  auto L1_Et = Monitored::Scalar<float>("L1_gFexNC_Et", static_cast<float>(L1_met_Et));
592  auto L1_Et_log = Monitored::Scalar<float>("L1_gFexNC_Et_log", static_cast<float>(L1_met_Et_log));
593  auto L1_sumEt = Monitored::Scalar<float>("L1_gFexNC_sumEt", static_cast<float>(L1_met_sumEt));
594  auto L1_sumEt_log = Monitored::Scalar<float>("L1_gFexNC_sumEt_log", static_cast<float>(L1_met_sumEt_log));
595  fill(tool, L1_Et, L1_Et_log, L1_sumEt, L1_sumEt_log);
596  }
597 
598  if (l1_gFexNCMETComponents_cont.isValid() && l1_gFexNCMETComponents_cont->size() > 0) {
599  l1_gmet = l1_gFexNCMETComponents_cont->at(0);
600  float L1_met_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
601  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
602  float L1_met_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
603  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
604  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
605  float L1_met_phi = v.Phi();
606  auto L1_Ex = Monitored::Scalar<float>("L1_gFexNC_Ex", static_cast<float>(L1_met_Ex));
607  auto L1_Ey = Monitored::Scalar<float>("L1_gFexNC_Ey", static_cast<float>(L1_met_Ey));
608  auto L1_Ex_log = Monitored::Scalar<float>("L1_gFexNC_Ex_log", static_cast<float>(L1_met_Ex_log));
609  auto L1_Ey_log = Monitored::Scalar<float>("L1_gFexNC_Ey_log", static_cast<float>(L1_met_Ey_log));
610  auto L1_phi = Monitored::Scalar<float>("L1_gFexNC_phi", static_cast<float>(L1_met_phi));
611  fill(tool, L1_Ex, L1_Ey, L1_Ex_log, L1_Ey_log, L1_phi);
612  }
613 
614  if (l1_gFexRhoMETScalar_cont.isValid() && l1_gFexRhoMETScalar_cont->size() > 0) {
615  l1_gmet = l1_gFexRhoMETScalar_cont->at(0);
616  float L1_met_Et = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
617  float L1_met_sumEt = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
618  float L1_met_Et_log = signed_log(L1_met_Et, epsilon);
619  float L1_met_sumEt_log = signed_log(L1_met_sumEt, epsilon);
620  auto L1_Et = Monitored::Scalar<float>("L1_gFexRho_Et", static_cast<float>(L1_met_Et));
621  auto L1_Et_log = Monitored::Scalar<float>("L1_gFexRho_Et_log", static_cast<float>(L1_met_Et_log));
622  auto L1_sumEt = Monitored::Scalar<float>("L1_gFexRho_sumEt", static_cast<float>(L1_met_sumEt));
623  auto L1_sumEt_log = Monitored::Scalar<float>("L1_gFexRho_sumEt_log", static_cast<float>(L1_met_sumEt_log));
624  fill(tool, L1_Et, L1_Et_log, L1_sumEt, L1_sumEt_log);
625  }
626 
627  if (l1_gFexRhoMETComponents_cont.isValid() && l1_gFexRhoMETComponents_cont->size() > 0) {
628  l1_gmet = l1_gFexRhoMETComponents_cont->at(0);
629  float L1_met_Ex = l1_gmet->METquantityOne()/Gaudi::Units::GeV;
630  float L1_met_Ex_log = signed_log(L1_met_Ex, epsilon);
631  float L1_met_Ey = l1_gmet->METquantityTwo()/Gaudi::Units::GeV;
632  float L1_met_Ey_log = signed_log(L1_met_Ey, epsilon);
633  TVector3 v(L1_met_Ex, L1_met_Ey, 0.0);
634  float L1_met_phi = v.Phi();
635  auto L1_Ex = Monitored::Scalar<float>("L1_gFexRho_Ex", static_cast<float>(L1_met_Ex));
636  auto L1_Ey = Monitored::Scalar<float>("L1_gFexRho_Ey", static_cast<float>(L1_met_Ey));
637  auto L1_Ex_log = Monitored::Scalar<float>("L1_gFexRho_Ex_log", static_cast<float>(L1_met_Ex_log));
638  auto L1_Ey_log = Monitored::Scalar<float>("L1_gFexRho_Ey_log", static_cast<float>(L1_met_Ey_log));
639  auto L1_phi = Monitored::Scalar<float>("L1_gFexRho_phi", static_cast<float>(L1_met_phi));
640  fill(tool, L1_Ex, L1_Ey, L1_Ex_log, L1_Ey_log, L1_phi);
641  }
642 
643  // define TrigMissingET object
644  const xAOD::TrigMissingET *hlt_met = 0;
645 
646  // status, component from HLT cell
647  int nComponent = m_compNames.size();
648  int nStatus = m_bitNames.size();
649  if ( hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0 ) {
650  hlt_met = hlt_cell_met_cont->at(0);
651  for (int j=0; j<nStatus; ++j) { //status loop
652  unsigned mask = (1u<<j);
653  if (hlt_met->flag() & mask) {
654  MET_status = 1.;
655  } else {
656  MET_status = 0;
657  }
658  auto mon1 = Monitored::Scalar<std::string>( "HLT_MET_status",m_bitNames[j]);
659  fill(tool,mon1,MET_status);
660  }
661 
662  for (int i=0; i<nComponent; ++i) { //component loop
663  float ex = hlt_met->exComponent(i)/Gaudi::Units::GeV;
664  float ey = hlt_met->eyComponent(i)/Gaudi::Units::GeV;
665  component_Et = sqrt(ex*ex+ey*ey);
666  auto mon2 = Monitored::Scalar<std::string>( "HLT_MET_component",m_compNames[i]);
667  fill(tool,mon2,component_Et);
668  }
669 
670  for (int i=0; i<nComponent; ++i) { //component loop
671  for (int j=0; j<nStatus; ++j) { //status loop
672  unsigned mask = (1u<<j);
673  if (hlt_met->statusComponent(i) & mask) {
674  component_status_weight = 1.;
675  } else {
676  component_status_weight = 0;
677  }
678  auto mon_bit = Monitored::Scalar<std::string>( "component_status",m_bitNames[j]);
679  auto mon_comp = Monitored::Scalar<std::string>( "component",m_compNames[i]);
680  fill(tool,mon_comp,mon_bit,component_status_weight);
681  }
682  }
683  }
684 
685  // get L1 MET for pre-selection
686  float L1_roiMet_Et = 0;
687  if ( l1_roi_cont.isValid() ) {
688  if ((l1_roi_cont->energyX())>-9e12 && (l1_roi_cont->energyX())<9e12 && (l1_roi_cont->energyY())>-9e12 && (l1_roi_cont->energyY())<9e12) {
689  float Ex = - l1_roi_cont->energyX()/Gaudi::Units::GeV;
690  float Ey = - l1_roi_cont->energyY()/Gaudi::Units::GeV;
691  L1_roiMet_Et = std::sqrt(Ex*Ex + Ey*Ey);
692  }
693  }
694  float L1_jFexMet_Et = 0;
695  if (l1_jFexMet_cont.isValid() && l1_jFexMet_cont->size() > 0) {
696  float L1_met_Ex = 0;
697  float L1_met_Ey = 0;
698  for (const auto l1_jmet: *l1_jFexMet_cont) {
699  L1_met_Ex += l1_jmet->Ex()/Gaudi::Units::GeV;
700  L1_met_Ey += l1_jmet->Ey()/Gaudi::Units::GeV;
701  }
702  L1_jFexMet_Et = std::sqrt(L1_met_Ex*L1_met_Ex + L1_met_Ey*L1_met_Ey);
703  }
704  float L1_gFexJWOJMet_Et = 0;
705 
706  float L1_PreSelMet_Et = L1_roiMet_Et;
707  if (m_L1MetAlg == 1) L1_PreSelMet_Et = L1_jFexMet_Et;
708  if (m_L1MetAlg == 2) L1_PreSelMet_Et = L1_gFexJWOJMet_Et;
709 
710  // access HLT MET values
711  for (const std::string& alg : m_algsHLT) {
712  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
713  hlt_met = hlt_cell_met_cont->at(0);
714  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
715  hlt_met = hlt_mht_met_cont->at(0);
716  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
717  hlt_met = hlt_tc_met_cont->at(0);
718  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
719  hlt_met = hlt_tc_em_met_cont->at(0);
720  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
721  hlt_met = hlt_tcpufit_met_cont->at(0);
722  } else if (alg == "tcpufit_sig30" && hlt_tcpufit_sig30_met_cont.isValid() && hlt_tcpufit_sig30_met_cont->size() > 0) {
723  hlt_met = hlt_tcpufit_sig30_met_cont->at(0);
724  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
725  hlt_met = hlt_trkmht_met_cont->at(0);
726  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
727  hlt_met = hlt_pfsum_met_cont->at(0);
728  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
729  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
730  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
731  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
732  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
733  hlt_met = hlt_pfopufit_met_cont->at(0);
734  } else if (alg == "pfopufit_sig30" && hlt_pfopufit_sig30_met_cont.isValid() && hlt_pfopufit_sig30_met_cont->size() > 0) {
735  hlt_met = hlt_pfopufit_sig30_met_cont->at(0);
736  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
737  hlt_met = hlt_cvfpufit_met_cont->at(0);
738  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
739  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
740  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
741  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
742  } else if (alg == "met_nn" && hlt_met_nn_cont.isValid() && hlt_met_nn_cont->size() > 0) {
743  hlt_met = hlt_met_nn_cont->at(0);
744  } else {
745  hlt_met = 0;
746  }
747 
748  if ( hlt_met ) {
749  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
750  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
751  float hlt_Ez = hlt_met->ez()/Gaudi::Units::GeV;
752  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
753  float hlt_sumEt = hlt_met->sumEt()/Gaudi::Units::GeV;
754  float hlt_Ex_log = signed_log(hlt_Ex, epsilon);
755  float hlt_Ey_log = signed_log(hlt_Ey, epsilon);
756  float hlt_Et_log = signed_log(hlt_Et, epsilon);
757  float hlt_sumEt_log = signed_log(hlt_sumEt, epsilon);
758  TVector3 v(hlt_Ex, hlt_Ey, hlt_Ez);
759  float hlt_eta = v.Eta();
760  float hlt_phi = v.Phi();
761 
762  auto met_Ex = Monitored::Scalar<float>(alg+"_Ex", static_cast<float>(hlt_Ex));
763  auto met_Ey = Monitored::Scalar<float>(alg+"_Ey", static_cast<float>(hlt_Ey));
764  auto met_Et = Monitored::Scalar<float>(alg+"_Et", static_cast<float>(hlt_Et));
765  auto met_sumEt = Monitored::Scalar<float>(alg+"_sumEt", static_cast<float>(hlt_sumEt));
766  auto met_Ex_log = Monitored::Scalar<float>(alg+"_Ex_log", static_cast<float>(hlt_Ex_log));
767  auto met_Ey_log = Monitored::Scalar<float>(alg+"_Ey_log", static_cast<float>(hlt_Ey_log));
768  auto met_Et_log = Monitored::Scalar<float>(alg+"_Et_log", static_cast<float>(hlt_Et_log));
769  auto met_sumEt_log = Monitored::Scalar<float>(alg+"_sumEt_log", static_cast<float>(hlt_sumEt_log));
770  auto met_eta = Monitored::Scalar<float>(alg+"_eta", static_cast<float>(hlt_eta));
771  auto met_phi = Monitored::Scalar<float>(alg+"_phi", static_cast<float>(hlt_phi));
772  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt,
773  met_Ex_log,met_Ey_log,met_Et_log,met_sumEt_log,
774  met_eta,met_phi);
775 
776  }
777  }
778 
779  // access HLT pre-selection MET values
780  for (const std::string& alg : m_algsHLTPreSel) {
781  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
782  hlt_met = hlt_cell_met_cont->at(0);
783  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
784  hlt_met = hlt_mht_met_cont->at(0);
785  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
786  hlt_met = hlt_tc_met_cont->at(0);
787  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
788  hlt_met = hlt_tc_em_met_cont->at(0);
789  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
790  hlt_met = hlt_tcpufit_met_cont->at(0);
791  } else if (alg == "tcpufit_sig30" && hlt_tcpufit_sig30_met_cont.isValid() && hlt_tcpufit_sig30_met_cont->size() > 0) {
792  hlt_met = hlt_tcpufit_sig30_met_cont->at(0);
793  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
794  hlt_met = hlt_trkmht_met_cont->at(0);
795  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
796  hlt_met = hlt_pfsum_met_cont->at(0);
797  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
798  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
799  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
800  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
801  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
802  hlt_met = hlt_pfopufit_met_cont->at(0);
803  } else if (alg == "pfopufit_sig30" && hlt_pfopufit_sig30_met_cont.isValid() && hlt_pfopufit_sig30_met_cont->size() > 0) {
804  hlt_met = hlt_pfopufit_sig30_met_cont->at(0);
805  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
806  hlt_met = hlt_cvfpufit_met_cont->at(0);
807  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
808  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
809  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
810  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
811  } else if (alg == "met_nn" && hlt_met_nn_cont.isValid() && hlt_met_nn_cont->size() > 0) {
812  hlt_met = hlt_met_nn_cont->at(0);
813  } else {
814  hlt_met = 0;
815  }
816 
817  if ( hlt_met ) {
818  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
819  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
820  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
821  if (L1_PreSelMet_Et > m_L1MetCut && !std::isnan(hlt_Et)) {
822  auto met_presel_Et = Monitored::Scalar<float>(alg+"_presel_Et", hlt_Et);
823  fill(tool,met_presel_Et);
824  }
825  }
826  }
827 
828  for (const std::string& alg : m_LArNoiseBurstVetoAlgs) {
829  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
830  hlt_met = hlt_cell_met_cont->at(0);
831  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
832  hlt_met = hlt_mht_met_cont->at(0);
833  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
834  hlt_met = hlt_tc_met_cont->at(0);
835  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
836  hlt_met = hlt_tc_em_met_cont->at(0);
837  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
838  hlt_met = hlt_tcpufit_met_cont->at(0);
839  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
840  hlt_met = hlt_trkmht_met_cont->at(0);
841  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
842  hlt_met = hlt_pfsum_met_cont->at(0);
843  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
844  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
845  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
846  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
847  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
848  hlt_met = hlt_pfopufit_met_cont->at(0);
849  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
850  hlt_met = hlt_cvfpufit_met_cont->at(0);
851  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
852  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
853  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
854  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
855  } else {
856  hlt_met = 0;
857  }
858 
859  if ( hlt_met ) {
860  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
861  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
862  float hlt_Ez = hlt_met->ez()/Gaudi::Units::GeV;
863  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
864  float hlt_sumEt = hlt_met->sumEt()/Gaudi::Units::GeV;
865  float hlt_Ex_log = signed_log(hlt_Ex, epsilon);
866  float hlt_Ey_log = signed_log(hlt_Ey, epsilon);
867  float hlt_Et_log = signed_log(hlt_Et, epsilon);
868  float hlt_sumEt_log = signed_log(hlt_sumEt, epsilon);
869  TVector3 v(hlt_Ex, hlt_Ey, hlt_Ez);
870  float hlt_eta = v.Eta();
871  float hlt_phi = v.Phi();
872 
873 
874  // LAr noiseburst Veto
875  bool LArNoiseBurst = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO);
876  if (!LArNoiseBurst){
877  auto met_Ex = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Ex", static_cast<float>(hlt_Ex));
878  auto met_Ey = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Ey", static_cast<float>(hlt_Ey));
879  auto met_Et = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Et", static_cast<float>(hlt_Et));
880  auto met_sumEt = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_sumEt", static_cast<float>(hlt_sumEt));
881  auto met_Ex_log = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Ex_log", static_cast<float>(hlt_Ex_log));
882  auto met_Ey_log = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Ey_log", static_cast<float>(hlt_Ey_log));
883  auto met_Et_log = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_Et_log", static_cast<float>(hlt_Et_log));
884  auto met_sumEt_log = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_sumEt_log", static_cast<float>(hlt_sumEt_log));
885  auto met_phi = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_phi", static_cast<float>(hlt_phi));
886  auto met_eta = Monitored::Scalar<float>(alg+"_LArNoiseBurstVeto_eta", static_cast<float>(hlt_eta));
887  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt,
888  met_Ex_log,met_Ey_log,met_Et_log,met_sumEt_log,
889  met_eta,met_phi);
890  }
891  }
892  }
893 
894 
895  for (const std::string& alg : m_signalLepAlgs) {
896  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
897  hlt_met = hlt_cell_met_cont->at(0);
898  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
899  hlt_met = hlt_mht_met_cont->at(0);
900  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
901  hlt_met = hlt_tc_met_cont->at(0);
902  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
903  hlt_met = hlt_tc_em_met_cont->at(0);
904  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
905  hlt_met = hlt_tcpufit_met_cont->at(0);
906  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
907  hlt_met = hlt_trkmht_met_cont->at(0);
908  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
909  hlt_met = hlt_pfsum_met_cont->at(0);
910  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
911  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
912  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
913  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
914  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
915  hlt_met = hlt_pfopufit_met_cont->at(0);
916  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
917  hlt_met = hlt_cvfpufit_met_cont->at(0);
918  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
919  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
920  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
921  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
922  } else {
923  hlt_met = 0;
924  }
925 
926  if ( hlt_met ) {
927  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
928  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
929  float hlt_Ez = hlt_met->ez()/Gaudi::Units::GeV;
930  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
931  float hlt_sumEt = hlt_met->sumEt()/Gaudi::Units::GeV;
932  float hlt_Ex_log = signed_log(hlt_Ex, epsilon);
933  float hlt_Ey_log = signed_log(hlt_Ey, epsilon);
934  float hlt_Et_log = signed_log(hlt_Et, epsilon);
935  float hlt_sumEt_log = signed_log(hlt_sumEt, epsilon);
936  TVector3 v(hlt_Ex, hlt_Ey, hlt_Ez);
937  float hlt_eta = v.Eta();
938  float hlt_phi = v.Phi();
939 
940 // access events with electron passing primary single electron chain
941  if(passedPrimaryEl){
942  auto met_Ex = Monitored::Scalar<float>(alg+"_SigEl_Ex", static_cast<float>(hlt_Ex));
943  auto met_Ey = Monitored::Scalar<float>(alg+"_SigEl_Ey", static_cast<float>(hlt_Ey));
944  auto met_Et = Monitored::Scalar<float>(alg+"_SigEl_Et", static_cast<float>(hlt_Et));
945  auto met_sumEt = Monitored::Scalar<float>(alg+"_SigEl_sumEt", static_cast<float>(hlt_sumEt));
946  auto met_Ex_log = Monitored::Scalar<float>(alg+"_SigEl_Ex_log", static_cast<float>(hlt_Ex_log));
947  auto met_Ey_log = Monitored::Scalar<float>(alg+"_SigEl_Ey_log", static_cast<float>(hlt_Ey_log));
948  auto met_Et_log = Monitored::Scalar<float>(alg+"_SigEl_Et_log", static_cast<float>(hlt_Et_log));
949  auto met_sumEt_log = Monitored::Scalar<float>(alg+"_SigEl_sumEt_log", static_cast<float>(hlt_sumEt_log));
950  auto met_eta = Monitored::Scalar<float>(alg+"_SigEl_eta", static_cast<float>(hlt_eta));
951  auto met_phi = Monitored::Scalar<float>(alg+"_SigEl_phi", static_cast<float>(hlt_phi));
952  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt,
953  met_Ex_log,met_Ey_log,met_Et_log,met_sumEt_log,
954  met_eta,met_phi);
955  }
956 
957 // access events with muon passing primary single muon chain
958  if(passedPrimaryMu){
959  auto met_Ex = Monitored::Scalar<float>(alg+"_SigMu_Ex", static_cast<float>(hlt_Ex));
960  auto met_Ey = Monitored::Scalar<float>(alg+"_SigMu_Ey", static_cast<float>(hlt_Ey));
961  auto met_Et = Monitored::Scalar<float>(alg+"_SigMu_Et", static_cast<float>(hlt_Et));
962  auto met_sumEt = Monitored::Scalar<float>(alg+"_SigMu_sumEt", static_cast<float>(hlt_sumEt));
963  auto met_Ex_log = Monitored::Scalar<float>(alg+"_SigMu_Ex_log", static_cast<float>(hlt_Ex_log));
964  auto met_Ey_log = Monitored::Scalar<float>(alg+"_SigMu_Ey_log", static_cast<float>(hlt_Ey_log));
965  auto met_Et_log = Monitored::Scalar<float>(alg+"_SigMu_Et_log", static_cast<float>(hlt_Et_log));
966  auto met_sumEt_log = Monitored::Scalar<float>(alg+"_SigMu_sumEt_log", static_cast<float>(hlt_sumEt_log));
967  auto met_eta = Monitored::Scalar<float>(alg+"_SigMu_eta", static_cast<float>(hlt_eta));
968  auto met_phi = Monitored::Scalar<float>(alg+"_SigMu_phi", static_cast<float>(hlt_phi));
969  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt,
970  met_Ex_log,met_Ey_log,met_Et_log,met_sumEt_log,
971  met_eta,met_phi);
972  }
973  }
974  }
975 
976  // access HLT MET Expert values
977  for (const std::string& alg : m_algsHLTExpert) {
978  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
979  hlt_met = hlt_cell_met_cont->at(0);
980  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
981  hlt_met = hlt_mht_met_cont->at(0);
982  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
983  hlt_met = hlt_tc_met_cont->at(0);
984  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
985  hlt_met = hlt_tc_em_met_cont->at(0);
986  } else if (alg == "tcpufit" && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0) {
987  hlt_met = hlt_tcpufit_met_cont->at(0);
988  } else if (alg == "tcpufit_sig30" && hlt_tcpufit_sig30_met_cont.isValid() && hlt_tcpufit_sig30_met_cont->size() > 0) {
989  hlt_met = hlt_tcpufit_sig30_met_cont->at(0);
990  } else if (alg == "trkmht" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
991  hlt_met = hlt_trkmht_met_cont->at(0);
992  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
993  hlt_met = hlt_pfsum_met_cont->at(0);
994  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
995  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
996  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
997  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
998  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
999  hlt_met = hlt_pfopufit_met_cont->at(0);
1000  } else if (alg == "pfopufit_sig30" && hlt_pfopufit_sig30_met_cont.isValid() && hlt_pfopufit_sig30_met_cont->size() > 0) {
1001  hlt_met = hlt_pfopufit_sig30_met_cont->at(0);
1002  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
1003  hlt_met = hlt_cvfpufit_met_cont->at(0);
1004  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
1005  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
1006  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
1007  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
1008  } else if (alg == "met_nn" && hlt_met_nn_cont.isValid() && hlt_met_nn_cont->size() > 0) {
1009  hlt_met = hlt_met_nn_cont->at(0);
1010  } else {
1011  hlt_met = 0;
1012  }
1013 
1014  if ( hlt_met ) {
1015  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
1016  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
1017  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
1018  float hlt_sumEt = hlt_met->sumEt()/Gaudi::Units::GeV;
1019  if (!std::isnan(hlt_Et)) {
1020  auto met_Ex = Monitored::Scalar<float>(alg+"_Ex", static_cast<float>(hlt_Ex));
1021  auto met_Ey = Monitored::Scalar<float>(alg+"_Ey", static_cast<float>(hlt_Ey));
1022  auto met_Et = Monitored::Scalar<float>(alg+"_Et", static_cast<float>(hlt_Et));
1023  auto met_sumEt = Monitored::Scalar<float>(alg+"_sumEt", static_cast<float>(hlt_sumEt));
1024  fill(tool,met_Ex,met_Ey,met_Et,met_sumEt);
1025  ATH_MSG_DEBUG(alg << ": hlt_Et = " << hlt_Et);
1026  if (L1_roiMet_Et > 50.) {
1027  auto met_presel_Et = Monitored::Scalar<float>(alg+"_presel_Et", static_cast<float>(hlt_Et));
1028  fill(tool,met_presel_Et);
1029  }
1030  }
1031  }
1032  }
1033 
1034  // Make 2D tcpufit MET distributions wrt track-based MET
1035  const xAOD::TrigMissingET *hlt_tcpufit_met = 0;
1036  for (const std::string& alg : m_algsMET2d_tcpufit) {
1037  if (alg == "cell" && hlt_cell_met_cont.isValid() && hlt_cell_met_cont->size() > 0) {
1038  hlt_met = hlt_cell_met_cont->at(0);
1039  } else if (alg == "mht" && hlt_mht_met_cont.isValid() && hlt_mht_met_cont->size() > 0) {
1040  hlt_met = hlt_mht_met_cont->at(0);
1041  } else if (alg == "tc" && hlt_tc_met_cont.isValid() && hlt_tc_met_cont->size() > 0) {
1042  hlt_met = hlt_tc_met_cont->at(0);
1043  } else if (alg == "tc_em" && hlt_tc_em_met_cont.isValid() && hlt_tc_em_met_cont->size() > 0) {
1044  hlt_met = hlt_tc_em_met_cont->at(0);
1045  } else if (alg == "trkmht_pf" && hlt_trkmht_met_cont.isValid() && hlt_trkmht_met_cont->size() > 0) {
1046  hlt_met = hlt_trkmht_met_cont->at(0);
1047  } else if (alg == "pfsum" && hlt_pfsum_met_cont.isValid() && hlt_pfsum_met_cont->size() > 0) {
1048  hlt_met = hlt_pfsum_met_cont->at(0);
1049  } else if (alg == "pfsum_cssk" && hlt_pfsum_cssk_met_cont.isValid() && hlt_pfsum_cssk_met_cont->size() > 0) {
1050  hlt_met = hlt_pfsum_cssk_met_cont->at(0);
1051  } else if (alg == "pfsum_vssk" && hlt_pfsum_vssk_met_cont.isValid() && hlt_pfsum_vssk_met_cont->size() > 0) {
1052  hlt_met = hlt_pfsum_vssk_met_cont->at(0);
1053  } else if (alg == "pfopufit" && hlt_pfopufit_met_cont.isValid() && hlt_pfopufit_met_cont->size() > 0) {
1054  hlt_met = hlt_pfopufit_met_cont->at(0);
1055  } else if (alg == "cvfpufit" && hlt_cvfpufit_met_cont.isValid() && hlt_cvfpufit_met_cont->size() > 0) {
1056  hlt_met = hlt_cvfpufit_met_cont->at(0);
1057  } else if (alg == "mhtpufit_pf" && hlt_mhtpufit_pf_met_cont.isValid() && hlt_mhtpufit_pf_met_cont->size() > 0) {
1058  hlt_met = hlt_mhtpufit_pf_met_cont->at(0);
1059  } else if (alg == "mhtpufit_em" && hlt_mhtpufit_em_met_cont.isValid() && hlt_mhtpufit_em_met_cont->size() > 0) {
1060  hlt_met = hlt_mhtpufit_em_met_cont->at(0);
1061  } else {
1062  hlt_met = 0;
1063  }
1064 
1065  if(hlt_met && hlt_tcpufit_met_cont.isValid() && hlt_tcpufit_met_cont->size() > 0){
1066  hlt_tcpufit_met = hlt_tcpufit_met_cont->at(0);
1067  float hlt_Ex = hlt_met->ex()/Gaudi::Units::GeV;
1068  float hlt_Ey = hlt_met->ey()/Gaudi::Units::GeV;
1069  float hlt_Et = std::sqrt(hlt_Ex*hlt_Ex + hlt_Ey*hlt_Ey);
1070  auto met_Et = Monitored::Scalar<float>(alg+"_2D_Et", static_cast<float>(hlt_Et));
1071 
1072  float hlt_tcpufit_Ex = hlt_tcpufit_met->ex()/Gaudi::Units::GeV;
1073  float hlt_tcpufit_Ey = hlt_tcpufit_met->ey()/Gaudi::Units::GeV;
1074  float hlt_tcpufit_Et = std::sqrt(hlt_tcpufit_Ex*hlt_tcpufit_Ex + hlt_tcpufit_Ey*hlt_tcpufit_Ey);
1075  auto tcpufit_met_Et = Monitored::Scalar<float>("tcpufit_2D_Et", static_cast<float>(hlt_tcpufit_Et));
1076  fill(tool, met_Et, tcpufit_met_Et);
1077  }
1078  }
1079 
1080  // efficiency plots
1081  for (const std::string& chain : m_l1Chains) {
1082  auto pass_chain = Monitored::Scalar<float>("pass_" + chain, static_cast<float>(getTrigDecisionTool()->isPassed(chain)));
1083  fill(tool, pass_chain,offline_NoMu_Et_eff);
1084  }
1085  for (const std::string& chain : m_hltChains) {
1086  auto pass_chain = Monitored::Scalar<float>("pass_" + chain, static_cast<float>(getTrigDecisionTool()->isPassed(chain)));
1087  fill(tool, pass_chain,offline_NoMu_Et_eff);
1088  }
1089  for (const std::string& chain : m_hltChainsVal) {
1090  auto pass_chain = Monitored::Scalar<float>("pass_" + chain, static_cast<float>(getTrigDecisionTool()->isPassed(chain)));
1091  fill(tool, pass_chain,offline_NoMu_Et_eff);
1092  }
1093  for (const std::string& chain : m_hltChainsT0) {
1094  auto pass_chain = Monitored::Scalar<float>("pass_" + chain, static_cast<float>(getTrigDecisionTool()->isPassed(chain)));
1095  fill(tool, pass_chain,offline_NoMu_Et_eff);
1096  }
1097 
1098  return StatusCode::SUCCESS;
1099 }

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96  {
97  return execState( ctx ).filterPassed();
98  }

◆ GetEventInfo()

SG::ReadHandle< xAOD::EventInfo > AthMonitorAlgorithm::GetEventInfo ( const EventContext &  ctx) const
inherited

Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)

Parameters
ctxEventContext for the event
Returns
a SG::ReadHandle<xAOD::EventInfo>

Definition at line 107 of file AthMonitorAlgorithm.cxx.

107  {
109 }

◆ getGroup()

const ToolHandle< GenericMonitoringTool > & AthMonitorAlgorithm::getGroup ( const std::string &  name) const
inherited

Get a specific monitoring tool from the tool handle array.

Finds a specific GenericMonitoringTool instance from the list of monitoring tools (a ToolHandleArray). Throws a FATAL warning if the object found is empty.

Parameters
namestring name of the desired tool
Returns
reference to the desired monitoring tool

Definition at line 164 of file AthMonitorAlgorithm.cxx.

164  {
165  // get the pointer to the tool, and check that it exists
166  auto idx = m_toolLookupMap.find(name);
167  if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
168  return m_tools[idx->second];
169  }
170  else {
171  // treat empty tool handle case as in Monitored::Group
172  if (m_toolLookupMap.empty()) {
173  return m_dummy;
174  }
175 
176  if (!isInitialized()) {
178  "It seems that the AthMonitorAlgorithm::initialize was not called "
179  "in derived class initialize method");
180  } else {
181  std::string available = std::accumulate(
182  m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
183  [](const std::string& s, auto h) { return s + "," + h.first; });
184  ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
185  << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
186  << "your python configuration and c++ filling code. Note: your available groups are {"
187  << available << "}.");
188  }
189  }
190  return m_dummy;
191 }

◆ getTrigDecisionTool()

const ToolHandle< Trig::TrigDecisionTool > & AthMonitorAlgorithm::getTrigDecisionTool ( ) const
inherited

Get the trigger decision tool member.

The trigger decision tool is used to check whether a specific trigger is passed by an event.

Returns
m_trigDecTool

Definition at line 194 of file AthMonitorAlgorithm.cxx.

194  {
195  return m_trigDecTool;
196 }

◆ initialize()

StatusCode TrigMETMonitorAlgorithm::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from AthMonitorAlgorithm.

Definition at line 19 of file TrigMETMonitorAlgorithm.cxx.

19  {
21  ATH_CHECK( m_offline_met_key.initialize() );
26  ATH_CHECK( m_vertex_key.initialize() );
27  ATH_CHECK( m_offline_vertex_key.initialize() );
28  ATH_CHECK( m_lvl1_roi_key.initialize() );
29  ATH_CHECK( m_l1_jFexMet_key.initialize() );
30  ATH_CHECK( m_l1_jFexSumEt_key.initialize() );
31  ATH_CHECK( m_l1_gFexJwojScalar_key.initialize() );
35  ATH_CHECK( m_l1_gFexNCMETScalar_key.initialize() );
37  ATH_CHECK( m_l1_gFexRhoMETScalar_key.initialize() );
39  ATH_CHECK( m_hlt_cell_met_key.initialize() );
40  ATH_CHECK( m_hlt_mht_met_key.initialize() );
41  ATH_CHECK( m_hlt_tc_met_key.initialize() );
42  ATH_CHECK( m_hlt_tc_em_met_key.initialize() );
43  ATH_CHECK( m_hlt_tcpufit_met_key.initialize() );
44  ATH_CHECK( m_hlt_tcpufit_sig30_met_key.initialize() );
45  ATH_CHECK( m_hlt_trkmht_met_key.initialize() );
46  ATH_CHECK( m_hlt_pfsum_met_key.initialize() );
47  ATH_CHECK( m_hlt_pfopufit_met_key.initialize() );
49  ATH_CHECK( m_hlt_cvfpufit_met_key.initialize() );
50  ATH_CHECK( m_hlt_mhtpufit_pf_met_key.initialize() );
51  ATH_CHECK( m_hlt_mhtpufit_em_met_key.initialize() );
52  ATH_CHECK( m_hlt_met_nn_key.initialize() );
53  ATH_CHECK( m_hlt_pfsum_cssk_met_key.initialize() );
54  ATH_CHECK( m_hlt_pfsum_vssk_met_key.initialize() );
55 
57 }

◆ inputHandles()

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

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

52 {
53  // Reentrant algorithms are clonable.
54  return true;
55 }

◆ msg() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Gaudi::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< Gaudi::Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

◆ parseList()

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

Parse a string into a vector.

The input string is a single long string of all of the trigger names. It parses this string and turns it into a vector, where each element is one trigger or trigger category.

Parameters
lineThe input string.
resultThe parsed output vector of strings.
Returns
StatusCode

Definition at line 341 of file AthMonitorAlgorithm.cxx.

341  {
342  std::string item;
343  std::stringstream ss(line);
344 
345  ATH_MSG_DEBUG( "AthMonitorAlgorithm::parseList()" );
346 
347  while ( std::getline(ss, item, ',') ) {
348  std::stringstream iss(item); // remove whitespace
349  iss >> item;
350  result.push_back(item);
351  }
352 
353  return StatusCode::SUCCESS;
354 }

◆ 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< Gaudi::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< Gaudi::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  }

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100  {
101  execState( ctx ).setFilterPassed( state );
102  }

◆ signed_log()

double TrigMETMonitorAlgorithm::signed_log ( double  e,
double  epsilon 
) const
private

Definition at line 1102 of file TrigMETMonitorAlgorithm.cxx.

1102  {
1103 
1104 
1105  double e_log = -9e9;
1106  if (std::abs(e) > epsilon)
1107  e_log = std::copysign(std::log10(std::abs(e)), e);
1108  else
1109  e_log = 0.01;
1110 
1111  return e_log;
1112 }

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext &  ctx)
overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

77 {
78  return BaseAlg::sysExecute (ctx);
79 }

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

107  {
109 
110  if (sc.isFailure()) {
111  return sc;
112  }
113 
114  ServiceHandle<ICondSvc> cs("CondSvc",name());
115  for (auto h : outputHandles()) {
116  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
117  // do this inside the loop so we don't create the CondSvc until needed
118  if ( cs.retrieve().isFailure() ) {
119  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
120  return StatusCode::SUCCESS;
121  }
122  if (cs->regHandle(this,*h).isFailure()) {
123  sc = StatusCode::FAILURE;
124  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
125  << " with CondSvc");
126  }
127  }
128  }
129  return sc;
130 }

◆ sysStart()

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

◆ trigChainsArePassed()

bool AthMonitorAlgorithm::trigChainsArePassed ( const std::vector< std::string > &  vTrigNames) const
inherited

Check whether triggers are passed.

For the event, use the trigger decision tool to check that at least one of the triggers listed in the supplied vector is passed.

Parameters
vTrigNamesList of trigger names.
Returns
If empty input, default to true. If at least one trigger is specified, returns whether at least one trigger was passed.

Definition at line 199 of file AthMonitorAlgorithm.cxx.

199  {
200 
201 
202  // If no triggers were given, return true.
203  if (vTrigNames.empty()) return true;
204 
205 
206  // Trigger: Check if this Algorithm is being run as an Express Stream job.
207  // Events are entering the express stream are chosen randomly, and by chain,
208  // Hence an additional check should be aplied to see if the chain(s)
209  // monitored here are responsible for the event being selected for
210  // the express stream.
211 
212  const auto group = m_trigDecTool->getChainGroup(vTrigNames);
214  const auto passedBits = m_trigDecTool->isPassedBits(group);
215  bool expressPass = passedBits & TrigDefs::Express_passed; //bitwise AND
216  if(!expressPass) {
217  return false;
218  }
219  }
220 
221  // monitor the event if any of the chains in the chain group passes the event.
222  return group->isPassed();
223 
224 }

◆ updateVHKA()

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

◆ cfg

TrigMETMonitorAlgorithm.cfg

Definition at line 974 of file TrigMETMonitorAlgorithm.py.

◆ file

TrigMETMonitorAlgorithm.file

Definition at line 963 of file TrigMETMonitorAlgorithm.py.

◆ Files

TrigMETMonitorAlgorithm.Files

Definition at line 965 of file TrigMETMonitorAlgorithm.py.

◆ flags

TrigMETMonitorAlgorithm.flags

Definition at line 964 of file TrigMETMonitorAlgorithm.py.

◆ HISTFileName

TrigMETMonitorAlgorithm.HISTFileName

Definition at line 967 of file TrigMETMonitorAlgorithm.py.

◆ isMC

TrigMETMonitorAlgorithm.isMC

Definition at line 966 of file TrigMETMonitorAlgorithm.py.

◆ m_algsHLT

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_algsHLT {this, "algsHLT", {}, "HLT algorithms to monitor"}
private

Definition at line 94 of file TrigMETMonitorAlgorithm.h.

◆ m_algsHLT2d

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_algsHLT2d {this, "algsHLT2d", {}, "HLT algorithms for 2d eta-phi plots"}
private

Definition at line 97 of file TrigMETMonitorAlgorithm.h.

◆ m_algsHLTExpert

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_algsHLTExpert {this, "algsHLTExpert", {}, "HLT algorithms for Expert"}
private

Definition at line 98 of file TrigMETMonitorAlgorithm.h.

◆ m_algsHLTPreSel

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_algsHLTPreSel {this, "algsHLTPreSel", {}, "HLTPreSel algorithms to monitor"}
private

Definition at line 95 of file TrigMETMonitorAlgorithm.h.

◆ m_algsL1

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_algsL1 {this, "algsL1", {}, "L1 algorithms to monitor"}
private

Definition at line 93 of file TrigMETMonitorAlgorithm.h.

◆ m_algsMET2d_tcpufit

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_algsMET2d_tcpufit {this, "algsMET2d_tcpufit", {}, "HLT algorithms for 2D MET wrt tcpufit"}
private

Definition at line 99 of file TrigMETMonitorAlgorithm.h.

◆ m_bitNames

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_bitNames {this, "bitNames", {}, "Status bit names"}
private

Definition at line 101 of file TrigMETMonitorAlgorithm.h.

◆ m_compNames

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_compNames {this, "compNames", {}, "Calorimeter component names"}
private

Definition at line 100 of file TrigMETMonitorAlgorithm.h.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 351 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

Gaudi::Property<std::string> AthMonitorAlgorithm::m_dataTypeStr {this,"DataType","userDefined"}
protectedinherited

DataType string pulled from the job option and converted to enum.

Definition at line 353 of file AthMonitorAlgorithm.h.

◆ m_defaultLBDuration

Gaudi::Property<float> AthMonitorAlgorithm::m_defaultLBDuration {this,"DefaultLBDuration",60.}
protectedinherited

Default duration of one lumi block.

Definition at line 360 of file AthMonitorAlgorithm.h.

◆ m_detailLevel

Gaudi::Property<int> AthMonitorAlgorithm::m_detailLevel {this,"DetailLevel",0}
protectedinherited

Sets the level of detail used in the monitoring.

Definition at line 361 of file AthMonitorAlgorithm.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 369 of file AthMonitorAlgorithm.h.

◆ m_electronEtaCut

Gaudi::Property<double> TrigMETMonitorAlgorithm::m_electronEtaCut {this, "electronEtaCut", 0.0, "Electron eta cut for leading electron"}
private

Definition at line 107 of file TrigMETMonitorAlgorithm.h.

◆ m_electronPtCut

Gaudi::Property<double> TrigMETMonitorAlgorithm::m_electronPtCut {this, "electronPtCut", 0.0, "Electron pt cut for leading electron"}
private

Definition at line 106 of file TrigMETMonitorAlgorithm.h.

◆ m_enforceExpressTriggers

Gaudi::Property<bool> AthMonitorAlgorithm::m_enforceExpressTriggers
privateinherited
Initial value:
{this,
"EnforceExpressTriggers", false,
"Requires that matched triggers made the event enter the express stream"}

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 350 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

Gaudi::Property<std::string> AthMonitorAlgorithm::m_environmentStr {this,"Environment","user"}
protectedinherited

Environment string pulled from the job option and converted to enum.

Definition at line 352 of file AthMonitorAlgorithm.h.

◆ m_EventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> AthMonitorAlgorithm::m_EventInfoKey {this,"EventInfoKey","EventInfo"}
protectedinherited

Key for retrieving EventInfo from StoreGate.

Definition at line 362 of file AthMonitorAlgorithm.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_fileKey

Gaudi::Property<std::string> AthMonitorAlgorithm::m_fileKey {this,"FileKey",""}
protectedinherited

Internal Athena name for file.

Definition at line 358 of file AthMonitorAlgorithm.h.

◆ m_hlt_cell_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_cell_met_key {this, "hlt_cell_key", "HLT_MET_cell", "HLT Cell MET container name"}
private

Definition at line 70 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_cvfpufit_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_cvfpufit_met_key {this, "hlt_cvfpufit_key", "HLT_MET_cvfpufit", "HLT CvfPufit MET container name"}
private

Definition at line 82 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_electron_key

SG::ReadHandleKey<xAOD::ElectronContainer> TrigMETMonitorAlgorithm::m_hlt_electron_key {this, "hlt_electron_key", "HLT_egamma_Electrons_GSF", "HLT electron container name"}
private

Definition at line 49 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_met_nn_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_met_nn_key {this, "hlt_met_nn_key", "HLT_MET_nn", "HLT MET NN container name"}
private

Definition at line 85 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_mht_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_mht_met_key {this, "hlt_mht_key", "HLT_MET_mht", "HLT MHT MET container name"}
private

Definition at line 71 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_mhtpufit_em_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_mhtpufit_em_met_key {this, "hlt_mhtpufit_em_key", "HLT_MET_mhtpufit_em", "HLT MhtPufitEm MET container name"}
private

Definition at line 84 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_mhtpufit_pf_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_mhtpufit_pf_met_key {this, "hlt_mhtpufit_pf_key", "HLT_MET_mhtpufit_pf", "HLT MhtPufitPf MET container name"}
private

Definition at line 83 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_muon_key

SG::ReadHandleKey<xAOD::MuonContainer> TrigMETMonitorAlgorithm::m_hlt_muon_key {this, "hlt_muon_key", "HLT_MuonsCB_FS", "HLT muon container name"}
private

Definition at line 50 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_pfopufit_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_pfopufit_met_key {this, "hlt_pfopufit_key", "HLT_MET_pfopufit", "HLT PfoPufit MET container name"}
private

Definition at line 80 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_pfopufit_sig30_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_pfopufit_sig30_met_key {this, "hlt_pfopufit_sig30_key", "HLT_MET_pfopufit_sig30", "HLT PfoPufit sig30 MET container name"}
private

Definition at line 81 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_pfsum_cssk_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_pfsum_cssk_met_key {this, "hlt_pfsum_cssk_key", "HLT_MET_pfsum_cssk", "HLT Pfsum CSSK MET container name"}
private

Definition at line 78 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_pfsum_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_pfsum_met_key {this, "hlt_pfsum_key", "HLT_MET_pfsum", "HLT Pfsum MET container name"}
private

Definition at line 77 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_pfsum_vssk_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_pfsum_vssk_met_key {this, "hlt_pfsum_vssk_key", "HLT_MET_pfsum_vssk", "HLT Pfsum VSSK MET container name"}
private

Definition at line 79 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_tc_em_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_tc_em_met_key {this, "hlt_tc_em_key", "HLT_MET_tc_em", "HLT TC EM MET container name"}
private

Definition at line 73 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_tc_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_tc_met_key {this, "hlt_tc_key", "HLT_MET_tc", "HLT TC MET container name"}
private

Definition at line 72 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_tcpufit_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_tcpufit_met_key {this, "hlt_tcpufit_key", "HLT_MET_tcpufit", "HLT TCPufit MET container name"}
private

Definition at line 74 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_tcpufit_sig30_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_tcpufit_sig30_met_key {this, "hlt_tcpufit_sig30_key", "HLT_MET_tcpufit_sig30", "HLT TCPufit sig30 MET container name"}
private

Definition at line 75 of file TrigMETMonitorAlgorithm.h.

◆ m_hlt_trkmht_met_key

SG::ReadHandleKey<xAOD::TrigMissingETContainer> TrigMETMonitorAlgorithm::m_hlt_trkmht_met_key {this, "hlt_trkmht_key", "HLT_MET_trkmht", "HLT TrkMht MET container name"}
private

Definition at line 76 of file TrigMETMonitorAlgorithm.h.

◆ m_hltChainEl

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_hltChainEl {this, "HLTChainEl", {}, "The HLT Electron primary chain to use for monitoring plots"}
private

Definition at line 91 of file TrigMETMonitorAlgorithm.h.

◆ m_hltChainMu

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_hltChainMu {this, "HLTChainMu", {}, "The HLT Muon primary chain to use for monitoring plots"}
private

Definition at line 92 of file TrigMETMonitorAlgorithm.h.

◆ m_hltChains

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_hltChains {this, "HLTChains", {}, "The HLT shifter chains to monitor"}
private

Definition at line 88 of file TrigMETMonitorAlgorithm.h.

◆ m_hltChainsT0

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_hltChainsT0 {this, "HLTChainsT0", {}, "The HLT t0 chains to monitor"}
private

Definition at line 90 of file TrigMETMonitorAlgorithm.h.

◆ m_hltChainsVal

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_hltChainsVal {this, "HLTChainsVal", {}, "The HLT val chains to monitor"}
private

Definition at line 89 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_gFexJwojMETComponents_key

SG::ReadHandleKey<xAOD::gFexGlobalRoIContainer> TrigMETMonitorAlgorithm::m_l1_gFexJwojMETComponents_key {this, "l1_gFexJwojMETComponents_key", "L1_gMETComponentsJwoj", "L1 gFex JWOJ Ex and Ey container name"}
private

Definition at line 62 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_gFexJwojMHTComponents_key

SG::ReadHandleKey<xAOD::gFexGlobalRoIContainer> TrigMETMonitorAlgorithm::m_l1_gFexJwojMHTComponents_key {this, "l1_gFexJwojMHTComponents_key", "L1_gMHTComponentsJwoj", "L1 gFex JWOJ Hard Term Ex and Ey container name"}
private

Definition at line 63 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_gFexJwojMSTComponents_key

SG::ReadHandleKey<xAOD::gFexGlobalRoIContainer> TrigMETMonitorAlgorithm::m_l1_gFexJwojMSTComponents_key {this, "l1_gFexJwojMSTComponents_key", "L1_gMSTComponentsJwoj", "L1 gFex JWOJ Soft Term Ex and Ey container name"}
private

Definition at line 64 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_gFexJwojScalar_key

SG::ReadHandleKey<xAOD::gFexGlobalRoIContainer> TrigMETMonitorAlgorithm::m_l1_gFexJwojScalar_key {this, "l1_gFexJwojScalar_key", "L1_gScalarEJwoj", "L1 gFex JWOJ Et and sumEt container name"}
private

Definition at line 61 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_gFexNCMETComponents_key

SG::ReadHandleKey<xAOD::gFexGlobalRoIContainer> TrigMETMonitorAlgorithm::m_l1_gFexNCMETComponents_key {this, "l1_gFexNCMETComponents_key", "L1_gMETComponentsNoiseCut", "L1 gFex NC Ex and Ey container name"}
private

Definition at line 66 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_gFexNCMETScalar_key

SG::ReadHandleKey<xAOD::gFexGlobalRoIContainer> TrigMETMonitorAlgorithm::m_l1_gFexNCMETScalar_key {this, "l1_gFexNCMETScalar_key", "L1_gScalarENoiseCut", "L1 gFex NC Et and sumEt container name"}
private

Definition at line 65 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_gFexRhoMETComponents_key

SG::ReadHandleKey<xAOD::gFexGlobalRoIContainer> TrigMETMonitorAlgorithm::m_l1_gFexRhoMETComponents_key {this, "l1_gFexRhoMETComponents_key", "L1_gMETComponentsRms", "L1 gFex Rho Ex and Ey container name"}
private

Definition at line 68 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_gFexRhoMETScalar_key

SG::ReadHandleKey<xAOD::gFexGlobalRoIContainer> TrigMETMonitorAlgorithm::m_l1_gFexRhoMETScalar_key {this, "l1_gFexRhoMETScalar_key", "L1_gScalarERms", "L1 gFex Rho Et and sumEt container name"}
private

Definition at line 67 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_jFexMet_key

SG::ReadHandleKey<xAOD::jFexMETRoIContainer> TrigMETMonitorAlgorithm::m_l1_jFexMet_key {this, "l1_jFexMet_key", "L1_jFexMETRoI", "L1 jFex MET container name"}
private

Definition at line 59 of file TrigMETMonitorAlgorithm.h.

◆ m_l1_jFexSumEt_key

SG::ReadHandleKey<xAOD::jFexSumETRoIContainer> TrigMETMonitorAlgorithm::m_l1_jFexSumEt_key {this, "l1_jFexSumEt_key", "L1_jFexSumETRoI", "L1 jFex sumEt container name"}
private

Definition at line 60 of file TrigMETMonitorAlgorithm.h.

◆ m_l1Chains

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_l1Chains {this, "L1Chains", {}, "The L1 chains to monitor"}
private

Definition at line 87 of file TrigMETMonitorAlgorithm.h.

◆ m_L1MetAlg

Gaudi::Property<int> TrigMETMonitorAlgorithm::m_L1MetAlg {this, "L1MetAlg", 1, "L1 MET algorithm for PreSel"}
private

Definition at line 103 of file TrigMETMonitorAlgorithm.h.

◆ m_L1MetCut

Gaudi::Property<double> TrigMETMonitorAlgorithm::m_L1MetCut {this, "L1MetCut", 50.0, "L1 MET cut for PreSel"}
private

Definition at line 104 of file TrigMETMonitorAlgorithm.h.

◆ m_LArNoiseBurstVetoAlgs

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_LArNoiseBurstVetoAlgs {this, "LArNoiseBurstVetoAlgs", {}, "MET histograms with LAr NoiseBurst Veto Applied"}
private

Definition at line 96 of file TrigMETMonitorAlgorithm.h.

◆ m_lbDurationDataKey

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

Definition at line 345 of file AthMonitorAlgorithm.h.

◆ m_lumiDataKey

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

Definition at line 343 of file AthMonitorAlgorithm.h.

◆ m_lvl1_roi_key

SG::ReadHandleKey<xAOD::EnergySumRoI> TrigMETMonitorAlgorithm::m_lvl1_roi_key {this, "l1_roi_key", "LVL1EnergySumRoI", "L1 energy sum ROI container name"}
private

Definition at line 57 of file TrigMETMonitorAlgorithm.h.

◆ m_muonEtaCut

Gaudi::Property<double> TrigMETMonitorAlgorithm::m_muonEtaCut {this, "muonEtaCut", 0.0, "Muon eta cut for leading muon"}
private

Definition at line 109 of file TrigMETMonitorAlgorithm.h.

◆ m_muonPtCut

Gaudi::Property<double> TrigMETMonitorAlgorithm::m_muonPtCut {this, "muonPtCut", 0.0, "Muon pt cut for leading muon"}
private

Definition at line 108 of file TrigMETMonitorAlgorithm.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 366 of file AthMonitorAlgorithm.h.

◆ m_offline_met_key

SG::ReadHandleKey<xAOD::MissingETContainer> TrigMETMonitorAlgorithm::m_offline_met_key {this, "offline_met_key", "MET_Reference_AntiKt4EMPFlow", "Offline met container name"}
private

Definition at line 47 of file TrigMETMonitorAlgorithm.h.

◆ m_offline_vertex_key

SG::ReadHandleKey<xAOD::VertexContainer> TrigMETMonitorAlgorithm::m_offline_vertex_key {this, "offline_vertex_key", "PrimaryVertices", "Offline vertex container name"}
private

Definition at line 55 of file TrigMETMonitorAlgorithm.h.

◆ m_signalLepAlgs

Gaudi::Property<std::vector<std::string> > TrigMETMonitorAlgorithm::m_signalLepAlgs {this, "signalLepAlgs", {}, "Signal lepton MET histograms"}
private

Definition at line 110 of file TrigMETMonitorAlgorithm.h.

◆ m_toolLookupMap

std::unordered_map<std::string, size_t> AthMonitorAlgorithm::m_toolLookupMap
privateinherited

Definition at line 367 of file AthMonitorAlgorithm.h.

◆ m_tools

ToolHandleArray<GenericMonitoringTool> AthMonitorAlgorithm::m_tools {this,"GMTools",{}}
protectedinherited

Array of Generic Monitoring Tools.

Definition at line 338 of file AthMonitorAlgorithm.h.

◆ m_topoclusters_key

SG::ReadHandleKey<xAOD::CaloClusterContainer> TrigMETMonitorAlgorithm::m_topoclusters_key {this, "topoclusters_key", "HLT_TopoCaloClustersLCFS", "HLT topoclusters container name"}
private

Definition at line 52 of file TrigMETMonitorAlgorithm.h.

◆ m_tracks_key

SG::ReadHandleKey<xAOD::TrackParticleContainer> TrigMETMonitorAlgorithm::m_tracks_key {this, "tracks_key", "HLT_IDTrack_FS_FTF", "HLT tracks container name"}
private

Definition at line 53 of file TrigMETMonitorAlgorithm.h.

◆ m_trigDecTool

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

Tool to tell whether a specific trigger is passed.

Definition at line 340 of file AthMonitorAlgorithm.h.

◆ m_triggerChainString

Gaudi::Property<std::string> AthMonitorAlgorithm::m_triggerChainString {this,"TriggerChain",""}
protectedinherited

Trigger chain string pulled from the job option and parsed into a vector.

Definition at line 355 of file AthMonitorAlgorithm.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 347 of file AthMonitorAlgorithm.h.

◆ m_useLumi

Gaudi::Property<bool> AthMonitorAlgorithm::m_useLumi {this,"EnableLumi",false}
protectedinherited

Allows use of various luminosity functions.

Definition at line 359 of file AthMonitorAlgorithm.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vertex_key

SG::ReadHandleKey<xAOD::VertexContainer> TrigMETMonitorAlgorithm::m_vertex_key {this, "vertex_key", "HLT_IDVertex_FS", "HLT vertex container name"}
private

Definition at line 54 of file TrigMETMonitorAlgorithm.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

std::vector<std::string> AthMonitorAlgorithm::m_vTrigChainNames
protectedinherited

Vector of trigger chain names parsed from trigger chain string.

Definition at line 356 of file AthMonitorAlgorithm.h.

◆ nightly

TrigMETMonitorAlgorithm.nightly

Definition at line 962 of file TrigMETMonitorAlgorithm.py.

◆ trigMETMonitorAcc

TrigMETMonitorAlgorithm.trigMETMonitorAcc

Definition at line 977 of file TrigMETMonitorAlgorithm.py.

◆ withDetails

TrigMETMonitorAlgorithm.withDetails

Definition at line 982 of file TrigMETMonitorAlgorithm.py.


The documentation for this class was generated from the following files:
TrigMETMonitorAlgorithm::m_hlt_pfopufit_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfopufit_met_key
Definition: TrigMETMonitorAlgorithm.h:80
TrigMETMonitorAlgorithm::signed_log
double signed_log(double e, double epsilon) const
Definition: TrigMETMonitorAlgorithm.cxx:1102
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
xAOD::TrigMissingET_v1::sumEt
float sumEt() const
Get the sum of the ET of the missing energy.
xAOD::TrigMissingET_v1::exComponent
float exComponent(unsigned int index) const
Get the x component fo the energy of a component.
Definition: TrigMissingET_v1.cxx:119
AthMonitorAlgorithm::Environment_t::tier0Raw
@ tier0Raw
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
TrigMETMonitorAlgorithm::m_hlt_met_nn_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_met_nn_key
Definition: TrigMETMonitorAlgorithm.h:85
get_generator_info.result
result
Definition: get_generator_info.py:21
TrigMETMonitorAlgorithm::m_hlt_trkmht_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_trkmht_met_key
Definition: TrigMETMonitorAlgorithm.h:76
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition: AthMonitorAlgorithm.h:340
TrigMETMonitorAlgorithm::m_algsMET2d_tcpufit
Gaudi::Property< std::vector< std::string > > m_algsMET2d_tcpufit
Definition: TrigMETMonitorAlgorithm.h:99
TrigMETMonitorAlgorithm::m_hltChainsT0
Gaudi::Property< std::vector< std::string > > m_hltChainsT0
Definition: TrigMETMonitorAlgorithm.h:90
AthMonitorAlgorithm::Environment_t::tier0
@ tier0
AthMonitorAlgorithm::Environment_t::AOD
@ AOD
xAOD::TrigMissingET_v1::statusComponent
short statusComponent(unsigned int index) const
Get Status.
Definition: TrigMissingET_v1.cxx:207
xAOD::MissingET_v1::sumet
float sumet() const
Returns.
TrigMETMonitorAlgorithm::m_signalLepAlgs
Gaudi::Property< std::vector< std::string > > m_signalLepAlgs
Definition: TrigMETMonitorAlgorithm.h:110
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
TrigMETMonitorAlgorithm::m_hlt_cell_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_cell_met_key
Definition: TrigMETMonitorAlgorithm.h:70
runITkAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runITkAlign.py:62
xAOD::EnergySumRoI_v2::energyT
float energyT() const
The deposited total transverse energy.
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition: AthMonitorAlgorithm.h:356
AthCommonDataStore::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 > renounce(T &h)
Definition: AthCommonDataStore.h:380
CaloClusterMLCalib::epsilon
constexpr float epsilon
Definition: CaloClusterMLGaussianMixture.h:16
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition: AthMonitorAlgorithm.h:362
AthMonitorAlgorithm::getTrigDecisionTool
const ToolHandle< Trig::TrigDecisionTool > & getTrigDecisionTool() const
Get the trigger decision tool member.
Definition: AthMonitorAlgorithm.cxx:194
xAOD::gFexGlobalRoI_v1
Class describing properties of a LVL1 gFEX global Trigger Object (TOB) in the xAOD format.
Definition: gFexGlobalRoI_v1.h:25
TrigMETMonitorAlgorithm::m_l1_gFexJwojScalar_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexJwojScalar_key
Definition: TrigMETMonitorAlgorithm.h:61
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
xAOD::TrigMissingET_v1::ex
float ex() const
Get the x component of the missing energy.
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition: AthMonitorAlgorithm.h:367
TrigMETMonitorAlgorithm::m_hlt_cvfpufit_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_cvfpufit_met_key
Definition: TrigMETMonitorAlgorithm.h:82
xAOD::TrigMissingET_v1::flag
int flag() const
Get the status flag.
xAOD::gFexGlobalRoI_v1::METquantityOne
float METquantityOne() const
retrieves the Et index from the 32-bit word
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition: AthMonitorAlgorithm.h:350
xAOD::EnergySumRoI_v2::energyY
float energyY() const
The total energy deposited in the Y direction.
TrigMETMonitorAlgorithm::m_LArNoiseBurstVetoAlgs
Gaudi::Property< std::vector< std::string > > m_LArNoiseBurstVetoAlgs
Definition: TrigMETMonitorAlgorithm.h:96
cosmics
Definition: cosmics.py:1
TrigMETMonitorAlgorithm::m_hltChainEl
Gaudi::Property< std::vector< std::string > > m_hltChainEl
Definition: TrigMETMonitorAlgorithm.h:91
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
TrigMETMonitorAlgorithm::m_hlt_pfopufit_sig30_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfopufit_sig30_met_key
Definition: TrigMETMonitorAlgorithm.h:81
TrigMETMonitorAlgorithm::m_hlt_pfsum_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfsum_met_key
Definition: TrigMETMonitorAlgorithm.h:77
Muon
NRpcCablingAlg reads raw condition data and writes derived condition data to the condition store.
Definition: TrackSystemController.h:45
TrigMETMonitorAlgorithm::m_l1Chains
Gaudi::Property< std::vector< std::string > > m_l1Chains
Definition: TrigMETMonitorAlgorithm.h:87
TrigMETMonitorAlgorithm::m_hlt_tcpufit_sig30_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_tcpufit_sig30_met_key
Definition: TrigMETMonitorAlgorithm.h:75
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition: EventInfo_v1.h:335
TrigMETMonitorAlgorithm::m_l1_gFexJwojMSTComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexJwojMSTComponents_key
Definition: TrigMETMonitorAlgorithm.h:64
dq_defect_bulk_create_defects.line
line
Definition: dq_defect_bulk_create_defects.py:27
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:199
AthMonitorAlgorithm::Environment_t::user
@ user
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:459
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition: AthMonitorAlgorithm.h:369
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
xAOD::gFexGlobalRoI_v1::METquantityTwo
float METquantityTwo() const
floating point value (GeV, TOB scale)
TrigMETMonitorAlgorithm::m_bitNames
Gaudi::Property< std::vector< std::string > > m_bitNames
Definition: TrigMETMonitorAlgorithm.h:101
PyPoolBrowser.item
item
Definition: PyPoolBrowser.py:129
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
TrigMETMonitorAlgorithm::m_l1_gFexNCMETComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexNCMETComponents_key
Definition: TrigMETMonitorAlgorithm.h:66
LArEventBitInfo::NOISEBURSTVETO
@ NOISEBURSTVETO
Definition: LArEventBitInfo.h:13
TileSynchronizeBch.online
online
Definition: TileSynchronizeBch.py:88
AthCommonReentrantAlgorithm::extraOutputDeps
virtual const DataObjIDColl & extraOutputDeps() const override
Return the list of extra output dependencies.
Definition: AthCommonReentrantAlgorithm.cxx:89
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition: AthMonitorAlgorithm.h:341
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TrigMETMonitorAlgorithm::m_l1_gFexJwojMHTComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexJwojMHTComponents_key
Definition: TrigMETMonitorAlgorithm.h:63
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
lumiFormat.i
int i
Definition: lumiFormat.py:85
TrigMETMonitorAlgorithm::m_hlt_mhtpufit_pf_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_mhtpufit_pf_met_key
Definition: TrigMETMonitorAlgorithm.h:83
TrigMETMonitorAlgorithm::m_algsHLTExpert
Gaudi::Property< std::vector< std::string > > m_algsHLTExpert
Definition: TrigMETMonitorAlgorithm.h:98
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:28
TrigMETMonitorAlgorithm::m_l1_gFexJwojMETComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexJwojMETComponents_key
Definition: TrigMETMonitorAlgorithm.h:62
AthMonitorAlgorithm::DataType_t::heavyIonCollisions
@ heavyIonCollisions
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
TrigMETMonitorAlgorithm::m_hlt_mhtpufit_em_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_mhtpufit_em_met_key
Definition: TrigMETMonitorAlgorithm.h:84
tolower
void tolower(std::string &s)
Definition: AthenaSummarySvc.cxx:108
python.CaloAddPedShiftConfig.str
str
Definition: CaloAddPedShiftConfig.py:42
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
AthCommonReentrantAlgorithm::sysExecute
virtual StatusCode sysExecute(const EventContext &ctx) override
Execute an algorithm.
Definition: AthCommonReentrantAlgorithm.cxx:76
Amg::transform
Amg::Vector3D transform(Amg::Vector3D &v, Amg::Transform3D &tr)
Transform a point from a Trasformation3D.
Definition: GeoPrimitivesHelpers.h:156
xAOD::VxType::PriVtx
@ PriVtx
Primary vertex.
Definition: TrackingPrimitives.h:572
xAOD::MissingET_v1
Principal data object for Missing ET.
Definition: MissingET_v1.h:25
xAOD::MissingET_v1::mpx
float mpx() const
Returns .
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TrigMETMonitorAlgorithm::m_l1_jFexMet_key
SG::ReadHandleKey< xAOD::jFexMETRoIContainer > m_l1_jFexMet_key
Definition: TrigMETMonitorAlgorithm.h:59
TrigMETMonitorAlgorithm::m_algsHLT
Gaudi::Property< std::vector< std::string > > m_algsHLT
Definition: TrigMETMonitorAlgorithm.h:94
TrigMETMonitorAlgorithm::m_hltChainsVal
Gaudi::Property< std::vector< std::string > > m_hltChainsVal
Definition: TrigMETMonitorAlgorithm.h:89
TrigMETMonitorAlgorithm::m_L1MetAlg
Gaudi::Property< int > m_L1MetAlg
Definition: TrigMETMonitorAlgorithm.h:103
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::Vertex_v1::z
float z() const
Returns the z position.
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
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
TrigMETMonitorAlgorithm::m_hlt_electron_key
SG::ReadHandleKey< xAOD::ElectronContainer > m_hlt_electron_key
Definition: TrigMETMonitorAlgorithm.h:49
TrigMETMonitorAlgorithm::m_hlt_tc_em_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_tc_em_met_key
Definition: TrigMETMonitorAlgorithm.h:73
Electron
TrigMETMonitorAlgorithm::m_hlt_pfsum_cssk_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfsum_cssk_met_key
Definition: TrigMETMonitorAlgorithm.h:78
xAOD::EnergySumRoI_v2::energyX
float energyX() const
The total energy deposited in the X direction.
TrigMETMonitorAlgorithm::m_l1_gFexRhoMETScalar_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexRhoMETScalar_key
Definition: TrigMETMonitorAlgorithm.h:67
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition: AthMonitorAlgorithm.h:351
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
AthMonitorAlgorithm::DataType_t::cosmics
@ cosmics
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
TrigMETMonitorAlgorithm::m_lvl1_roi_key
SG::ReadHandleKey< xAOD::EnergySumRoI > m_lvl1_roi_key
Definition: TrigMETMonitorAlgorithm.h:57
TrigMETMonitorAlgorithm::m_hlt_tc_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_tc_met_key
Definition: TrigMETMonitorAlgorithm.h:72
TrigMETMonitorAlgorithm::m_offline_vertex_key
SG::ReadHandleKey< xAOD::VertexContainer > m_offline_vertex_key
Definition: TrigMETMonitorAlgorithm.h:55
AthMonitorAlgorithm::Environment_t::online
@ online
TrigMETMonitorAlgorithm::m_hltChains
Gaudi::Property< std::vector< std::string > > m_hltChains
Definition: TrigMETMonitorAlgorithm.h:88
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:452
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
RegSelToolConfig.alg
alg
Definition: RegSelToolConfig.py:332
WriteBchToCool.user
user
Definition: WriteBchToCool.py:76
TrigMETMonitorAlgorithm::m_hlt_tcpufit_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_tcpufit_met_key
Definition: TrigMETMonitorAlgorithm.h:74
TrigMETMonitorAlgorithm::m_vertex_key
SG::ReadHandleKey< xAOD::VertexContainer > m_vertex_key
Definition: TrigMETMonitorAlgorithm.h:54
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
python.PyAthena.v
v
Definition: PyAthena.py:154
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
a
TList * a
Definition: liststreamerinfos.cxx:10
TrigMETMonitorAlgorithm::m_l1_gFexNCMETScalar_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexNCMETScalar_key
Definition: TrigMETMonitorAlgorithm.h:65
CaloLCW_tf.group
group
Definition: CaloLCW_tf.py:28
h
xAOD::Vertex_v1
Class describing a Vertex.
Definition: Vertex_v1.h:42
TrigMETMonitorAlgorithm::m_l1_gFexRhoMETComponents_key
SG::ReadHandleKey< xAOD::gFexGlobalRoIContainer > m_l1_gFexRhoMETComponents_key
Definition: TrigMETMonitorAlgorithm.h:68
TrigMETMonitorAlgorithm::m_hlt_mht_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_mht_met_key
Definition: TrigMETMonitorAlgorithm.h:71
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthMonitorAlgorithm::DataType_t::collisions
@ collisions
TrigMETMonitorAlgorithm::m_compNames
Gaudi::Property< std::vector< std::string > > m_compNames
Definition: TrigMETMonitorAlgorithm.h:100
xAOD::TrigMissingET_v1
Class holding the Missing ET trigger fex results.
Definition: TrigMissingET_v1.h:32
AthMonitorAlgorithm::m_name
std::string m_name
Definition: AthMonitorAlgorithm.h:366
xAOD::TrigMissingET_v1::eyComponent
float eyComponent(unsigned int index) const
Get the y component fo the energy of a component.
Definition: TrigMissingET_v1.cxx:130
xAOD::TrigMissingET_v1::ey
float ey() const
Get the y component of the missing energy.
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
AthMonitorAlgorithm::AthMonitorAlgorithm
AthMonitorAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: AthMonitorAlgorithm.cxx:7
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthCommonReentrantAlgorithm.cxx:107
xAOD::TrigMissingET_v1::ez
float ez() const
Get the z component of the missing energy.
TrigMETMonitorAlgorithm::m_algsL1
Gaudi::Property< std::vector< std::string > > m_algsL1
Definition: TrigMETMonitorAlgorithm.h:93
str
Definition: BTagTrackIpAccessor.cxx:11
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
TrigMETMonitorAlgorithm::m_topoclusters_key
SG::ReadHandleKey< xAOD::CaloClusterContainer > m_topoclusters_key
Definition: TrigMETMonitorAlgorithm.h:52
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
AthMonitorAlgorithm::DataType_t::userDefined
@ userDefined
TrigMETMonitorAlgorithm::m_algsHLTPreSel
Gaudi::Property< std::vector< std::string > > m_algsHLTPreSel
Definition: TrigMETMonitorAlgorithm.h:95
xAOD::MissingET_v1::mpy
float mpy() const
Returns .
AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthCommonReentrantAlgorithm.h:114
TrigMETMonitorAlgorithm::m_l1_jFexSumEt_key
SG::ReadHandleKey< xAOD::jFexSumETRoIContainer > m_l1_jFexSumEt_key
Definition: TrigMETMonitorAlgorithm.h:60
TrigMETMonitorAlgorithm::m_hlt_muon_key
SG::ReadHandleKey< xAOD::MuonContainer > m_hlt_muon_key
Definition: TrigMETMonitorAlgorithm.h:50
TrigMETMonitorAlgorithm::m_hlt_pfsum_vssk_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_pfsum_vssk_met_key
Definition: TrigMETMonitorAlgorithm.h:79
TrigMETMonitorAlgorithm::m_hltChainMu
Gaudi::Property< std::vector< std::string > > m_hltChainMu
Definition: TrigMETMonitorAlgorithm.h:92
TrigMETMonitorAlgorithm::m_tracks_key
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_tracks_key
Definition: TrigMETMonitorAlgorithm.h:53
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition: AthMonitorAlgorithm.cxx:164
TrigMETMonitorAlgorithm::m_offline_met_key
SG::ReadHandleKey< xAOD::MissingETContainer > m_offline_met_key
Definition: TrigMETMonitorAlgorithm.h:47
AthMonitorAlgorithm::DataType_t::monteCarlo
@ monteCarlo
fitman.k
k
Definition: fitman.py:528
ServiceHandle< ICondSvc >
collisions
Definition: collisions.py:1
TrigMETMonitorAlgorithm::m_L1MetCut
Gaudi::Property< double > m_L1MetCut
Definition: TrigMETMonitorAlgorithm.h:104