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 > &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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

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 AthReentrantAlgorithm::cardinality ( ) const
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 55 of file AthReentrantAlgorithm.cxx.

56 {
57  return 0;
58 }

◆ 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 > &  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 > &  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 > &  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 > &  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 > &  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 & AthReentrantAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.cxx.

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

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

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext &  ctx) const
inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

135  {
136  return execState( ctx ).filterPassed();
137  }

◆ 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  if (!isInitialized()) {
173  "It seems that the AthMonitorAlgorithm::initialize was not called "
174  "in derived class initialize method");
175  } else {
176  std::string available = std::accumulate(
177  m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
178  [](const std::string& s, auto h) { return s + "," + h.first; });
179  ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
180  << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
181  << "your python configuration and c++ filling code. Note: your available groups are {"
182  << available << "}.");
183  }
184  }
185  return m_dummy;
186 }

◆ 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 189 of file AthMonitorAlgorithm.cxx.

189  {
190  return m_trigDecTool;
191 }

◆ 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() );
22  ATH_CHECK( m_hlt_muon_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 AthReentrantAlgorithm::isClonable ( ) const
overridevirtualinherited

◆ 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 336 of file AthMonitorAlgorithm.cxx.

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

◆ 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 AthReentrantAlgorithm::setFilterPassed ( bool  state,
const EventContext &  ctx 
) const
inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

139  {
140  execState( ctx ).setFilterPassed( state );
141  }

◆ signed_log()

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

Definition at line 1094 of file TrigMETMonitorAlgorithm.cxx.

1094  {
1095 
1096 
1097  double e_log = -9e9;
1098  if (std::abs(e) > epsilon)
1099  e_log = std::copysign(std::log10(std::abs(e)), e);
1100  else
1101  e_log = 0.01;
1102 
1103  return e_log;
1104 }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::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 67 of file AthReentrantAlgorithm.cxx.

68 {
69  return Gaudi::Algorithm::sysExecute (ctx);
70 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::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 96 of file AthReentrantAlgorithm.cxx.

96  {
98 
99  if (sc.isFailure()) {
100  return sc;
101  }
102 
103  ServiceHandle<ICondSvc> cs("CondSvc",name());
104  for (auto h : outputHandles()) {
105  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
106  // do this inside the loop so we don't create the CondSvc until needed
107  if ( cs.retrieve().isFailure() ) {
108  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
109  return StatusCode::SUCCESS;
110  }
111  if (cs->regHandle(this,*h).isFailure()) {
112  sc = StatusCode::FAILURE;
113  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
114  << " with CondSvc");
115  }
116  }
117  }
118  return sc;
119 }

◆ 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 194 of file AthMonitorAlgorithm.cxx.

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

◆ 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 971 of file TrigMETMonitorAlgorithm.py.

◆ file

TrigMETMonitorAlgorithm.file

Definition at line 960 of file TrigMETMonitorAlgorithm.py.

◆ Files

TrigMETMonitorAlgorithm.Files

Definition at line 962 of file TrigMETMonitorAlgorithm.py.

◆ flags

TrigMETMonitorAlgorithm.flags

Definition at line 961 of file TrigMETMonitorAlgorithm.py.

◆ HISTFileName

TrigMETMonitorAlgorithm.HISTFileName

Definition at line 964 of file TrigMETMonitorAlgorithm.py.

◆ isMC

TrigMETMonitorAlgorithm.isMC

Definition at line 963 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 AthReentrantAlgorithm::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.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 959 of file TrigMETMonitorAlgorithm.py.

◆ trigMETMonitorAcc

TrigMETMonitorAlgorithm.trigMETMonitorAcc

Definition at line 974 of file TrigMETMonitorAlgorithm.py.

◆ withDetails

TrigMETMonitorAlgorithm.withDetails

Definition at line 979 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:1094
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
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
checkFileSG.line
line
Definition: checkFileSG.py:75
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
SGout2dot.alg
alg
Definition: SGout2dot.py:243
get_generator_info.result
result
Definition: get_generator_info.py:21
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
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:70
TrigMETMonitorAlgorithm::m_hlt_cell_met_key
SG::ReadHandleKey< xAOD::TrigMissingETContainer > m_hlt_cell_met_key
Definition: TrigMETMonitorAlgorithm.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
accumulate
bool accumulate(AccumulateMap &map, std::vector< module_t > const &modules, FPGATrackSimMatrixAccumulator const &acc)
Accumulates an accumulator (e.g.
Definition: FPGATrackSimMatrixAccumulator.cxx:22
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:189
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
This class provides conversion from CSC RDO data to CSC Digits.
Definition: TrackSystemController.h:49
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
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:83
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition: AthMonitorAlgorithm.cxx:194
AthMonitorAlgorithm::Environment_t::user
@ user
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
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
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
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
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.
sim_rttUpdate.user
def user
Definition: sim_rttUpdate.py:662
lumiFormat.i
int i
Definition: lumiFormat.py:92
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
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:113
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
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:571
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
AthReentrantAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
Definition: AthReentrantAlgorithm.h:153
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:195
AthMonitorAlgorithm::Environment_t::tier0ESD
@ tier0ESD
AthMonitorAlgorithm::Environment_t::altprod
@ altprod
AthReentrantAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthReentrantAlgorithm.cxx:96
AtlCoolConsole.tool
tool
Definition: AtlCoolConsole.py:453
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition: AthMonitorAlgorithm.h:372
item
Definition: ItemListSvc.h:43
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:157
ATH_LIKELY
#define ATH_LIKELY(x)
Definition: AthUnlikelyMacros.h:16
Trk::vertex
@ vertex
Definition: MeasurementType.h:21
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
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
python.CaloScaleNoiseConfig.str
str
Definition: CaloScaleNoiseConfig.py:78
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:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
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:790
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 .
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
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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