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 9 of file TrigMETMonitorAlgorithm.cxx.

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

◆ ~TrigMETMonitorAlgorithm()

TrigMETMonitorAlgorithm::~TrigMETMonitorAlgorithm ( )
virtual

Definition at line 15 of file TrigMETMonitorAlgorithm.cxx.

15 {}

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 59 of file TrigMETMonitorAlgorithm.cxx.

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

◆ 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 18 of file TrigMETMonitorAlgorithm.cxx.

18  {
20  ATH_CHECK( m_offline_met_key.initialize() );
25  ATH_CHECK( m_vertex_key.initialize() );
26  ATH_CHECK( m_offline_vertex_key.initialize() );
27  ATH_CHECK( m_lvl1_roi_key.initialize() );
28  ATH_CHECK( m_l1_jFexMet_key.initialize() );
29  ATH_CHECK( m_l1_jFexSumEt_key.initialize() );
30  ATH_CHECK( m_l1_gFexJwojScalar_key.initialize() );
34  ATH_CHECK( m_l1_gFexNCMETScalar_key.initialize() );
36  ATH_CHECK( m_l1_gFexRhoMETScalar_key.initialize() );
38  ATH_CHECK( m_hlt_cell_met_key.initialize() );
39  ATH_CHECK( m_hlt_mht_met_key.initialize() );
40  ATH_CHECK( m_hlt_tc_met_key.initialize() );
41  ATH_CHECK( m_hlt_tc_em_met_key.initialize() );
42  ATH_CHECK( m_hlt_tcpufit_met_key.initialize() );
43  ATH_CHECK( m_hlt_tcpufit_sig30_met_key.initialize() );
44  ATH_CHECK( m_hlt_trkmht_met_key.initialize() );
45  ATH_CHECK( m_hlt_pfsum_met_key.initialize() );
46  ATH_CHECK( m_hlt_pfopufit_met_key.initialize() );
48  ATH_CHECK( m_hlt_cvfpufit_met_key.initialize() );
49  ATH_CHECK( m_hlt_mhtpufit_pf_met_key.initialize() );
50  ATH_CHECK( m_hlt_mhtpufit_em_met_key.initialize() );
51  ATH_CHECK( m_hlt_met_nn_key.initialize() );
52  ATH_CHECK( m_hlt_pfsum_cssk_met_key.initialize() );
53  ATH_CHECK( m_hlt_pfsum_vssk_met_key.initialize() );
54 
56 }

◆ 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 1101 of file TrigMETMonitorAlgorithm.cxx.

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

◆ 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:1101
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:18
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
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
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:30
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
item
Definition: ItemListSvc.h:43
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
runIDAlign.accumulate
accumulate
Update flags based on parser line args.
Definition: runIDAlign.py:60
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