ATLAS Offline Software
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
TrigEgammaMonitorAnalysisAlgorithm Class Reference

#include <TrigEgammaMonitorAnalysisAlgorithm.h>

Inheritance diagram for TrigEgammaMonitorAnalysisAlgorithm:
Collaboration diagram for TrigEgammaMonitorAnalysisAlgorithm:

Public Types

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

Public Member Functions

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

Protected Member Functions

void fillLabel (const ToolHandle< GenericMonitoringTool > &groupHandle, const std::string &histname, const std::string &label) const
void fillEfficiencies (const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &, const bool) const
void fillDistributions (const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &) const
void fillResolutions (const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
 ***********************************************************************************************************************8
void fillInefficiency (const std::string &pidword, const TrigInfo &info, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const std::vector< asg::AcceptData > &acceptObjs) const
const std::map< std::string, TrigInfo > & getTrigInfoMap () const
 Helper methods.
const std::map< std::string, TrigInfo > & getTrigInfoMapR3 () const
bool ApplyElectronPid (const EventContext &ctx, const xAOD::Electron *eg, const std::string &) const
 Get offline electron decision.
bool ApplyPhotonPid (const EventContext &ctx, const xAOD::Photon *eg, const std::string &) const
 Get offline electron decision.
const ToolHandle< Trig::TrigDecisionTool > & tdt () const
 Get the TDT.
const ToolHandle< TrigEgammaMatchingToolMT > & match () const
 Get the e/g match tool.
const ToolHandle< Trig::IMatchingTool > & matchR3 () const
asg::AcceptData setAccept (const TrigCompositeUtils::Decision *, const TrigInfo &, const bool) const
 Set the accept object for all trigger levels.
TrigInfo getTrigInfo (const std::string &) const
 Get the trigger info parsed from the chain name (only single lepton triggers).
TrigInfo getTrigInfoR3 (const std::string &) const
float dR (const float, const float, const float, const float) const
 Get delta R.
std::string getL1Item (const std::string &trigger) const
 Creates static map to return L1 item from trigger name.
bool isIsolated (const xAOD::Electron *, const std::string &) const
 Check if electron fulfils isolation criteria.
bool isPrescaled (const std::string &) const
 Check if the event is prescaled.
void setTrigInfo (const std::string &)
 Set the trigger info parsed from the chain name.
void setTrigInfoR3 (const std::string &)
bool isHLTTruncated () const
float getEta2 (const xAOD::Egamma *eg) const
 Features helper.
float getEt (const xAOD::Electron *eg) const
float getEtCluster37 (const xAOD::Egamma *eg) const
float getDEmaxs1 (const xAOD::Egamma *eg) const
float rTRT (const xAOD::Electron *eg) const
float getSigmaD0 (const xAOD::Electron *eg) const
float getD0sig (const xAOD::Electron *eg) const
float getEnergyBE0 (const xAOD::Egamma *eg) const
float getEnergyBE1 (const xAOD::Egamma *eg) const
float getEnergyBE2 (const xAOD::Egamma *eg) const
float getEnergyBE3 (const xAOD::Egamma *eg) const
float getEaccordion (const xAOD::Egamma *eg) const
float getE0Eaccordion (const xAOD::Egamma *eg) const
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution
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.

Protected Attributes

ToolHandle< TrigEgammaMatchingToolMT > m_matchTool
ToolHandle< Trig::IMatchingTool > m_matchTool_R3
ToolHandle< Trig::TrigEgammaEmulationToolMT > m_emulatorTool
ToolHandleArray< IAsgElectronIsEMSelector > m_electronIsEMTool {this,"ElectronIsEMSelector",{}}
 Offline isEM Selectors.
ToolHandleArray< IAsgElectronLikelihoodTool > m_electronLHTool {this,"ElectronLikelihoodTool",{}}
 Offline LH Selectors.
ToolHandleArray< IAsgElectronLikelihoodTool > m_electronDNNTool { this, "ElectronDNNSelectorTool", {},"DNN tools" }
 Offline DNN Selectors.
ToolHandleArray< IAsgPhotonIsEMSelector > m_photonIsEMTool {this,"PhotonIsEMSelector",{}}
 Offline isEM Photon Selectors.
Gaudi::Property< bool > m_doEmulation {this, "DoEmulation", false }
 Do emulation.
Gaudi::Property< bool > m_doEffwithLH {this, "ComputeEffLH", false}
Gaudi::Property< bool > m_doEffwithDNN {this, "ComputeEffDNN", false}
Gaudi::Property< bool > m_tp {this, "TPTrigger", false }
 TP Trigger Analysis.
Gaudi::Property< std::string > m_defaultProbePidElectron {this, "DefaultProbeSelectionElectron", "lhloose"}
 default probe pid for electron trigitems that don't have pid in their name
Gaudi::Property< std::string > m_defaultProbePidPhoton {this, "DefaultProbeSelectionPhoton", "loose"}
 default probe pid for photon trigitems that don't have pid in their name
Gaudi::Property< std::vector< std::string > > m_isemname {this, "isEMResultNames", {} }
 isem names
Gaudi::Property< std::vector< std::string > > m_lhname {this, "LHResultNames", {} }
 lh names
Gaudi::Property< std::vector< std::string > > m_dnnname {this, "DNNResultNames", {}, }
 dnn names
Gaudi::Property< bool > m_detailedHists {this, "DetailedHistograms", false}
 Include more detailed histograms.
asg::AcceptInfo m_accept
ToolHandleArray< GenericMonitoringTool > m_tools {this,"GMTools",{}}
 Array of Generic Monitoring Tools.
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
 Tool to tell whether a specific trigger is passed.
ToolHandleArray< IDQFilterTool > m_DQFilterTools {this,"FilterTools",{}}
 Array of Data Quality filter tools.
SG::ReadCondHandleKey< LuminosityCondData > m_lumiDataKey {this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"}
SG::ReadCondHandleKey< LBDurationCondData > m_lbDurationDataKey {this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"}
SG::ReadCondHandleKey< TrigLiveFractionCondData > m_trigLiveFractionDataKey {this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"}
AthMonitorAlgorithm::Environment_t m_environment
 Instance of the Environment_t enum.
AthMonitorAlgorithm::DataType_t m_dataType
 Instance of the DataType_t enum.
Gaudi::Property< std::string > m_environmentStr {this,"Environment","user"}
 Environment string pulled from the job option and converted to enum.
Gaudi::Property< std::string > m_dataTypeStr {this,"DataType","userDefined"}
 DataType string pulled from the job option and converted to enum.
Gaudi::Property< std::string > m_triggerChainString {this,"TriggerChain",""}
 Trigger chain string pulled from the job option and parsed into a vector.
std::vector< std::string > m_vTrigChainNames
 Vector of trigger chain names parsed from trigger chain string.
Gaudi::Property< std::string > m_fileKey {this,"FileKey",""}
 Internal Athena name for file.
Gaudi::Property< bool > m_useLumi {this,"EnableLumi",false}
 Allows use of various luminosity functions.
Gaudi::Property< float > m_defaultLBDuration {this,"DefaultLBDuration",60.}
 Default duration of one lumi block.
Gaudi::Property< int > m_detailLevel {this,"DetailLevel",0}
 Sets the level of detail used in the monitoring.
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey {this,"EventInfoKey","EventInfo"}
 Key for retrieving EventInfo from StoreGate.

Private Types

typedef std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > MonVarVec_t
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t

Private Member Functions

void fillEfficiency (const EventContext &ctx, const std::string &subgroup, const std::string &level, const std::string &pidword, const TrigInfo &info, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const std::vector< asg::AcceptData > &acceptObjs, const std::string &dirname) const
void fillL1Calo (const std::string &trigger, const std::vector< const xAOD::EmTauRoI * > &l1_vec) const
void fillL1eEM (const std::string &trigger, const std::vector< const xAOD::eFexEMRoI * > &l1_vec) const
void fillL2Calo (const std::string &trigger, const std::vector< const xAOD::TrigEMCluster * > &emCluster_vec) const
void fillL2Electron (const std::string &trigger, const std::vector< const xAOD::TrigElectron * > &el_vec) const
void fillL2Photon (const std::string &trigger, const std::vector< const xAOD::TrigPhoton * > &eg_vec) const
void fillEFCalo (const std::string &trigger, const std::vector< const xAOD::CaloCluster * > &clus_vec) const
void fillShowerShapes (const std::string &trigger, const std::vector< const xAOD::Egamma * > &eg_vec, bool online) const
void fillTracking (const EventContext &ctx, const std::string &trigger, const std::vector< const xAOD::Electron * > &eg_vec, bool online) const
void fillL1CaloResolution (const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > &pairObjs) const
void fillL1CaloAbsResolution (const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > &pairObjs) const
void fillL2CaloResolution (const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs) const
void fillHLTElectronResolution (const EventContext &ctx, const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
void fillHLTPhotonResolution (const EventContext &ctx, const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes

ToolHandle< Trig::TrigDecisionTool > m_trigdec
 Trigger decision tool.
std::map< std::string, TrigInfo > m_trigInfo
 creates map of trigger name and TrigInfo struct
std::map< std::string, TrigInfo > m_trigInfoR3
std::string m_name
std::unordered_map< std::string, size_t > m_toolLookupMap
const ToolHandle< GenericMonitoringTool > m_dummy
Gaudi::Property< bool > m_enforceExpressTriggers
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 10 of file TrigEgammaMonitorAnalysisAlgorithm.h.

Member Typedef Documentation

◆ MonVarVec_t

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

Definition at line 370 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 class 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 194 of file AthMonitorAlgorithm.h.

194 {
195 userDefined = 0,
196 monteCarlo,
197 collisions,
198 cosmics,
199 heavyIonCollisions,
200 };
python.BuildSignatureFlags.cosmics
AthConfigFlags cosmics(AthConfigFlags flags, str instanceName, str recoMode)
Definition BuildSignatureFlags.py:597

◆ Environment_t

enum class 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 175 of file AthMonitorAlgorithm.h.

175 {
176 user = 0,
177 online,
178 tier0,
179 tier0Raw,
180 tier0ESD,
181 AOD,
182 altprod,
183 };

Constructor & Destructor Documentation

◆ TrigEgammaMonitorAnalysisAlgorithm()

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

Definition at line 8 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

8 :
9 TrigEgammaMonitorBaseAlgorithm( name, pSvcLocator )
10
11{}
TrigEgammaMonitorBaseAlgorithm::TrigEgammaMonitorBaseAlgorithm
TrigEgammaMonitorBaseAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition TrigEgammaMonitorBaseAlgorithm.cxx:9

◆ ~TrigEgammaMonitorAnalysisAlgorithm()

TrigEgammaMonitorAnalysisAlgorithm::~TrigEgammaMonitorAnalysisAlgorithm ( )
overridevirtual

Definition at line 13 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

14{}

Member Function Documentation

◆ ApplyElectronPid()

bool TrigEgammaMonitorBaseAlgorithm::ApplyElectronPid ( const EventContext & ctx,
const xAOD::Electron * eg,
const std::string & pidname ) const
protectedinherited

Get offline electron decision.

Definition at line 49 of file TrigEgammaMonitorBaseAlgorithm.cxx.

50{
51 if (pidname == "tight"){
52 return (bool) this->m_electronIsEMTool[0]->accept(ctx,eg);
53 }
54 else if (pidname == "medium"){
55 return (bool) this->m_electronIsEMTool[1]->accept(ctx,eg);
56 }
57 else if (pidname == "loose"){
58 return (bool) this->m_electronIsEMTool[2]->accept(ctx,eg);
59 }
60 else if (pidname == "lhtight"){
61 if (!m_doEffwithDNN) return (bool) this->m_electronLHTool[0]->accept(ctx,eg);
62 else return (bool) this->m_electronDNNTool[0]->accept(ctx,eg);
63 }
64 else if (pidname == "lhmedium"){
65 if (!m_doEffwithDNN) return (bool) this->m_electronLHTool[1]->accept(ctx,eg);
66 else return (bool) this->m_electronDNNTool[1]->accept(ctx,eg);
67 }
68 else if (pidname == "lhloose"){
69 if (!m_doEffwithDNN) return (bool) this->m_electronLHTool[2]->accept(ctx,eg);
70 else return (bool) this->m_electronDNNTool[2]->accept(ctx,eg);
71 }
72 else if (pidname == "lhvloose"){
73 return (bool) this->m_electronLHTool[3]->accept(ctx,eg);
74 }
75 else if (pidname == "dnntight"){
76 if (!m_doEffwithLH) return (bool) this->m_electronDNNTool[0]->accept(ctx,eg);
77 else return (bool) this->m_electronLHTool[0]->accept(ctx,eg);
78 }
79 else if (pidname == "dnnmedium"){
80 if (!m_doEffwithLH) return (bool) this->m_electronDNNTool[1]->accept(ctx,eg);
81 else return (bool) this->m_electronLHTool[1]->accept(ctx,eg);
82 }
83 else if (pidname == "dnnloose"){
84 if (!m_doEffwithLH) return (bool) this->m_electronDNNTool[2]->accept(ctx,eg);
85 else return (bool) this->m_electronLHTool[2]->accept(ctx,eg);
86 }
87 else ATH_MSG_DEBUG("No Pid tool, continue without PID");
88 return false;
89}
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
TrigEgammaMonitorBaseAlgorithm::m_electronLHTool
ToolHandleArray< IAsgElectronLikelihoodTool > m_electronLHTool
Offline LH Selectors.
Definition TrigEgammaMonitorBaseAlgorithm.h:104
TrigEgammaMonitorBaseAlgorithm::m_electronIsEMTool
ToolHandleArray< IAsgElectronIsEMSelector > m_electronIsEMTool
Offline isEM Selectors.
Definition TrigEgammaMonitorBaseAlgorithm.h:102
TrigEgammaMonitorBaseAlgorithm::m_electronDNNTool
ToolHandleArray< IAsgElectronLikelihoodTool > m_electronDNNTool
Offline DNN Selectors.
Definition TrigEgammaMonitorBaseAlgorithm.h:106

◆ ApplyPhotonPid()

bool TrigEgammaMonitorBaseAlgorithm::ApplyPhotonPid ( const EventContext & ctx,
const xAOD::Photon * eg,
const std::string & pidname ) const
protectedinherited

Get offline electron decision.

Definition at line 96 of file TrigEgammaMonitorBaseAlgorithm.cxx.

97{
98 if (pidname == "tight"){
99 return (bool) this->m_photonIsEMTool[0]->accept(ctx,eg);
100 }
101 else if (pidname == "medium"){
102 return (bool) this->m_photonIsEMTool[1]->accept(ctx,eg);
103 }
104 else if (pidname == "loose"){
105 return (bool) this->m_photonIsEMTool[2]->accept(ctx,eg);
106 }
107 else ATH_MSG_DEBUG("No Pid tool, continue without PID");
108 return false;
109}
TrigEgammaMonitorBaseAlgorithm::m_photonIsEMTool
ToolHandleArray< IAsgPhotonIsEMSelector > m_photonIsEMTool
Offline isEM Photon Selectors.
Definition TrigEgammaMonitorBaseAlgorithm.h:108

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

62{
63 return 0;
64}

◆ 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 224 of file AthMonitorAlgorithm.h.

224{ return m_dataType; }
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition AthMonitorAlgorithm.h:356

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

144 {
145 // convert the string to all lowercase
146 std::string lowerCaseStr = str;
147 std::transform(lowerCaseStr.begin(), lowerCaseStr.end(), lowerCaseStr.begin(), ::tolower);
148
149 // check if it matches one of the enum choices
150 if( lowerCaseStr == "userdefined" ) {
151 return DataType_t::userDefined;
152 } else if( lowerCaseStr == "montecarlo" ) {
153 return DataType_t::monteCarlo;
154 } else if( lowerCaseStr == "collisions" ) {
155 return DataType_t::collisions;
156 } else if( lowerCaseStr == "cosmics" ) {
157 return DataType_t::cosmics;
158 } else if( lowerCaseStr == "heavyioncollisions" ) {
159 return DataType_t::heavyIonCollisions;
160 } else { // otherwise, warn the user and return "userDefined"
161 ATH_MSG_WARNING("AthMonitorAlgorithm::dataTypeStringToEnum(): Unknown data type "
162 <<str<<", returning userDefined.");
163 return DataType_t::userDefined;
164 }
165}
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
tolower
void tolower(std::string &s)
Definition AthenaSummarySvc.cxx:108

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

158 {
159 return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160 hndl.value(),
161 hndl.documentation());
162
163 }
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
147 return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148 }
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition AthCommonDataStore.h:156

◆ 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; }

◆ dR()

float TrigEgammaMonitorBaseAlgorithm::dR ( const float eta1,
const float phi1,
const float eta2,
const float phi2 ) const
protectedinherited

Get delta R.

Definition at line 296 of file TrigEgammaMonitorBaseAlgorithm.cxx.

296 {
297 float deta = fabs(eta1 - eta2);
298 float dphi = fabs(phi1 - phi2) < TMath::Pi() ? fabs(phi1 - phi2) : 2*TMath:: \
299 Pi() - fabs(phi1 - phi2);
300 return sqrt(deta*deta + dphi*dphi);
301}
Pi
static const double Pi
Definition LArCellBinning.cxx:17

◆ 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 208 of file AthMonitorAlgorithm.h.

208{ return m_environment; }
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition AthMonitorAlgorithm.h:355

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

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

◆ evtStore()

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; }

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

77 {
78
79 // Checks that all of the DQ filters are passed. If any one of the filters
80 // fails, return SUCCESS code and do not fill the histograms with the event.
81 for ( const auto& filterItr : m_DQFilterTools ) {
82 if (!filterItr->accept(ctx)) {
83 ATH_MSG_DEBUG("Event rejected due to filter tool.");
84 return StatusCode::SUCCESS;
85 }
86 }
87
88 // Trigger: If there is a decision tool and the chains fail, skip the event.
89 if ( !m_trigDecTool.empty() && !trigChainsArePassed(m_vTrigChainNames) ) {
90 ATH_MSG_DEBUG("Event rejected due to trigger filter.");
91 return StatusCode::SUCCESS;
92 }
93
94 ATH_MSG_DEBUG("Event accepted!");
95 return fillHistograms(ctx);
96}
AthMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const =0
adds event to the monitoring histograms
AthMonitorAlgorithm::trigChainsArePassed
bool trigChainsArePassed(const std::vector< std::string > &vTrigNames) const
Check whether triggers are passed.
Definition AthMonitorAlgorithm.cxx:208
AthMonitorAlgorithm::m_vTrigChainNames
std::vector< std::string > m_vTrigChainNames
Vector of trigger chain names parsed from trigger chain string.
Definition AthMonitorAlgorithm.h:361
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition AthMonitorAlgorithm.h:345
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition AthMonitorAlgorithm.h:346

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

88{
89 // If we didn't find any symlinks to add, just return the collection
90 // from the base class. Otherwise, return the extended collection.
91 if (!m_extendedExtraObjects.empty()) {
92 return m_extendedExtraObjects;
93 }
94 return BaseAlg::extraOutputDeps();
95}
AthCommonReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition AthCommonReentrantAlgorithm.h:40

◆ fillDistributions()

void TrigEgammaMonitorAnalysisAlgorithm::fillDistributions ( const EventContext & ctx,
const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs,
const TrigInfo & info ) const
protected

Definition at line 440 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

442{
443
444 const std::string trigger = info.trigger;
445
446 unsigned int condition=TrigDefs::Physics;
447
448 // Offline
449 std::vector<const xAOD::Egamma*> eg_vec;
450 std::vector<const xAOD::Electron*> el_vec;
451 for( auto pairObj: pairObjs )
452 {
453 eg_vec.push_back(pairObj.first);
454 if( xAOD::EgammaHelpers::isElectron(pairObj.first)){
455 const xAOD::Electron* elOff = static_cast<const xAOD::Electron*> (pairObj.first);
456 el_vec.push_back(elOff);
457 }
458 }
459
460 // Offline
461 fillShowerShapes( trigger, eg_vec, false );
462 fillTracking( ctx, trigger, el_vec, false );
463
464 // L1Calo
465 {
466 // Fill L1 features
467 auto initRois = tdt()->features<TrigRoiDescriptorCollection>(trigger,condition,"",TrigDefs::allFeaturesOfType,"initialRoI");
468
469 if (info.L1Legacy){
470 std::vector<const xAOD::EmTauRoI*> l1_vec;
471 for( auto &initRoi: initRois ){
472 if( !initRoi.link.isValid() ) continue;
473 const auto *feat = match()->getL1Feature( initRoi.source );
474 if(feat) l1_vec.push_back(feat);
475 }
476 fillL1Calo( trigger, l1_vec );
477 }else{
478 std::vector<const xAOD::eFexEMRoI*> l1_vec;
479 for( auto &initRoi: initRois ){
480 if( !initRoi.link.isValid() ) continue;
481 const auto *feat = match()->getL1eEMFeature( initRoi.source );
482 if(feat) l1_vec.push_back(feat);
483 }
484 fillL1eEM( trigger, l1_vec );
485 }
486
487 }
488
489
490 // L2Calo
491 {
492 std::vector<const xAOD::TrigEMCluster*> emCluster_vec;
493 auto vec = tdt()->features<xAOD::TrigEMClusterContainer>(trigger,condition ,match()->key("FastCalo") );
494 for(auto &featLinkInfo : vec ){
495 if(! featLinkInfo.isValid() ) continue;
496 const auto *feat = *(featLinkInfo.link);
497 if(!feat) continue;
498 emCluster_vec.push_back(feat);
499 }
500 fillL2Calo( trigger, emCluster_vec );
501 }
502 // EFCalo
503 {
504 std::string key = match()->key("PrecisionCalo_Electron");
505 if(info.signature == "Photon" or info.signature == "g") key = match()->key("PrecisionCalo_Photon");
506 if(info.lrt) key = match()->key("PrecisionCalo_LRT");
507 if(info.ion) key = match()->key("PrecisionCalo_HI");
508
509 std::vector<const xAOD::CaloCluster* > clus_vec;
510 auto vec = tdt()->features<xAOD::CaloClusterContainer>(trigger,condition,key);
511 for(auto &featLinkInfo : vec ){
512 if(! featLinkInfo.isValid() ) continue;
513 const auto *feat = *(featLinkInfo.link);
514 if(!feat) continue;
515 clus_vec.push_back(feat);
516 }
517 fillEFCalo( trigger, clus_vec );
518 }
519
520 if ( info.signature == "Electron" or info.signature == "e" ){
521
522 // L2 Electron
523 {
524 std::string key = match()->key("FastElectrons");
525 if(info.lrt) key = match()->key("FastElectrons_LRT");
526
527 std::vector<const xAOD::TrigElectron*> el_vec;
528 // Get only passed objects
529 auto vec = tdt()->features<xAOD::TrigElectronContainer>(trigger,condition,key );
530 for( auto &featLinkInfo : vec ){
531 if(! featLinkInfo.isValid() ) continue;
532 const auto *feat = *(featLinkInfo.link);
533 if(!feat) continue;
534 el_vec.push_back(feat);
535 }
536 fillL2Electron( trigger, el_vec );
537 }
538 // HLT Electron
539 {
540 std::string key = match()->key("Electrons_GSF");
541 if(info.nogsf) key = match()->key("Electrons");
542 if(info.lrt) key = match()->key("Electrons_LRT");
543
544 std::vector<const xAOD::Electron*> el_vec;
545 std::vector<const xAOD::Egamma*> eg_vec;
546 auto vec = tdt()->features<xAOD::ElectronContainer>(trigger, condition ,key );
547 for( auto &featLinkInfo : vec ){
548 if(! featLinkInfo.isValid() ) continue;
549 const auto *feat = *(featLinkInfo.link);
550 if(!feat) continue;
551 el_vec.push_back(feat);
552 eg_vec.push_back(feat);
553 }
554 fillShowerShapes( trigger, eg_vec, true );
555 fillTracking( ctx, trigger, el_vec, true );
556 }
557 }else if ( info.signature == "Photon" or info.signature == "g"){
558 // Fast Photon
559 {
560 std::string key = match()->key("FastPhotons");
561 std::vector<const xAOD::TrigPhoton*> ph_vec;
562 // Get only passed objects
563 auto vec = tdt()->features<xAOD::TrigPhotonContainer>(trigger,condition,key );
564 for( auto &featLinkInfo : vec ){
565 if(! featLinkInfo.isValid() ) continue;
566 const auto *feat = *(featLinkInfo.link);
567 if(!feat) continue;
568 ph_vec.push_back(feat);
569 }
570 fillL2Photon( trigger, ph_vec );
571 }
572
573 // HLT Photon
574 {
575 std::vector<const xAOD::Egamma*> ph_vec;
576 auto vec = tdt()->features<xAOD::PhotonContainer>(trigger,condition ,match()->key("Photons") );
577 for( auto &featLinkInfo : vec ){
578 if(! featLinkInfo.isValid() ) continue;
579 const auto *feat = *(featLinkInfo.link);
580 if(!feat) continue;
581 ph_vec.push_back(feat);
582 }
583 fillShowerShapes( trigger, ph_vec, true );
584 }
585 }else{
586 ATH_MSG_INFO( "Chain type not specified" );
587 }
588
589}
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
TrigRoiDescriptorCollection
Athena::TPCnvVers::Current Athena::TPCnvVers::Old TrigRoiDescriptorCollection
Definition TrigSteeringEventTPCnv.cxx:78
TrigEgammaMonitorAnalysisAlgorithm::fillTracking
void fillTracking(const EventContext &ctx, const std::string &trigger, const std::vector< const xAOD::Electron * > &eg_vec, bool online) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:855
TrigEgammaMonitorAnalysisAlgorithm::fillEFCalo
void fillEFCalo(const std::string &trigger, const std::vector< const xAOD::CaloCluster * > &clus_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:730
TrigEgammaMonitorAnalysisAlgorithm::fillShowerShapes
void fillShowerShapes(const std::string &trigger, const std::vector< const xAOD::Egamma * > &eg_vec, bool online) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:785
TrigEgammaMonitorAnalysisAlgorithm::fillL2Calo
void fillL2Calo(const std::string &trigger, const std::vector< const xAOD::TrigEMCluster * > &emCluster_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:654
TrigEgammaMonitorAnalysisAlgorithm::fillL1eEM
void fillL1eEM(const std::string &trigger, const std::vector< const xAOD::eFexEMRoI * > &l1_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:623
TrigEgammaMonitorAnalysisAlgorithm::fillL2Photon
void fillL2Photon(const std::string &trigger, const std::vector< const xAOD::TrigPhoton * > &eg_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:705
TrigEgammaMonitorAnalysisAlgorithm::fillL2Electron
void fillL2Electron(const std::string &trigger, const std::vector< const xAOD::TrigElectron * > &el_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:681
TrigEgammaMonitorAnalysisAlgorithm::fillL1Calo
void fillL1Calo(const std::string &trigger, const std::vector< const xAOD::EmTauRoI * > &l1_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:594
TrigEgammaMonitorBaseAlgorithm::match
const ToolHandle< TrigEgammaMatchingToolMT > & match() const
Get the e/g match tool.
Definition TrigEgammaMonitorBaseAlgorithm.h:148
TrigEgammaMonitorBaseAlgorithm::tdt
const ToolHandle< Trig::TrigDecisionTool > & tdt() const
Get the TDT.
Definition TrigEgammaMonitorBaseAlgorithm.h:145
TrigDefs::allFeaturesOfType
static const unsigned int allFeaturesOfType
Run 3 "enum". Return all features along legs (still with type and container checks).
Definition TrigEvent/TrigDecisionInterface/TrigDecisionInterface/Conditions.h:70
TrigSteeringEventDict::l1_vec
std::vector< LVL1CTP::Lvl1Item * > l1_vec
Definition TrigSteeringEventDict.h:40
xAOD::EgammaHelpers::isElectron
bool isElectron(const xAOD::Egamma *eg)
is the object an electron (not Fwd)
Definition EgammaxAODHelpers.cxx:12
xAOD::PhotonContainer
PhotonContainer_v1 PhotonContainer
Definition of the current "photon container version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/PhotonContainer.h:17
xAOD::TrigElectronContainer
TrigElectronContainer_v1 TrigElectronContainer
Declare the latest version of the container.
Definition Event/xAOD/xAODTrigEgamma/xAODTrigEgamma/TrigElectronContainer.h:17
xAOD::ElectronContainer
ElectronContainer_v1 ElectronContainer
Definition of the current "electron container version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/ElectronContainer.h:17
xAOD::TrigEMClusterContainer
TrigEMClusterContainer_v1 TrigEMClusterContainer
Define the latest version of the trigger EM cluster container.
Definition Event/xAOD/xAODTrigCalo/xAODTrigCalo/TrigEMClusterContainer.h:17
xAOD::TrigPhotonContainer
TrigPhotonContainer_v1 TrigPhotonContainer
Declare the latest version of the container.
Definition Event/xAOD/xAODTrigEgamma/xAODTrigEgamma/TrigPhotonContainer.h:17
xAOD::CaloClusterContainer
CaloClusterContainer_v1 CaloClusterContainer
Define the latest version of the calorimeter cluster container.
Definition Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloClusterContainer.h:17
xAOD::Electron
Electron_v1 Electron
Definition of the current "egamma version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/Electron.h:17

◆ fillEFCalo()

void TrigEgammaMonitorAnalysisAlgorithm::fillEFCalo ( const std::string & trigger,
const std::vector< const xAOD::CaloCluster * > & clus_vec ) const
private

Definition at line 730 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

731{
732
733 auto monGroup = getGroup( trigger + "_Distributions_EFCalo" );
734
735
736 std::vector<float> energyBE0_vec, energyBE1_vec, energyBE2_vec, energyBE3_vec,
737 energy_vec, et_vec, eta_vec, phi_vec, eta_calo_vec, phi_calo_vec, highet_vec;
738
739
740
741 auto energyBE0_col = Monitored::Collection("energyBE0", energyBE0_vec);
742 auto energyBE1_col = Monitored::Collection("energyBE1", energyBE1_vec);
743 auto energyBE2_col = Monitored::Collection("energyBE2", energyBE2_vec);
744 auto energyBE3_col = Monitored::Collection("energyBE3", energyBE3_vec);
745 auto energy_col = Monitored::Collection("energy" , energy_vec );
746 auto et_col = Monitored::Collection("et" , et_vec );
747 auto highet_col = Monitored::Collection("highet" , highet_vec );
748 auto eta_col = Monitored::Collection("eta" , eta_vec );
749 auto phi_col = Monitored::Collection("phi" , phi_vec );
750 auto eta_calo_col = Monitored::Collection("eta_calo" , eta_calo_vec );
751 auto phi_calo_col = Monitored::Collection("phi_calo" , phi_calo_vec );
752
753 for ( const auto *clus : clus_vec )
754 {
755 double tmpeta = -999.;
756 if(!clus->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta))
757 tmpeta=-999.;
758 double tmpphi = -999.;
759 if(!clus->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi))
760 tmpphi=-999.;
761
762 energyBE0_vec.push_back( clus->energyBE(0)/Gaudi::Units::GeV );
763 energyBE1_vec.push_back( clus->energyBE(1)/Gaudi::Units::GeV );
764 energyBE2_vec.push_back( clus->energyBE(2)/Gaudi::Units::GeV );
765 energyBE3_vec.push_back( clus->energyBE(3)/Gaudi::Units::GeV );
766 energy_vec.push_back( clus->e()/Gaudi::Units::GeV );
767 et_vec.push_back( clus->et()/Gaudi::Units::GeV );
768 highet_vec.push_back( clus->et()/Gaudi::Units::GeV );
769 eta_vec.push_back( clus->eta() );
770 phi_vec.push_back( clus->phi() );
771 eta_calo_vec.push_back( tmpeta );
772 phi_calo_vec.push_back( tmpphi );
773
774 }
775
776
777 fill( monGroup, energyBE0_col, energyBE1_col, energyBE2_col, energyBE3_col,
778 energy_col, et_col, eta_col, phi_col, eta_calo_col, phi_calo_col, highet_col);
779}
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition AthMonitorAlgorithm.cxx:168
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma).
Definition CaloCluster_v1.h:190
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma).
Definition CaloCluster_v1.h:191
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.
Definition AthMonitorAlgorithm.cxx:99
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition MonitoredCollection.h:38
python.TIDAMonTool.monGroup
monGroup(analysis_chain)
Definition TIDAMonTool.py:324

◆ fillEfficiencies()

void TrigEgammaMonitorAnalysisAlgorithm::fillEfficiencies ( const EventContext & ctx,
const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs,
const TrigInfo & info,
const bool onlyHLT ) const
protected

Definition at line 42 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

45{
46
47 std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_vec;
48 std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_iso_vec;
49
50 std::vector<asg::AcceptData> accept_vec;
51 std::vector<asg::AcceptData> accept_iso_vec;
52
53 std::vector<asg::AcceptData> emu_accept_vec;
54 std::vector<asg::AcceptData> emu_accept_iso_vec;
55
56 ATH_MSG_DEBUG("Inside fillEfficiencies: pairObject which is passed to function is: " << pairObjs.size());
57
58 for( auto pairObj : pairObjs ){
59
60 ATH_MSG_DEBUG("Print decision = " << pairObj.second);
61 if(pairObj.first->type()==xAOD::Type::Electron){
62 auto passBits=tdt()->isPassedBits(info.trigger);
63 if(!((passBits & TrigDefs::L1_isPassedAfterVeto) && ((passBits & TrigDefs::EF_prescaled)==0))){
64 ATH_MSG_DEBUG("Prescaled trigger: " << info.trigger << " Skipping to normalize efficiencies");
65 continue;
66 }
67 const xAOD::Electron* el = static_cast<const xAOD::Electron *> (pairObj.first);
68 float et = getEt(el)/Gaudi::Units::GeV;
69 if(et < info.etthr-5.0) continue;
70
71 }else if(pairObj.first->type()==xAOD::Type::Photon){
72 ATH_MSG_DEBUG("FILL EFFICIENCY IS LOOKING AT PHOTONS");
73 float et = getCluster_et(pairObj.first)/Gaudi::Units::GeV;
74 ATH_MSG_DEBUG("raw cluster et (MeV?) = " << getCluster_et(pairObj.first));
75 ATH_MSG_DEBUG("et: " << et);
76 ATH_MSG_DEBUG("info.etthr: " << info.etthr);
77 if(et < info.etthr-5.0) continue;
78
79 // Applying FixedCutLoose isolation on the offline photon as recommended in the twiki:
80 // https://twiki.cern.ch/twiki/bin/viewauth/AtlasProtected/IsolationSelectionTool#Photons
81 bool pass_CaloIso = getIsolation_topoetcone20(pairObj.first)/getCluster_et(pairObj.first) < 0.065;
82 bool pass_trkIso = getIsolation_ptcone20(pairObj.first)/getCluster_et(pairObj.first) < 0.05;
83
84 ATH_MSG_DEBUG(" pass_CaloIso :" << pass_CaloIso );
85 ATH_MSG_DEBUG(" pass_trkIso :" << pass_trkIso );
86
87 if (!pass_CaloIso || !pass_trkIso){
88 ATH_MSG_DEBUG("Did not passed FixedCutLoose offline isolationFixedCutLoose offline isolation");
89 continue; // pass FixedCutLoose offline isolation
90
91 }
92 } // Offline photon
93
94
95 // Good pair to be measure
96 if(m_doEmulation){ // Emulation
97 bool valid=false;
98 auto acceptData = m_emulatorTool->emulate( pairObj.second, info.trigger , valid);
99 // skip this probe since the emulation is not possible. Avoid diff denominators between emulation and efficiecy
100 if(!valid) {
101 ATH_MSG_DEBUG("Emulation fail. Skip this probe...");
102 continue;
103 }
104 emu_accept_vec.push_back( acceptData );
105 static const SG::Decorator<bool> IsolatedDec("Isolated");
106 if( IsolatedDec(*pairObj.first) ){
107 emu_accept_iso_vec.push_back(acceptData);
108 }
109 }
110
111 // Good pair to be measure
112 { // Efficiency
113 pair_vec.push_back(pairObj);
114 auto acceptData = setAccept( pairObj.second, info, onlyHLT );
115 accept_vec.push_back(acceptData);
116 static const SG::Decorator<bool> IsolatedDec("Isolated");
117 if( IsolatedDec(*pairObj.first) ){
118 pair_iso_vec.push_back(pairObj);
119 accept_iso_vec.push_back(acceptData);
120 }
121 }
122
123
124 }
125
126 std::string dirname= "Efficiency";
127 std::string l2step = "FastElectron";
128 if( info.signature == "Electron" or info.signature == "e" ){
129 l2step = "FastElectron";
130 }else if( info.signature == "Photon" or info.signature == "g" ){
131 l2step = "FastPhoton";
132 }
133 fillEfficiency(ctx, "L1Calo" , "L1Calo" , info.pidname, info, pair_vec , accept_vec, dirname);
134 fillEfficiency(ctx, "FastCalo" , "L2Calo" , info.pidname, info, pair_vec , accept_vec, dirname);
135 fillEfficiency(ctx, l2step , "L2" , info.pidname, info, pair_vec , accept_vec, dirname);
136 fillEfficiency(ctx, "PrecisionCalo" , "EFCalo" , info.pidname, info, pair_vec , accept_vec, dirname);
137 fillEfficiency(ctx, "HLT" , "HLT" , info.pidname, info, pair_vec , accept_vec, dirname);
138
139 ATH_MSG_DEBUG("THE SIZE OF PAIR_VEC IS: " << pair_vec.size());
140 ATH_MSG_DEBUG("THE SIZE OF accept_VEC IS: " << accept_vec.size());
141 ATH_MSG_DEBUG("INFO.PIDNAME: " << info.pidname);
142
143
144 if( m_detailedHists ){
145 for( const auto& pid : m_isemname ){
146 fillEfficiency(ctx, "HLT_" + pid, "HLT", pid, info, pair_vec , accept_vec, dirname);
147 fillEfficiency(ctx, "HLT_" + pid + "Iso", "HLT", pid, info, pair_iso_vec, accept_iso_vec, dirname );
148 }
149 for( const auto& pid : m_lhname ){
150 fillEfficiency(ctx, "HLT_" + pid, "HLT", pid, info, pair_vec, accept_vec, dirname );
151 fillEfficiency(ctx, "HLT_" + pid + "Iso", "HLT", pid, info, pair_iso_vec, accept_iso_vec, dirname );
152 }
153 }
154
155 // Fill emulator efficiency plots
156 if ( m_doEmulation ){
157 dirname= "Emulation";
158 fillEfficiency(ctx, "L1Calo" , "L1Calo" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
159 fillEfficiency(ctx, "FastCalo" , "L2Calo" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
160 fillEfficiency(ctx, l2step , "L2" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
161 fillEfficiency(ctx, "PrecisionCalo" , "EFCalo" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
162 fillEfficiency(ctx, "HLT" , "HLT" , info.pidname, info, pair_vec , emu_accept_vec, dirname);
163 }
164
165 // Fill Inefficiencies
166 fillInefficiency( info.pidname, info, pair_vec , accept_vec);
167
168}
et
float et(const xAOD::jFexSRJetRoI *j)
Definition L1MonitorAdaptors.h:17
TrigEgammaMonitorAnalysisAlgorithm::fillEfficiency
void fillEfficiency(const EventContext &ctx, const std::string &subgroup, const std::string &level, const std::string &pidword, const TrigInfo &info, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const std::vector< asg::AcceptData > &acceptObjs, const std::string &dirname) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:173
TrigEgammaMonitorAnalysisAlgorithm::fillInefficiency
void fillInefficiency(const std::string &pidword, const TrigInfo &info, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const std::vector< asg::AcceptData > &acceptObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:397
TrigEgammaMonitorBaseAlgorithm::m_isemname
Gaudi::Property< std::vector< std::string > > m_isemname
isem names
Definition TrigEgammaMonitorBaseAlgorithm.h:124
TrigEgammaMonitorBaseAlgorithm::m_detailedHists
Gaudi::Property< bool > m_detailedHists
Include more detailed histograms.
Definition TrigEgammaMonitorBaseAlgorithm.h:130
TrigEgammaMonitorBaseAlgorithm::m_doEmulation
Gaudi::Property< bool > m_doEmulation
Do emulation.
Definition TrigEgammaMonitorBaseAlgorithm.h:112
TrigEgammaMonitorBaseAlgorithm::getEt
float getEt(const xAOD::Electron *eg) const
Definition TrigEgammaMonitorBaseAlgorithm.cxx:315
TrigEgammaMonitorBaseAlgorithm::m_lhname
Gaudi::Property< std::vector< std::string > > m_lhname
lh names
Definition TrigEgammaMonitorBaseAlgorithm.h:126
TrigEgammaMonitorBaseAlgorithm::setAccept
asg::AcceptData setAccept(const TrigCompositeUtils::Decision *, const TrigInfo &, const bool) const
Set the accept object for all trigger levels.
Definition TrigEgammaMonitorBaseAlgorithm.cxx:181
TrigEgammaMonitorBaseAlgorithm::m_emulatorTool
ToolHandle< Trig::TrigEgammaEmulationToolMT > m_emulatorTool
Definition TrigEgammaMonitorBaseAlgorithm.h:100
SG::Decorator
SG::Decorator< T, ALLOC > Decorator
Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
Definition AuxElement.h:576
calibdata.valid
list valid
Definition calibdata.py:44
xAODType::Photon
@ Photon
The object is a photon.
Definition ObjectType.h:47
xAODType::Electron
@ Electron
The object is an electron.
Definition ObjectType.h:46
dirname
std::string dirname(std::string name)
Definition utils.cxx:200

◆ fillEfficiency()

void TrigEgammaMonitorAnalysisAlgorithm::fillEfficiency ( const EventContext & ctx,
const std::string & subgroup,
const std::string & level,
const std::string & pidword,
const TrigInfo & info,
const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs,
const std::vector< asg::AcceptData > & acceptObjs,
const std::string & dirname ) const
private

Definition at line 173 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

182{
183 const float etthr = info.etthr;
184 const std::string trigger = info.trigger;
185 auto monGroup = getGroup( trigger + "_"+dirname+"_" + subgroup );
186
187 std::vector<float> et_vec, highet_vec, pt_vec, eta_vec, phi_vec, avgmu_vec, npvtx_vec,et_slice0_vec,et_slice1_vec,et_slice2_vec,et_slice3_vec, ptvarcone20rel_vec, ptvarcone30rel_vec, z0_vec, d0_vec;
188 std::vector<float> match_et_vec, match_highet_vec, match_pt_vec, match_eta_vec, match_phi_vec, match_avgmu_vec, match_npvtx_vec, match_ptvarcone20rel_vec, match_ptvarcone30rel_vec, match_z0_vec, match_d0_vec;
189 std::vector<bool> et_passed_vec, et_failed_vec, highet_passed_vec, highet_failed_vec, pt_passed_vec, eta_passed_vec, eta_failed_vec, phi_passed_vec, avgmu_passed_vec, npvtx_passed_vec;
190 std::vector<bool> ptvarcone20rel_passed_vec, ptvarcone30rel_passed_vec, z0_passed_vec, d0_passed_vec;
191 std::vector<bool> et_slice0_passed_vec,et_slice1_passed_vec,et_slice2_passed_vec,et_slice3_passed_vec;
192
193 auto et_col = Monitored::Collection( "et" , et_vec );
194 auto highet_col = Monitored::Collection( "highet" , highet_vec );
195 auto pt_col = Monitored::Collection( "pt" , pt_vec );
196 auto eta_col = Monitored::Collection( "eta" , eta_vec );
197 auto phi_col = Monitored::Collection( "phi" , phi_vec );
198 auto avgmu_col = Monitored::Collection( "avgmu" , avgmu_vec );
199 auto npvtx_col = Monitored::Collection( "npvtx" , npvtx_vec );
200 auto ptvarcone20rel_col = Monitored::Collection( "ptvarcone20rel" , ptvarcone20rel_vec );
201 auto ptvarcone30rel_col = Monitored::Collection( "ptvarcone30rel" , ptvarcone30rel_vec );
202
203 auto z0_col = Monitored::Collection( "z0" , z0_vec );
204 auto d0_col = Monitored::Collection( "d0" , d0_vec );
205
206 auto match_et_col = Monitored::Collection( "match_et" , match_et_vec );
207 auto match_highet_col = Monitored::Collection( "match_ethigh" , match_highet_vec );
208 auto match_pt_col = Monitored::Collection( "match_pt" , match_pt_vec );
209 auto match_eta_col = Monitored::Collection( "match_eta" , match_eta_vec );
210 auto match_phi_col = Monitored::Collection( "match_phi" , match_phi_vec );
211 auto match_avgmu_col = Monitored::Collection( "match_avgmu" , match_avgmu_vec );
212 auto match_npvtx_col = Monitored::Collection( "match_npvtx" , match_npvtx_vec );
213 auto match_ptvarcone20rel_col = Monitored::Collection( "match_ptvarcone20rel" , match_ptvarcone20rel_vec );
214 auto match_ptvarcone30rel_col = Monitored::Collection( "match_ptvarcone30rel" , match_ptvarcone30rel_vec );
215
216 auto match_z0_col = Monitored::Collection( "match_z0" , match_z0_vec );
217 auto match_d0_col = Monitored::Collection( "match_d0" , match_d0_vec );
218
219 auto et_passed_col = Monitored::Collection( "et_passed" , et_passed_vec );
220 auto et_failed_col = Monitored::Collection( "et_failed" , et_failed_vec );
221 auto highet_passed_col = Monitored::Collection( "highet_passed" , highet_passed_vec );
222 auto highet_failed_col = Monitored::Collection( "highet_failed" , highet_failed_vec );
223 auto pt_passed_col = Monitored::Collection( "pt_passed" , pt_passed_vec );
224 auto eta_passed_col = Monitored::Collection( "eta_passed" , eta_passed_vec );
225 auto eta_failed_col = Monitored::Collection( "eta_failed" , eta_failed_vec );
226 auto phi_passed_col = Monitored::Collection( "phi_passed" , phi_passed_vec );
227 auto avgmu_passed_col = Monitored::Collection( "avgmu_passed" , avgmu_passed_vec );
228 auto npvtx_passed_col = Monitored::Collection( "npvtx_passed" , npvtx_passed_vec );
229 auto ptvarcone20rel_passed_col = Monitored::Collection( "ptvarcone20rel_passed" , ptvarcone20rel_passed_vec );
230 auto ptvarcone30rel_passed_col = Monitored::Collection( "ptvarcone30rel_passed" , ptvarcone30rel_passed_vec );
231
232 auto z0_passed_col = Monitored::Collection( "z0_passed" , z0_passed_vec );
233 auto d0_passed_col = Monitored::Collection( "d0_passed" , d0_passed_vec );
234
235 // For ET efficiency analysis in eta slices
236 auto et_slice0_col = Monitored::Collection( "et_slice0" , et_slice0_vec );
237 auto et_slice1_col = Monitored::Collection( "et_slice1" , et_slice1_vec );
238 auto et_slice2_col = Monitored::Collection( "et_slice2" , et_slice2_vec );
239 auto et_slice3_col = Monitored::Collection( "et_slice3" , et_slice3_vec );
240
241 auto et_slice0_passed_col = Monitored::Collection( "et_slice0_passed" , et_slice0_passed_vec );
242 auto et_slice1_passed_col = Monitored::Collection( "et_slice1_passed" , et_slice1_passed_vec );
243 auto et_slice2_passed_col = Monitored::Collection( "et_slice2_passed" , et_slice2_passed_vec );
244 auto et_slice3_passed_col = Monitored::Collection( "et_slice3_passed" , et_slice3_passed_vec );
245
246 unsigned iObj=0;
247
248 SG::Decorator<bool> pidwordDec("is"+pidword);
249 for( auto pairObj : pairObjs ){
250
251 bool pid=true;
252 bool isPassed = acceptObjs[iObj].getCutResult( level );
253 float et=0.;
254 float ptvarcone20rel = -99.0;
255 float ptvarcone30rel = -99.0;
256 float z0 = -99.0;
257 float d0 = -99.0;
258 const auto *eg = pairObj.first;
259 ATH_MSG_DEBUG("Default pid " << pid << " te " << isPassed);
260 if(xAOD::EgammaHelpers::isElectron(eg)){
261 ATH_MSG_DEBUG("Offline Electron with pidword " << pidword);
262 const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg);
263 pid=pidwordDec(*el);
264 ATH_MSG_DEBUG("Electron pid " << pid);
265 et = getEt(el)/Gaudi::Units::GeV;
266 if (el->pt() > 0) {
267 ptvarcone20rel = getIsolation_ptvarcone20(el)/el->pt();
268 ptvarcone30rel = getIsolation_ptvarcone30(el)/el->pt();
269 }
270 z0 = getTrack_z0(el);
271 d0 = getTrack_d0(el);
272 }
273 else et=eg->caloCluster()->et()/Gaudi::Units::GeV;
274
275 float eta = eg->caloCluster()->etaBE(2);
276 float phi = eg->phi();
277 float pt = eg->pt()/Gaudi::Units::GeV;
278 float avgmu=lbAverageInteractionsPerCrossing( ctx );
279 float npvtx=0.0;
280
281 ATH_MSG_DEBUG("PID decision efficiency " << pidwordDec(*eg));
282
283 if(pid){
284 et_vec.push_back( et );
285 pt_vec.push_back( pt );
286 highet_vec.push_back( et );
287
288 if(et > etthr+1.0){
289 eta_vec.push_back(eta);
290 phi_vec.push_back(phi);
291 avgmu_vec.push_back(avgmu);
292 npvtx_vec.push_back(npvtx);
293 ptvarcone20rel_vec.push_back(ptvarcone20rel);
294 ptvarcone30rel_vec.push_back(ptvarcone30rel);
295 z0_vec.push_back(z0);
296 d0_vec.push_back(d0);
297 }
298
299 if(abs(eta)<=0.8){
300 et_slice0_vec.push_back(et);
301 }else if( abs(eta) > 0.80 && abs(eta) <= 1.37 ){
302 et_slice1_vec.push_back(et);
303 }else if( abs(eta) > 1.37 && abs(eta) <= 1.54 ){
304 et_slice2_vec.push_back(et);
305 }else if( abs(eta) > 1.54 && abs(eta) <= 2.50 ){
306 et_slice3_vec.push_back(et);
307 }
308
309 if(isPassed) {
310 match_et_vec.push_back( et );
311 match_pt_vec.push_back( pt );
312 match_highet_vec.push_back( et );
313
314 if(et > etthr+1.0){
315 match_eta_vec.push_back(eta);
316 match_phi_vec.push_back(phi);
317 match_avgmu_vec.push_back(avgmu);
318 match_npvtx_vec.push_back(npvtx);
319 match_ptvarcone20rel_vec.push_back(ptvarcone20rel);
320 match_ptvarcone30rel_vec.push_back(ptvarcone30rel);
321 match_z0_vec.push_back(z0);
322 match_d0_vec.push_back(d0);
323 }
324
325 et_passed_vec.push_back( true );
326 et_failed_vec.push_back( false );
327 pt_passed_vec.push_back( true );
328 highet_passed_vec.push_back( true );
329 highet_failed_vec.push_back( false );
330
331 if(abs(eta)<=0.8){
332 et_slice0_passed_vec.push_back(true);
333 }else if( abs(eta) > 0.80 && abs(eta) <= 1.37 ){
334 et_slice1_passed_vec.push_back(true);
335 }else if( abs(eta) > 1.37 && abs(eta) <= 1.54 ){
336 et_slice2_passed_vec.push_back(true);
337 }else if( abs(eta) > 1.54 && abs(eta) <= 2.50 ){
338 et_slice3_passed_vec.push_back(true);
339 }
340
341 if(et > etthr+1.0){
342 eta_passed_vec.push_back( true );
343 eta_failed_vec.push_back( false );
344 phi_passed_vec.push_back( true );
345 avgmu_passed_vec.push_back( true );
346 npvtx_passed_vec.push_back( true );
347 ptvarcone20rel_passed_vec.push_back( true );
348 ptvarcone30rel_passed_vec.push_back( true );
349 z0_passed_vec.push_back( true );
350 d0_passed_vec.push_back( true );
351 }
352 } // Passes Trigger selection
353 else {
354
355 et_passed_vec.push_back( false );
356 et_failed_vec.push_back( true );
357 pt_passed_vec.push_back( false );
358 highet_passed_vec.push_back( false );
359 highet_failed_vec.push_back( true );
360
361 if(abs(eta)<=0.8){
362 et_slice0_passed_vec.push_back(false);
363 }else if( abs(eta) > 0.80 && abs(eta) <= 1.37 ){
364 et_slice1_passed_vec.push_back(false);
365 }else if( abs(eta) > 1.37 && abs(eta) <= 1.54 ){
366 et_slice2_passed_vec.push_back(false);
367 }else if( abs(eta) > 1.54 && abs(eta) <= 2.50 ){
368 et_slice3_passed_vec.push_back(false);
369 }
370
371 if(et > etthr+1.0){
372 eta_passed_vec.push_back( false );
373 eta_failed_vec.push_back( true );
374 phi_passed_vec.push_back( false );
375 avgmu_passed_vec.push_back( false );
376 npvtx_passed_vec.push_back( false );
377 ptvarcone20rel_passed_vec.push_back( false );
378 ptvarcone30rel_passed_vec.push_back( false );
379 z0_passed_vec.push_back( false );
380 d0_passed_vec.push_back( false );
381 }
382 } // Fails Trigger selection
383
384 } // Passes offline pid, fill histograms
385 iObj++;
386 }
387
388 fill( monGroup, et_col, highet_col, pt_col, eta_col, phi_col, avgmu_col, npvtx_col, ptvarcone20rel_col, ptvarcone30rel_col, z0_col, d0_col,
389 match_et_col, match_highet_col, match_pt_col, match_eta_col, match_phi_col, match_avgmu_col, match_npvtx_col, match_ptvarcone20rel_col, match_ptvarcone30rel_col,match_z0_col,match_d0_col,
390 et_passed_col, et_failed_col, highet_passed_col, highet_failed_col, pt_passed_col, eta_passed_col, eta_failed_col, phi_passed_col, avgmu_passed_col, npvtx_passed_col, ptvarcone20rel_passed_col, ptvarcone30rel_passed_col, z0_passed_col, d0_passed_col,
391 et_slice0_col,et_slice1_col,et_slice2_col,et_slice3_col,et_slice0_passed_col,et_slice1_passed_col,et_slice2_passed_col,et_slice3_passed_col);
392
393}
eta
Scalar eta() const
pseudorapidity method
Definition AmgMatrixBasePlugin.h:83
phi
Scalar phi() const
phi method
Definition AmgMatrixBasePlugin.h:67
AthMonitorAlgorithm::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx) const
Calculate the average mu, i.e.
Definition AthMonitorAlgorithm.cxx:236
ParticleGun_EoverP_Config.pid
pid
Definition ParticleGun_EoverP_Config.py:62
test_pyathena.pt
pt
Definition test_pyathena.py:11

◆ fillHistograms()

virtual StatusCode TrigEgammaMonitorBaseAlgorithm::fillHistograms ( const EventContext & ctx) const
inlineoverridevirtualinherited

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.

Reimplemented in TrigEgammaMonitorElectronAlgorithm, TrigEgammaMonitorPhotonAlgorithm, TrigEgammaMonitorTagAndProbeAlgorithm, TrigEgammaMonitorTagAndProbeAlgorithmZeeg, and TrigEgammaMonitorTopoAlgorithm.

Definition at line 76 of file TrigEgammaMonitorBaseAlgorithm.h.

76{return StatusCode::SUCCESS;};

◆ fillHLTElectronResolution()

void TrigEgammaMonitorAnalysisAlgorithm::fillHLTElectronResolution ( const EventContext & ctx,
const std::string & trigger,
const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs,
const TrigInfo & info ) const
private

Definition at line 1076 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

1079{
1080
1081 auto monGroup = getGroup( trigger + "_Resolutions_HLT" );
1082
1083 std::vector<float> res_pt_vec, res_et_vec, res_phi_vec, res_eta_vec, res_deta1_vec, res_deta2_vec, res_dphi2_vec, res_dphiresc_vec,
1084 res_z0_vec, res_d0_vec, res_d0sig_vec, res_eprobht_vec, res_npixhits_vec, res_nscthits_vec, res_Rhad_vec, res_Rhad1_vec, res_Reta_vec,
1085 res_Rphi_vec, res_weta1_vec, res_weta2_vec, res_wtots1_vec, res_f1_vec, res_f3_vec, res_eratio_vec, res_ethad_vec, res_ethad1_vec,
1086 et_vec, eta_vec, mu_vec, pt_vec;
1087 std::vector<float> res_ptcone20_vec, res_ptcone20_rel_vec, res_ptvarcone20_vec, res_ptvarcone20_rel_vec;
1088 std::vector<float> res_etInEta0_vec, res_etInEta1_vec, res_etInEta2_vec, res_etInEta3_vec;
1089
1090
1091 auto et_col = Monitored::Collection( "et" , et_vec );
1092 auto pt_col = Monitored::Collection( "pt" , pt_vec );
1093 auto eta_col = Monitored::Collection( "eta" , eta_vec );
1094 auto mu_col = Monitored::Collection( "mu" , mu_vec );
1095
1096 // For calo
1097 auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1098 auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
1099 auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
1100 auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
1101 auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
1102 auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
1103 auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
1104 auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
1105 auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
1106 auto res_weta1_col = Monitored::Collection( "res_weta1" , res_weta1_vec );
1107 auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
1108 auto res_wtots1_col = Monitored::Collection( "res_wtots1" , res_wtots1_vec );
1109 auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
1110 auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
1111 auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
1112
1113 auto res_etInEta0_col = Monitored::Collection( "res_etInEta0" , res_etInEta0_vec );
1114 auto res_etInEta1_col = Monitored::Collection( "res_etInEta1" , res_etInEta1_vec );
1115 auto res_etInEta2_col = Monitored::Collection( "res_etInEta2" , res_etInEta2_vec );
1116 auto res_etInEta3_col = Monitored::Collection( "res_etInEta3" , res_etInEta3_vec );
1117
1118 // For electron
1119 auto res_pt_col = Monitored::Collection( "res_pt" , res_pt_vec );
1120 auto res_deta1_col = Monitored::Collection( "res_deta1" , res_deta1_vec );
1121 auto res_deta2_col = Monitored::Collection( "res_deta2" , res_deta2_vec );
1122 auto res_dphi2_col = Monitored::Collection( "res_dphi2" , res_dphi2_vec );
1123 auto res_dphiresc_col = Monitored::Collection( "res_dphiresc" , res_dphiresc_vec );
1124 auto res_z0_col = Monitored::Collection( "res_z0" , res_z0_vec );
1125 auto res_d0_col = Monitored::Collection( "res_d0" , res_d0_vec );
1126 auto res_d0sig_col = Monitored::Collection( "res_d0sig" , res_d0sig_vec );
1127 auto res_eprobht_col = Monitored::Collection( "res_eprobht" , res_eprobht_vec );
1128 auto res_npixhits_col = Monitored::Collection( "res_npixhits" , res_npixhits_vec );
1129 auto res_nscthits_col = Monitored::Collection( "res_nscthits" , res_nscthits_vec );
1130 auto res_ptcone20_col = Monitored::Collection( "res_ptcone20" , res_ptcone20_vec );
1131 auto res_ptcone20_rel_col = Monitored::Collection( "res_ptcone20_rel" , res_ptcone20_rel_vec );
1132 auto res_ptvarcone20_col = Monitored::Collection( "res_ptvarcone20" , res_ptvarcone20_vec );
1133 auto res_ptvarcone20_rel_col = Monitored::Collection( "res_ptvarcone20_rel" , res_ptvarcone20_rel_vec );
1134
1135
1136
1137
1138 // Check for zero before filling
1139 ATH_MSG_DEBUG("Fill Resolution");
1140
1141 std::string key = match()->key("Electrons_GSF");
1142 if(info.nogsf) key = match()->key("Electrons");
1143 if(info.lrt) key = match()->key("Electrons_LRT");
1144
1145 for ( const auto & pairObj : pairObjs ){
1146
1147 const xAOD::Electron *off = static_cast<const xAOD::Electron*>(pairObj.first);
1148 const xAOD::Electron *onl=nullptr;
1149
1150
1151 { // Get the closest electron object from the trigger starting with deltaR = 0.15
1152 float maxDeltaR=0.05;
1153 auto vec = tdt()->features<xAOD::ElectronContainer>(trigger,TrigDefs::Physics ,key );
1154 for(auto &featLinkInfo : vec ){
1155 if(! featLinkInfo.isValid() ) continue;
1156 const auto *feat = *(featLinkInfo.link);
1157 if(!feat) continue;
1158 float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
1159 if( deltaR < maxDeltaR){
1160 maxDeltaR=deltaR;
1161 onl=feat;
1162 }
1163 }
1164 }
1165
1166 if(!onl) continue;
1167
1168 float val_off=0.;
1169 const float onl_eta=onl->eta();
1170 const float feta = abs(onl_eta);
1171 const float onl_et = getEt(onl)/Gaudi::Units::GeV;
1172 const float avgmu=lbAverageInteractionsPerCrossing( ctx );
1173 const float dummy=-999;
1174
1175 eta_vec.push_back( onl_eta );
1176 et_vec.push_back( onl_et );
1177 mu_vec.push_back( avgmu );
1178
1179 val_off=getTrack_pt(off);
1180 if(val_off!=0.){
1181 res_pt_vec.push_back( (getTrack_pt(off)-val_off)/val_off );
1182 }else{
1183 }
1184
1185
1186 val_off=getEt(off);
1187 if(val_off!=0.){
1188 res_et_vec.push_back( (getEt(onl)-val_off)/val_off );
1189 if( feta < 1.37 )
1190 res_etInEta0_vec.push_back((getEt(onl)-val_off)/val_off);
1191 else if( feta >=1.37 && feta <= 1.52 )
1192 res_etInEta1_vec.push_back((getEt(onl)-val_off)/val_off);
1193 else if( feta >= 1.55 && feta < 1.8 )
1194 res_etInEta2_vec.push_back((getEt(onl)-val_off)/val_off);
1195 else if( feta >= 1.8 && feta < 2.45 )
1196 res_etInEta3_vec.push_back((getEt(onl)-val_off)/val_off);
1197 }
1198
1199 val_off=off->eta();
1200 if(val_off!=0.){
1201 res_eta_vec.push_back( (onl_eta-val_off)/val_off );
1202 }else{
1203 res_eta_vec.push_back( dummy );
1204 }
1205
1206 val_off=off->phi();
1207 if(val_off!=0.){
1208 res_phi_vec.push_back( (onl->phi()-val_off)/val_off );
1209 }else{
1210 res_phi_vec.push_back(dummy );
1211 }
1212
1213 val_off=getShowerShape_ethad(off);
1214 if(val_off!=0.) {
1215 res_ethad_vec.push_back((getShowerShape_ethad(onl)-val_off)/val_off);
1216 }else{
1217 res_ethad_vec.push_back( dummy );
1218 }
1219
1220 val_off=getShowerShape_ethad1(off);
1221 if(val_off!=0){
1222 res_ethad1_vec.push_back((getShowerShape_ethad1(onl)-val_off)/val_off);
1223 }else{
1224 res_ethad1_vec.push_back( dummy);
1225 }
1226
1227 val_off=getShowerShape_Rhad(off);
1228 if(val_off!=0.){
1229 res_Rhad_vec.push_back( (getShowerShape_Rhad(onl)-val_off)/val_off );
1230 }else{
1231 res_Rhad_vec.push_back( dummy );
1232 }
1233
1234 val_off=getShowerShape_Rhad1(off);
1235 if(val_off!=0.){
1236 res_Rhad1_vec.push_back( (getShowerShape_Rhad1(onl)-val_off)/val_off );
1237 }else{
1238 res_Rhad1_vec.push_back( dummy );
1239 }
1240
1241 val_off=getShowerShape_Reta(off);
1242 if(val_off!=0.){
1243 res_Reta_vec.push_back( (getShowerShape_Reta(onl)-val_off)/val_off );
1244 }else{
1245 res_Reta_vec.push_back( dummy );
1246 }
1247
1248 val_off=getShowerShape_Rphi(off);
1249 if(val_off!=0.){
1250 res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
1251 }else{
1252 res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
1253 }
1254
1255 val_off=getShowerShape_weta1(off);
1256 if(val_off!=0.){
1257 res_weta1_vec.push_back( (getShowerShape_weta1(onl)-val_off)/val_off );
1258 }else{
1259 res_weta1_vec.push_back( dummy );
1260 }
1261
1262 val_off=getShowerShape_weta2(off);
1263 if(val_off!=0.){
1264 res_weta2_vec.push_back( (getShowerShape_weta2(onl)-val_off)/val_off );
1265 }else{
1266 res_weta2_vec.push_back( dummy );
1267 }
1268
1269 val_off=getShowerShape_wtots1(off);
1270 if(val_off!=0.){
1271 res_wtots1_vec.push_back( (getShowerShape_wtots1(onl)-val_off)/val_off );
1272 }else{
1273 res_wtots1_vec.push_back( dummy );
1274 }
1275
1276 val_off=getShowerShape_f1(off);
1277 if(val_off!=0.){
1278 res_f1_vec.push_back( (getShowerShape_f1(onl)-val_off)/val_off );
1279 }else{
1280 res_f1_vec.push_back(dummy );
1281 }
1282
1283 val_off=getShowerShape_f3(off);
1284 if(val_off!=0.){
1285 res_f3_vec.push_back( (getShowerShape_f3(onl)-val_off)/val_off );
1286 }else{
1287 res_f3_vec.push_back( dummy );
1288 }
1289
1290 val_off=getShowerShape_Eratio(off);
1291 if(val_off!=0.){
1292 res_eratio_vec.push_back( (getShowerShape_Eratio(onl)-val_off)/val_off );
1293 }else{
1294 res_eratio_vec.push_back( dummy );
1295 }
1296
1297
1298 //
1299 // Track variables
1300 //
1301
1302 val_off=getTrack_pt(off);
1303 if(val_off!=0.){
1304 res_pt_vec.push_back( (getTrack_pt(onl)-val_off)/val_off );
1305 }else{
1306 res_pt_vec.push_back( dummy );
1307 }
1308
1309 val_off=getEt(off);
1310 if(val_off!=0.) {
1311 res_et_vec.push_back( (getEt(onl)-val_off)/val_off );
1312 }else{
1313 res_et_vec.push_back( dummy );
1314 }
1315
1316 val_off=getCaloTrackMatch_deltaEta1(off);
1317 if(val_off!=0.) {
1318 res_deta1_vec.push_back( (getCaloTrackMatch_deltaEta1(onl)-val_off)/val_off );
1319 }else{
1320 res_deta1_vec.push_back( dummy );
1321 }
1322
1323 val_off=getCaloTrackMatch_deltaEta2(off);
1324 res_deta2_vec.push_back( (getCaloTrackMatch_deltaEta2(onl)-val_off)/val_off );
1325 val_off=getCaloTrackMatch_deltaPhi2(off);
1326 if(val_off!=0.) {
1327 res_dphi2_vec.push_back( (getCaloTrackMatch_deltaPhi2(onl)-val_off)/val_off );
1328 }else{
1329 res_dphi2_vec.push_back(dummy );
1330 }
1331
1332 val_off=getCaloTrackMatch_deltaPhiRescaled2(off);
1333 res_dphiresc_vec.push_back( (getCaloTrackMatch_deltaPhiRescaled2(onl)-val_off)/val_off );
1334 // Resolution of Z0 of the track
1335 val_off=getTrack_z0(off);
1336 if(val_off!=0.) {
1337 res_z0_vec.push_back( getTrack_z0(onl)-val_off );
1338 }else{
1339 res_z0_vec.push_back( dummy );
1340 }
1341
1342 // Absolute resolution for impact parameter
1343 val_off=getTrack_d0(off);
1344 if(val_off!=0.) {
1345 res_d0_vec.push_back( getTrack_d0(onl)-val_off );
1346 }else{
1347 res_d0_vec.push_back( dummy );
1348 }
1349
1350 val_off=getD0sig(off);
1351 if(val_off!=0.) {
1352 res_d0sig_vec.push_back( getD0sig(onl)-val_off );
1353 }else{
1354 res_d0sig_vec.push_back( dummy );
1355 }
1356
1357 // Absolute resolution on track summary ints/floats
1358 val_off=getTrackSummaryFloat_eProbabilityHT(off);
1359 res_eprobht_vec.push_back( (getTrackSummaryFloat_eProbabilityHT(onl)-val_off) );
1360 res_npixhits_vec.push_back( getTrackSummary_numberOfPixelHits(onl)-getTrackSummary_numberOfPixelHits(onl) );
1361 res_nscthits_vec.push_back( getTrackSummary_numberOfSCTHits(onl)-getTrackSummary_numberOfSCTHits(onl) );
1362
1363
1364
1365
1366 if(info.isolated){
1367
1368 float val_off=getIsolation_ptcone20(off);
1369 if (val_off > 0.) {
1370 res_ptcone20_vec.push_back((getIsolation_ptcone20(onl)-val_off)/val_off);
1371 if (getEt(onl) > 0. && getEt(off) > 0.) {
1372 const float reliso_onl=getIsolation_ptcone20(onl)/getEt(onl);
1373 const float reliso_off=getIsolation_ptcone20(off)/getEt(off);
1374 res_ptcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
1375 }else{
1376 res_ptcone20_rel_vec.push_back(dummy);
1377 }
1378 }else{
1379 res_ptcone20_vec.push_back(dummy);
1380 res_ptcone20_rel_vec.push_back(dummy);
1381 }
1382
1383 // ptvarcone20 isolation
1384 val_off=getIsolation_ptvarcone20(off);
1385 if (val_off > 0.) {
1386 if (getEt(onl) > 0. && getEt(off) > 0.) {
1387 res_ptvarcone20_vec.push_back((getIsolation_ptvarcone20(onl)-val_off)/val_off);
1388 const float reliso_onl=getIsolation_ptvarcone20(onl)/getEt(onl);
1389 const float reliso_off=getIsolation_ptvarcone20(off)/getEt(off);
1390 res_ptvarcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
1391 }else{
1392 res_ptvarcone20_rel_vec.push_back(dummy);
1393 }
1394 }else{
1395 res_ptvarcone20_vec.push_back(dummy);
1396 res_ptvarcone20_rel_vec.push_back(dummy);
1397 }
1398
1399 }
1400
1401
1402
1403
1404
1405 } // Loop over all offline objects
1406
1407 // Fill everything
1408 fill( monGroup ,
1409 et_col ,
1410 pt_col ,
1411 eta_col ,
1412 mu_col ,
1413 res_pt_col ,
1414 res_et_col ,
1415 res_eta_col ,
1416 res_phi_col ,
1417 res_deta1_col ,
1418 res_deta2_col ,
1419 res_dphi2_col ,
1420 res_dphiresc_col,
1421 res_z0_col ,
1422 res_d0_col ,
1423 res_d0sig_col ,
1424 res_eprobht_col ,
1425 res_npixhits_col,
1426 res_nscthits_col,
1427 res_ethad_col ,
1428 res_ethad1_col ,
1429 res_Rhad_col ,
1430 res_Rhad1_col ,
1431 res_Reta_col ,
1432 res_Rphi_col ,
1433 res_weta1_col ,
1434 res_weta2_col ,
1435 res_wtots1_col ,
1436 res_f1_col ,
1437 res_f3_col ,
1438 res_eratio_col ,
1439 res_ptcone20_col ,
1440 res_ptcone20_rel_col ,
1441 res_ptvarcone20_col ,
1442 res_ptvarcone20_rel_col ,
1443 res_etInEta0_col,
1444 res_etInEta1_col,
1445 res_etInEta2_col,
1446 res_etInEta3_col );
1447
1448
1449
1450}
deltaR
Scalar deltaR(const MatrixBase< Derived > &vec) const
Definition AmgMatrixBasePlugin.h:105
TrigEgammaMonitorBaseAlgorithm::dR
float dR(const float, const float, const float, const float) const
Get delta R.
Definition TrigEgammaMonitorBaseAlgorithm.cxx:296
TrigEgammaMonitorBaseAlgorithm::getD0sig
float getD0sig(const xAOD::Electron *eg) const
Definition TrigEgammaMonitorBaseAlgorithm.cxx:386
xAOD::Egamma_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition Egamma_v1.cxx:71
xAOD::Egamma_v1::phi
virtual double phi() const override final
The azimuthal angle ( ) of the particle.
Definition Egamma_v1.cxx:76

◆ fillHLTPhotonResolution()

void TrigEgammaMonitorAnalysisAlgorithm::fillHLTPhotonResolution ( const EventContext & ctx,
const std::string & trigger,
const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs,
const TrigInfo & info ) const
private

Definition at line 1456 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

1459{
1460
1461 auto monGroup = getGroup( trigger + "_Resolutions_HLT" );
1462
1463 std::vector<float> res_phi_vec, res_eta_vec, res_Rhad_vec, res_Rhad1_vec, res_Reta_vec, res_ethad_vec, res_ethad1_vec,
1464 res_Rphi_vec, res_weta1_vec, res_weta2_vec, res_wtots1_vec, res_f1_vec, res_f3_vec, res_eratio_vec, et_vec, eta_vec, mu_vec;
1465
1466 std::vector<float> res_et_vec, res_et_cnv_vec, res_et_uncnv_vec, res_cnv_et_vec, res_uncnv_et_vec;
1467 std::vector<float> res_etInEta0_vec, res_etInEta1_vec, res_etInEta2_vec, res_etInEta3_vec;
1468 std::vector<float> res_cnv_etInEta0_vec, res_cnv_etInEta1_vec, res_cnv_etInEta2_vec, res_cnv_etInEta3_vec;
1469 std::vector<float> res_uncnv_etInEta0_vec, res_uncnv_etInEta1_vec, res_uncnv_etInEta2_vec, res_uncnv_etInEta3_vec;
1470
1471
1472
1473 std::vector<float> res_topoetcone20_vec, res_topoetcone20_rel_vec;
1474
1475 auto et_col = Monitored::Collection( "et" , et_vec );
1476 auto eta_col = Monitored::Collection( "eta" , eta_vec );
1477 auto mu_col = Monitored::Collection( "mu" , mu_vec );
1478
1479 // For calo
1480 auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
1481 auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
1482 auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
1483 auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
1484 auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
1485 auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
1486 auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
1487 auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
1488 auto res_weta1_col = Monitored::Collection( "res_weta1" , res_weta1_vec );
1489 auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
1490 auto res_wtots1_col = Monitored::Collection( "res_wtots1" , res_wtots1_vec );
1491 auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
1492 auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
1493 auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
1494
1495
1496 auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1497 auto res_et_cnv_col = Monitored::Collection( "res_et_cnv" , res_et_cnv_vec );
1498 auto res_cnv_et_col = Monitored::Collection( "res_cnv_et" , res_cnv_et_vec );
1499 auto res_uncnv_et_col = Monitored::Collection( "res_uncnv_et" , res_uncnv_et_vec );
1500 auto res_et_uncnv_col = Monitored::Collection( "res_et_uncnv" , res_et_uncnv_vec );
1501 auto res_etInEta0_col = Monitored::Collection( "res_etInEta0" , res_etInEta0_vec );
1502 auto res_etInEta1_col = Monitored::Collection( "res_etInEta1" , res_etInEta1_vec );
1503 auto res_etInEta2_col = Monitored::Collection( "res_etInEta2" , res_etInEta2_vec );
1504 auto res_etInEta3_col = Monitored::Collection( "res_etInEta3" , res_etInEta3_vec );
1505 auto res_cnv_etInEta0_col = Monitored::Collection( "res_cnv_etInEta0" , res_cnv_etInEta0_vec );
1506 auto res_cnv_etInEta1_col = Monitored::Collection( "res_cnv_etInEta1" , res_cnv_etInEta1_vec );
1507 auto res_cnv_etInEta2_col = Monitored::Collection( "res_cnv_etInEta2" , res_cnv_etInEta2_vec );
1508 auto res_cnv_etInEta3_col = Monitored::Collection( "res_cnv_etInEta3" , res_cnv_etInEta3_vec );
1509 auto res_uncnv_etInEta0_col = Monitored::Collection( "res_uncnv_etInEta0" , res_uncnv_etInEta0_vec);
1510 auto res_uncnv_etInEta1_col = Monitored::Collection( "res_uncnv_etInEta1" , res_uncnv_etInEta1_vec);
1511 auto res_uncnv_etInEta2_col = Monitored::Collection( "res_uncnv_etInEta2" , res_uncnv_etInEta2_vec);
1512 auto res_uncnv_etInEta3_col = Monitored::Collection( "res_uncnv_etInEta3" , res_uncnv_etInEta3_vec);
1513
1514 // For photon
1515 auto res_topoetcone20_col = Monitored::Collection( "res_topoetcone20" , res_topoetcone20_vec );
1516 auto res_topoetcone20_rel_col = Monitored::Collection( "res_topoetcone20_rel" , res_topoetcone20_rel_vec );
1517
1518
1519
1520
1521 // Check for zero before filling
1522 ATH_MSG_DEBUG("Fill Resolution");
1523
1524
1525
1526 for ( const auto & pairObj : pairObjs ){
1527
1528 const xAOD::Photon *off = static_cast<const xAOD::Photon*>(pairObj.first);
1529 const xAOD::Photon *onl=nullptr;
1530
1531
1532 { // Get the closest electron object from the trigger starting with deltaR = 0.15
1533 float maxDeltaR=0.05;
1534 auto vec = tdt()->features<xAOD::PhotonContainer>(trigger,TrigDefs::Physics ,match()->key("Photons") );
1535 for(auto &featLinkInfo : vec ){
1536 if(! featLinkInfo.isValid() ) continue;
1537 const auto *feat = *(featLinkInfo.link);
1538 if(!feat) continue;
1539 float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
1540 if( deltaR < maxDeltaR){
1541 maxDeltaR=deltaR;
1542 onl=feat;
1543 }
1544 }
1545 }
1546
1547 // If not found, skip this off object!
1548 if(!onl) continue;
1549
1550 float val_off=0.;
1551 const float onl_eta=onl->eta();
1552 const float feta = abs(onl_eta);
1553 const float onl_et = getCluster_et(onl)/Gaudi::Units::GeV;
1554 const float dummy=-999;
1555
1556 const float avgmu=lbAverageInteractionsPerCrossing( ctx );
1557 et_vec.push_back( onl_et );
1558 eta_vec.push_back( onl_eta );
1559 mu_vec.push_back( avgmu );
1560
1561
1562 val_off=getCluster_et(off);
1563 if(val_off!=0.){
1564 res_et_vec.push_back( (getCluster_et(onl)-val_off)/val_off );
1565 if( feta < 1.37 )
1566 res_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1567 else if( feta >=1.37 && feta <= 1.52 )
1568 res_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1569 else if( feta >= 1.55 && feta < 1.8 )
1570 res_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1571 else if( feta >= 1.8 && feta < 2.45 )
1572 res_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1573
1574 if(xAOD::EgammaHelpers::isConvertedPhoton(off)){
1575 res_et_cnv_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1576 if( feta < 1.37 )
1577 res_cnv_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1578 else if( feta >=1.37 && feta <= 1.52 )
1579 res_cnv_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1580 else if( feta >= 1.55 && feta < 1.8 )
1581 res_cnv_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1582 else if( feta >= 1.8 && feta < 2.45 )
1583 res_cnv_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1584 }else{
1585 res_et_uncnv_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1586 if( feta < 1.37 )
1587 res_uncnv_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1588 else if( feta >=1.37 && feta <= 1.52 )
1589 res_uncnv_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1590 else if( feta >= 1.55 && feta < 1.8 )
1591 res_uncnv_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1592 else if( feta >= 1.8 && feta < 2.45 )
1593 res_uncnv_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
1594 }
1595 }
1596
1597 val_off=off->eta();
1598 if(val_off!=0.){
1599 res_eta_vec.push_back( (onl_eta-val_off)/val_off ) ;
1600 }else{
1601 res_eta_vec.push_back( dummy ) ;
1602 }
1603
1604 val_off=off->phi();
1605 if(val_off!=0.){
1606 res_phi_vec.push_back( (onl->phi()-val_off)/val_off );
1607 }else{
1608 res_phi_vec.push_back(dummy );
1609 }
1610
1611 val_off=getShowerShape_ethad(off);
1612 if(val_off!=0.) {
1613 res_ethad_vec.push_back((getShowerShape_ethad(onl)-val_off)/val_off);
1614 }else{
1615 res_ethad_vec.push_back(dummy);
1616 }
1617
1618 val_off=getShowerShape_ethad1(off);
1619 if(val_off!=0){
1620 res_ethad1_vec.push_back((getShowerShape_ethad1(onl)-val_off)/val_off);
1621 }else{
1622 res_ethad1_vec.push_back(dummy);
1623 }
1624
1625 val_off=getShowerShape_Rhad(off);
1626 if(val_off!=0.){
1627 res_Rhad_vec.push_back( (getShowerShape_Rhad(onl)-val_off)/val_off );
1628 }else{
1629 res_Rhad_vec.push_back(dummy );
1630 }
1631
1632 val_off=getShowerShape_Rhad1(off);
1633 if(val_off!=0.){
1634 res_Rhad1_vec.push_back( (getShowerShape_Rhad1(onl)-val_off)/val_off );
1635 }else{
1636 res_Rhad1_vec.push_back(dummy );
1637 }
1638
1639 val_off=getShowerShape_Reta(off);
1640 if(val_off!=0.){
1641 res_Reta_vec.push_back( (getShowerShape_Reta(onl)-val_off)/val_off );
1642 }else{
1643 res_Reta_vec.push_back( dummy );
1644 }
1645
1646 val_off=getShowerShape_Rphi(off);
1647 if(val_off!=0.){
1648 res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
1649 }else{
1650 res_Rphi_vec.push_back(dummy );
1651 }
1652
1653 val_off=getShowerShape_weta1(off);
1654 if(val_off!=0.){
1655 res_weta1_vec.push_back( (getShowerShape_weta1(onl)-val_off)/val_off );
1656 }else{
1657 res_weta1_vec.push_back( dummy );
1658 }
1659
1660 val_off=getShowerShape_weta2(off);
1661 if(val_off!=0.){
1662 res_weta2_vec.push_back( (getShowerShape_weta2(onl)-val_off)/val_off );
1663 }else{
1664 res_weta2_vec.push_back(dummy);
1665 }
1666
1667 val_off=getShowerShape_wtots1(off);
1668 if(val_off!=0.){
1669 res_wtots1_vec.push_back( (getShowerShape_wtots1(onl)-val_off)/val_off );
1670 }else{
1671 res_wtots1_vec.push_back( dummy );
1672 }
1673
1674 val_off=getShowerShape_f1(off);
1675 if(val_off!=0.){
1676 res_f1_vec.push_back( (getShowerShape_f1(onl)-val_off)/val_off );
1677 }else{
1678 res_f1_vec.push_back( dummy );
1679 }
1680
1681 val_off=getShowerShape_f3(off);
1682 if(val_off!=0.){
1683 res_f3_vec.push_back( (getShowerShape_f3(onl)-val_off)/val_off );
1684 }else{
1685 res_f3_vec.push_back( dummy );
1686 }
1687
1688 val_off=getShowerShape_Eratio(off);
1689 if(val_off!=0.){
1690 res_eratio_vec.push_back( (getShowerShape_Eratio(onl)-val_off)/val_off);
1691 }else{
1692 res_eratio_vec.push_back( dummy);
1693 }
1694
1695
1696 if( info.isolated ){
1697 // topoetcone20 isolation
1698 float val_off=getIsolation_topoetcone20(off);
1699 float etonl=onl->pt();
1700 float etoff=off->pt();
1701 if (val_off > 0.) {
1702 res_topoetcone20_vec.push_back((getIsolation_topoetcone20(onl)-val_off)/val_off);
1703 if (etonl > 0. && etoff > 0.) {
1704 const float reliso_onl=getIsolation_topoetcone20(onl)/etonl;
1705 const float reliso_off=getIsolation_topoetcone20(off)/etoff;
1706 res_topoetcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
1707 }else{
1708 res_topoetcone20_rel_vec.push_back(dummy);
1709 }
1710 }else{
1711 res_topoetcone20_vec.push_back(dummy);
1712 res_topoetcone20_rel_vec.push_back(dummy);
1713 }
1714 }
1715
1716
1717
1718 } // Loop over all offline objects
1719
1720 // Fill everything
1721 fill( monGroup ,
1722 et_col ,
1723 eta_col ,
1724 mu_col ,
1725 res_et_col ,
1726 res_eta_col ,
1727 res_phi_col ,
1728 res_ethad_col ,
1729 res_ethad1_col ,
1730 res_Rhad_col ,
1731 res_Rhad1_col ,
1732 res_Reta_col ,
1733 res_Rphi_col ,
1734 res_weta1_col ,
1735 res_weta2_col ,
1736 res_wtots1_col ,
1737 res_f1_col ,
1738 res_f3_col ,
1739 res_eratio_col ,
1740 res_topoetcone20_col ,
1741 res_topoetcone20_rel_col ,
1742 res_etInEta0_col,
1743 res_etInEta1_col,
1744 res_etInEta2_col,
1745 res_etInEta3_col,
1746 res_et_uncnv_col,
1747 res_cnv_etInEta0_col,
1748 res_cnv_etInEta1_col,
1749 res_cnv_etInEta2_col,
1750 res_cnv_etInEta3_col,
1751 res_et_cnv_col,
1752 res_cnv_et_col,
1753 res_uncnv_et_col,
1754 res_uncnv_etInEta0_col,
1755 res_uncnv_etInEta1_col,
1756 res_uncnv_etInEta2_col,
1757 res_uncnv_etInEta3_col
1758 );
1759
1760
1761
1762}
xAOD::Egamma_v1::pt
virtual double pt() const override final
The transverse momentum ( ) of the particle.
Definition Egamma_v1.cxx:66
xAOD::EgammaHelpers::isConvertedPhoton
bool isConvertedPhoton(const xAOD::Egamma *eg, bool excludeTRT=false)
is the object a converted photon
Definition EgammaxAODHelpers.cxx:25
xAOD::Photon
Photon_v1 Photon
Definition of the current "egamma version".
Definition Event/xAOD/xAODEgamma/xAODEgamma/Photon.h:17

◆ fillInefficiency()

void TrigEgammaMonitorAnalysisAlgorithm::fillInefficiency ( const std::string & pidword,
const TrigInfo & info,
const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs,
const std::vector< asg::AcceptData > & acceptObjs ) const
protected

Definition at line 397 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

402{
403 auto monGroup = getGroup(info.trigger+"_Inefficiency");
404 unsigned iObj=0;
405 SG::Decorator<bool> pidwordDec("is"+pidword);
406 for( auto pairObj : pairObjs ){
407
408 bool pid=true;
409 bool isPassedL1Calo = acceptObjs[iObj].getCutResult( "L1Calo");
410 bool isPassedL2Calo = acceptObjs[iObj].getCutResult( "L2Calo");
411 bool isPassedL2 = acceptObjs[iObj].getCutResult( "L2" );
412 bool isPassedEFCalo = acceptObjs[iObj].getCutResult( "EFCalo");
413 bool isPassedHLT = acceptObjs[iObj].getCutResult( "HLT" );
414
415 const auto *eg = pairObj.first;
416 if(xAOD::EgammaHelpers::isElectron(eg)){
417 ATH_MSG_DEBUG("Offline Electron with pidword " << pidword);
418 const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg);
419 pid=pidwordDec(*el);
420 ATH_MSG_DEBUG("Electron pid " << pid);
421 }
422 if(pid){
423 if(!isPassedL1Calo){
424 fillLabel(monGroup, "InefficiencyCounts", "L1Calo" );
425 }if(!isPassedL2Calo){
426 fillLabel(monGroup, "InefficiencyCounts", "L2Calo" );
427 }if(!isPassedL2){
428 fillLabel(monGroup, "InefficiencyCounts", "L2" );
429 }if(!isPassedEFCalo){
430 fillLabel(monGroup, "InefficiencyCounts", "EFCalo" );
431 }if(!isPassedHLT){
432 fillLabel(monGroup, "InefficiencyCounts", "HLT" );
433 }
434 }
435 iObj++;
436 }
437}
TrigEgammaMonitorAnalysisAlgorithm::fillLabel
void fillLabel(const ToolHandle< GenericMonitoringTool > &groupHandle, const std::string &histname, const std::string &label) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:30

◆ fillL1Calo()

void TrigEgammaMonitorAnalysisAlgorithm::fillL1Calo ( const std::string & trigger,
const std::vector< const xAOD::EmTauRoI * > & l1_vec ) const
private

Definition at line 594 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

595{
596 auto monGroup = getGroup(trigger+"_Distributions_L1Calo");
597
598 std::vector<float> eta_vec, phi_vec, energy_vec, roi_et_vec, emIso_vec, hadCore_vec;
599
600 auto eta_col = Monitored::Collection( "eta" , eta_vec );
601 auto phi_col = Monitored::Collection( "phi" , phi_vec );
602 auto energy_col = Monitored::Collection( "energy" , energy_vec );
603 auto roi_et_col = Monitored::Collection( "roi_et" , roi_et_vec );
604 auto emIso_col = Monitored::Collection( "emIso" , emIso_vec );
605 auto hadCore_col = Monitored::Collection( "hadCore" , hadCore_vec );
606
607 for( const auto *l1 : l1_vec )
608 {
609 if(!l1) continue;
610 eta_vec.push_back( l1->eta() );
611 phi_vec.push_back( l1->phi() );
612 energy_vec.push_back( l1->emClus()/Gaudi::Units::GeV );
613 roi_et_vec.push_back( l1->eT()/Gaudi::Units::GeV );
614 emIso_vec.push_back( l1->emIsol()/Gaudi::Units::GeV );
615 hadCore_vec.push_back( l1->hadCore()/Gaudi::Units::GeV );
616 }
617
618 fill( monGroup, eta_col, phi_col, energy_col, roi_et_col, emIso_col, hadCore_col );
619
620}

◆ fillL1CaloAbsResolution()

void TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloAbsResolution ( const std::string & trigger,
const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > & pairObjs ) const
private

Definition at line 1048 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

1050{
1051 auto monGroup = getGroup( trigger + "_AbsResolutions_L1Calo" );
1052
1053 std::vector<float> eta_vec, res_et_vec;
1054
1055 auto eta_col = Monitored::Collection( "eta" , eta_vec );
1056 auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1057
1058
1059 for (const auto & pairObj : pairObjs){
1060 const auto *off = pairObj.first;
1061 const auto *l1 = pairObj.second;
1062 ATH_MSG_DEBUG("Fill L1CaloAbsResolution");
1063 if(off->type()==xAOD::Type::Electron){
1064 const xAOD::Electron* eloff =static_cast<const xAOD::Electron*> (off);
1065 eta_vec.push_back( l1->eta() );
1066 res_et_vec.push_back( (l1->emClus()-getEt(eloff))/Gaudi::Units::GeV ) ;
1067 }
1068 }
1069
1070 fill( monGroup, eta_col, res_et_col );
1071}

◆ fillL1CaloResolution()

void TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloResolution ( const std::string & trigger,
const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > & pairObjs ) const
private

Definition at line 1018 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

1020{
1021 auto monGroup = getGroup( trigger + "_Resolutions_L1Calo" );
1022
1023 std::vector<float> eta_vec, res_et_vec;
1024
1025 auto eta_col = Monitored::Collection( "eta" , eta_vec );
1026 auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1027
1028
1029 for (const auto & pairObj : pairObjs){
1030 const auto *off = pairObj.first;
1031 const auto *l1 = pairObj.second;
1032 ATH_MSG_DEBUG("Fill L1CaloResolution");
1033 if(off->type()==xAOD::Type::Electron){
1034 const xAOD::Electron* eloff =static_cast<const xAOD::Electron*> (off);
1035 eta_vec.push_back( l1->eta() );
1036 res_et_vec.push_back( (l1->emClus()-getEt(eloff))/getEt(eloff) ) ;
1037
1038 }
1039 }
1040
1041 fill( monGroup, eta_col, res_et_col );
1042}

◆ fillL1eEM()

void TrigEgammaMonitorAnalysisAlgorithm::fillL1eEM ( const std::string & trigger,
const std::vector< const xAOD::eFexEMRoI * > & l1_vec ) const
private

Definition at line 623 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

624{
625 auto monGroup = getGroup(trigger+"_Distributions_L1Calo");
626
627 std::vector<float> eta_vec, phi_vec, et_vec, wstot_vec, reta_vec, rhad_vec;
628
629 auto et_col = Monitored::Collection( "et" , et_vec );
630 auto eta_col = Monitored::Collection( "eta" , eta_vec );
631 auto phi_col = Monitored::Collection( "phi" , phi_vec );
632 auto wstot_col = Monitored::Collection( "Wstot" , wstot_vec );
633 auto reta_col = Monitored::Collection( "Reta" , reta_vec );
634 auto rhad_col = Monitored::Collection( "Rhad" , rhad_vec );
635
636
637 for( const auto *l1 : l1_vec )
638 {
639 if(!l1) continue;
640 et_vec.push_back( l1->et()/Gaudi::Units::GeV );
641 eta_vec.push_back( l1->eta() );
642 phi_vec.push_back( l1->phi() );
643 wstot_vec.push_back( l1->Wstot() );
644 reta_vec.push_back( l1->Reta() );
645 rhad_vec.push_back( l1->Rhad() );
646 }
647
648 fill( monGroup, eta_col, phi_col, et_col, wstot_col, reta_col, rhad_col );
649
650}

◆ fillL2Calo()

void TrigEgammaMonitorAnalysisAlgorithm::fillL2Calo ( const std::string & trigger,
const std::vector< const xAOD::TrigEMCluster * > & emCluster_vec ) const
private

Definition at line 654 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

655{
656 auto monGroup = getGroup(trigger+"_Distributions_L2Calo");
657
658 std::vector<float> et_vec,highet_vec, eta_vec, phi_vec;
659
660 auto et_col = Monitored::Collection("et" , et_vec );
661 auto highet_col = Monitored::Collection("highet" , highet_vec );
662 auto eta_col = Monitored::Collection("eta", eta_vec );
663 auto phi_col = Monitored::Collection("phi", phi_vec );
664
665 for ( const auto *emCluster : emCluster_vec )
666 {
667 if(!emCluster) continue;
668 et_vec.push_back( emCluster->et()/Gaudi::Units::GeV );
669 highet_vec.push_back( emCluster->et()/Gaudi::Units::GeV );
670 eta_vec.push_back( emCluster->eta() );
671 phi_vec.push_back( emCluster->phi() );
672 }
673
674 fill( monGroup, et_col, eta_col, phi_col, highet_col );
675
676
677}

◆ fillL2CaloResolution()

void TrigEgammaMonitorAnalysisAlgorithm::fillL2CaloResolution ( const std::string & trigger,
const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs ) const
private

Definition at line 1765 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

1768{
1769 ATH_MSG_DEBUG("Fill L2Calo Resolution");
1770
1771 auto monGroup = getGroup( trigger + "_Resolutions_L2Calo" );
1772
1773 std::vector<float> res_et_vec, res_phi_vec, res_eta_vec, res_Rhad_vec, res_Rhad1_vec, res_Reta_vec, res_ethad_vec, res_ethad1_vec,
1774 res_Rphi_vec, res_weta2_vec, res_f1_vec, res_f3_vec, res_eratio_vec, et_vec, eta_vec, res_etVsEt_vec;
1775
1776
1777 auto et_col = Monitored::Collection( "et" , et_vec );
1778 auto eta_col = Monitored::Collection( "eta" , eta_vec );
1779 auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1780 auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
1781 auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
1782 auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
1783 auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
1784 auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
1785 auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
1786 auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
1787 auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
1788 auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
1789 auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
1790 auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
1791 auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
1792 auto res_etVsEt_col = Monitored::Collection( "res_etVsEt" , res_etVsEt_vec );
1793
1794
1795
1796
1797 for ( const auto & pairObj : pairObjs ){
1798
1799
1800 const xAOD::Egamma *off = pairObj.first;
1801 const xAOD::TrigEMCluster *onl=nullptr;
1802
1803 { // Get the closest electron object from the trigger starting with deltaR = 0.15
1804 float maxDeltaR=0.05;
1805 auto vec = tdt()->features<xAOD::TrigEMClusterContainer>(trigger,TrigDefs::Physics ,match()->key("FastCalo") );
1806 for(auto &featLinkInfo : vec ){
1807 if(! featLinkInfo.isValid() ) continue;
1808 const auto *feat = *(featLinkInfo.link);
1809 if(!feat) continue;
1810 float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
1811 if( deltaR < maxDeltaR){
1812 maxDeltaR=deltaR;
1813 onl=feat;
1814 }
1815 }
1816 }
1817
1818 if(!onl) continue;
1819
1820 et_vec.push_back(onl->et()*1e-3);
1821 eta_vec.push_back(onl->eta());
1822 const float dummy=-999;
1823
1824 float val_off=0.;
1825
1826 val_off=off->caloCluster()->et();
1827 if(val_off!=0.){
1828 res_et_vec.push_back(((onl->et())-val_off)/val_off);
1829 }else{
1830 res_et_vec.push_back(dummy);
1831 }
1832
1833 val_off=off->caloCluster()->eta();
1834 if(val_off!=0.){
1835 res_eta_vec.push_back((onl->eta()-val_off)/val_off);
1836 }else{
1837 res_eta_vec.push_back(dummy);
1838 }
1839
1840 val_off=off->caloCluster()->phi();
1841 if(val_off!=0.){
1842 res_phi_vec.push_back((onl->phi()-val_off)/val_off);
1843 }else{
1844 res_phi_vec.push_back((onl->phi()-val_off)/val_off);
1845 }
1846
1847 float elonl_ethad = onl->energy( CaloSampling::HEC0 ); elonl_ethad += onl->energy( CaloSampling::HEC1 );
1848 elonl_ethad += onl->energy( CaloSampling::HEC2 ); elonl_ethad += onl->energy( CaloSampling::HEC3 );
1849 elonl_ethad += onl->energy( CaloSampling::TileBar0 ); elonl_ethad += onl->energy( CaloSampling::TileExt0 );
1850 elonl_ethad += onl->energy( CaloSampling::TileBar1 ); elonl_ethad += onl->energy( CaloSampling::TileExt1 );
1851 elonl_ethad += onl->energy( CaloSampling::TileBar2 ); elonl_ethad += onl->energy( CaloSampling::TileExt2 );
1852 elonl_ethad /= TMath::CosH(onl->eta() );
1853 val_off=getShowerShape_ethad(off);
1854 if(val_off!=0.){
1855 res_ethad_vec.push_back((elonl_ethad-val_off)/val_off);
1856 }else{
1857 res_ethad_vec.push_back(dummy);
1858 }
1859
1860 val_off=getShowerShape_ethad1(off);
1861 if(val_off!=0.){
1862 res_ethad1_vec.push_back(( (onl->ehad1()/TMath::Abs(onl->eta()) )-val_off)/val_off);
1863 }else{
1864 res_ethad1_vec.push_back(dummy);
1865 }
1866
1867 float elonl_Rhad = elonl_ethad / onl->energy() ;
1868 val_off=getShowerShape_Rhad(off);
1869 if(val_off!=0.){
1870 res_Rhad_vec.push_back(( elonl_Rhad-val_off)/val_off);
1871 }else{
1872 res_Rhad_vec.push_back(dummy);
1873 }
1874
1875 float elonl_Rhad1 = onl->ehad1() / onl->energy() ;
1876 val_off=getShowerShape_Rhad1(off);
1877 if(val_off!=0.){
1878 res_Rhad1_vec.push_back(( elonl_Rhad1-val_off)/val_off);
1879 }else{
1880 res_Rhad1_vec.push_back(dummy);
1881 }
1882
1883 float onl_reta= 999.0;
1884 if ( fabsf ( onl->e277() ) > 0.01 ) onl_reta = onl->e237() / onl->e277();
1885 val_off=getShowerShape_Reta(off);
1886 if(val_off!=0.){
1887 res_Reta_vec.push_back( (onl_reta -val_off)/val_off);
1888 }else{
1889 res_Reta_vec.push_back(dummy);
1890 }
1891
1892 val_off=getShowerShape_weta2(off);
1893 if(val_off!=0.){
1894 res_weta2_vec.push_back(( (onl->weta2())-val_off)/val_off);
1895 }else{
1896 res_weta2_vec.push_back(dummy);
1897 }
1898
1899 float onl_f1 = onl->energy(CaloSampling::EMB1)+onl->energy(CaloSampling::EME1);
1900 onl_f1 /= onl->energy();
1901 val_off=getShowerShape_f1(off);
1902 if(val_off!=0.){
1903 res_f1_vec.push_back(( (onl_f1)-val_off)/val_off);
1904 }else{
1905 res_f1_vec.push_back(dummy);
1906 }
1907
1908 float onl_f3 = onl->energy(CaloSampling::EMB3)+onl->energy(CaloSampling::EME3);
1909 onl_f3 /= onl->energy();
1910 val_off=getShowerShape_f3(off);
1911 if(val_off!=0.){
1912 res_f3_vec.push_back(( (onl_f3)-val_off)/val_off);
1913 }else{
1914 res_f3_vec.push_back(dummy);
1915 }
1916
1917 float onl_eratio = 999.0;
1918 if ( fabsf(onl->emaxs1() + onl->e2tsts1()) > 0.01 )
1919 onl_eratio = (onl->emaxs1() - onl->e2tsts1()) / (onl->emaxs1() + onl->e2tsts1());
1920 val_off=getShowerShape_Eratio(off);
1921 if(val_off!=0.){
1922 res_eratio_vec.push_back(( (onl_eratio)-val_off)/val_off);
1923 }else{
1924 res_eratio_vec.push_back(dummy);
1925 }
1926
1927 }// Loop over all pair objects
1928
1929
1930 // Fill everything
1931 fill( monGroup ,
1932 et_col ,
1933 eta_col ,
1934 res_et_col ,
1935 res_eta_col ,
1936 res_phi_col ,
1937 res_ethad_col ,
1938 res_ethad1_col ,
1939 res_Rhad_col ,
1940 res_Rhad1_col ,
1941 res_Reta_col ,
1942 res_Rphi_col ,
1943 res_weta2_col ,
1944 res_f1_col ,
1945 res_f3_col ,
1946 res_eratio_col ,
1947 res_etVsEt_col
1948 );
1949
1950}
xAOD::CaloCluster_v1::et
double et() const
Definition CaloCluster_v1.h:859
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition CaloCluster_v1.cxx:251
xAOD::CaloCluster_v1::phi
virtual double phi() const
The azimuthal angle ( ) of the particle.
Definition CaloCluster_v1.cxx:256
xAOD::Egamma_v1::caloCluster
const xAOD::CaloCluster * caloCluster(size_t index=0) const
Pointer to the xAOD::CaloCluster/s that define the electron candidate.
Definition Egamma_v1.cxx:377
xAOD::Egamma
Egamma_v1 Egamma
Definition of the current "egamma version".
Definition Egamma.h:17
xAOD::TrigEMCluster
TrigEMCluster_v1 TrigEMCluster
Define the latest version of the trigger EM cluster class.
Definition Event/xAOD/xAODTrigCalo/xAODTrigCalo/TrigEMCluster.h:17

◆ fillL2Electron()

void TrigEgammaMonitorAnalysisAlgorithm::fillL2Electron ( const std::string & trigger,
const std::vector< const xAOD::TrigElectron * > & el_vec ) const
private

Definition at line 681 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

682{
683
684 auto monGroup = getGroup(trigger+"_Distributions_L2Electron");
685
686 std::vector<float> et_vec, eta_vec, phi_vec, highet_vec;
687
688 auto et_col = Monitored::Collection("et" , et_vec );
689 auto highet_col = Monitored::Collection("highet" , highet_vec );
690 auto eta_col = Monitored::Collection("eta", eta_vec );
691 auto phi_col = Monitored::Collection("phi", phi_vec );
692
693 for ( const auto *el : el_vec )
694 {
695 if(!el) continue;
696 et_vec.push_back( el->pt()/Gaudi::Units::GeV );
697 highet_vec.push_back( el->pt()/Gaudi::Units::GeV );
698 eta_vec.push_back( el->eta() );
699 phi_vec.push_back( el->phi() );
700 }
701
702 fill( monGroup, et_col, eta_col, phi_col, highet_col );
703}

◆ fillL2Photon()

void TrigEgammaMonitorAnalysisAlgorithm::fillL2Photon ( const std::string & trigger,
const std::vector< const xAOD::TrigPhoton * > & eg_vec ) const
private

Definition at line 705 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

706{
707
708 auto monGroup = getGroup(trigger+"_Distributions_L2Photon");
709
710 std::vector<float> et_vec, eta_vec, phi_vec, highet_vec;
711
712 auto et_col = Monitored::Collection("et" , et_vec );
713 auto highet_col = Monitored::Collection("highet" , highet_vec );
714 auto eta_col = Monitored::Collection("eta", eta_vec );
715 auto phi_col = Monitored::Collection("phi", phi_vec );
716
717 for ( const auto *ph : ph_vec )
718 {
719 if(!ph) continue;
720 et_vec.push_back( ph->pt()/Gaudi::Units::GeV );
721 highet_vec.push_back( ph->pt()/Gaudi::Units::GeV );
722 eta_vec.push_back( ph->eta() );
723 phi_vec.push_back( ph->phi() );
724 }
725
726 fill( monGroup, et_col, eta_col, phi_col, highet_col );
727}

◆ fillLabel()

void TrigEgammaMonitorAnalysisAlgorithm::fillLabel ( const ToolHandle< GenericMonitoringTool > & groupHandle,
const std::string & histname,
const std::string & label ) const
protected

Definition at line 30 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

33{
34 auto mon = Monitored::Scalar<std::string>( histname, label );
35 fill( groupHandle, mon );
36}
label
std::string label(const std::string &format, int i)
Definition label.h:19

◆ fillResolutions()

void TrigEgammaMonitorAnalysisAlgorithm::fillResolutions ( const EventContext & ctx,
const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs,
const TrigInfo & info ) const
protected

***********************************************************************************************************************8

Definition at line 961 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

964{
965
966 std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pair_l1_vec;
967 std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_eg_vec;
968 const std::string trigger = info.trigger;
969
970 SG::Decorator<bool> pidnameDec("is"+info.pidname);
971 for( auto pairObj : pairObjs ){
972
973 const xAOD::Egamma* eg = pairObj.first;
974 const auto *feat = pairObj.second;
975
976 if (feat){
977
978 //
979 // Get only off and l1 where the offline object passed by the offline pid selector
980 //
981 const auto *l1 = match()->getL1Feature( feat );
982 if(eg->type()==xAOD::Type::Electron){
983 const xAOD::Electron* el = static_cast<const xAOD::Electron*>(eg);
984 float et = getEt(el)/Gaudi::Units::GeV;
985 if( et < info.etthr-5.0) continue;
986 if(!pidnameDec(*eg)) continue;
987 pair_eg_vec.emplace_back(el,feat);
988 if(l1) pair_l1_vec.emplace_back(eg,l1 );
989 }
990 else if(eg->type()==xAOD::Type::Photon){
991 float et = getCluster_et(eg)/Gaudi::Units::GeV;
992 if( et < info.etthr-5.0) continue;
993 pair_eg_vec.emplace_back(eg,feat);
994 if(l1) pair_l1_vec.emplace_back(eg,l1 );
995 }
996 }
997
998 }
999
1000 // Fill L1Calo for all level 1 objects found
1001 fillL1CaloResolution( trigger, pair_l1_vec );
1002 fillL1CaloAbsResolution( trigger, pair_l1_vec );
1003 fillL2CaloResolution( trigger, pair_eg_vec );
1004
1005 // Fill HLT electron for all onl objects found
1006 if ( info.signature=="Electron" or info.signature == "e"){
1007 fillHLTElectronResolution( ctx, trigger, pair_eg_vec, info );
1008 }
1009 else if ( info.signature=="Photon" or info.signature == "g"){
1010 fillHLTPhotonResolution( ctx, trigger, pair_eg_vec, info );
1011 }
1012
1013}
TrigEgammaMonitorAnalysisAlgorithm::fillHLTPhotonResolution
void fillHLTPhotonResolution(const EventContext &ctx, const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1456
TrigEgammaMonitorAnalysisAlgorithm::fillHLTElectronResolution
void fillHLTElectronResolution(const EventContext &ctx, const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1076
TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloAbsResolution
void fillL1CaloAbsResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1048
TrigEgammaMonitorAnalysisAlgorithm::fillL2CaloResolution
void fillL2CaloResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1765
TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloResolution
void fillL1CaloResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1018
xAOD::Egamma_v1::type
virtual Type::ObjectType type() const override=0
The type of the object as a simple enumeration, remains pure virtual in e/gamma.

◆ fillShowerShapes()

void TrigEgammaMonitorAnalysisAlgorithm::fillShowerShapes ( const std::string & trigger,
const std::vector< const xAOD::Egamma * > & eg_vec,
bool online ) const
private

Definition at line 785 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

786{
787
788 ATH_MSG_DEBUG("Fill SS distributions: " << trigger);
789 auto monGroup = getGroup( trigger + ( online ? "_Distributions_HLT" : "_Distributions_Offline") );
790
791 std::vector<float> Rhad_vec, Rhad1_vec, Reta_vec, Rphi_vec, weta1_vec, weta2_vec,
792 f1_vec, f3_vec, eratio_vec, et_vec, highet_vec , eta_vec, phi_vec, topoetcone20_vec, topoetcone40_shift_vec,
793 topoetcone20_rel_vec, topoetcone40_shift_rel_vec, ptvarcone20_rel_vec, pt_vec, mu_vec, pt_track_vec, z0_vec, res_etVsEt_vec, res_eprobht_vec, res_cnv_et_vec;
794
795 auto Rhad_col = Monitored::Collection("Rhad" , Rhad_vec );
796 auto Rhad1_col = Monitored::Collection("Rhad1" , Rhad1_vec );
797 auto Reta_col = Monitored::Collection("Reta" , Reta_vec );
798 auto Rphi_col = Monitored::Collection("Rphi" , Rphi_vec );
799 auto weta1_col = Monitored::Collection("weta1" , weta1_vec );
800 auto weta2_col = Monitored::Collection("weta2" , weta2_vec );
801 auto f1_col = Monitored::Collection("f1" , f1_vec );
802 auto f3_col = Monitored::Collection("f3" , f3_vec );
803 auto eratio_col = Monitored::Collection("eratio" , eratio_vec );
804 auto et_col = Monitored::Collection("et" , et_vec );
805 auto highet_col = Monitored::Collection("highet" , highet_vec );
806 auto eta_col = Monitored::Collection("eta" , eta_vec );
807 auto phi_col = Monitored::Collection("phi" , phi_vec );
808 auto topoetcone20_col = Monitored::Collection("topoetcone20", topoetcone20_vec);
809 auto topoetcone40_shift_col = Monitored::Collection("topoetcone40_shift", topoetcone40_shift_vec );
810 auto topoetcone20_rel_col = Monitored::Collection("topoetcone20_rel", topoetcone20_rel_vec);
811 auto topoetcone40_shift_rel_col = Monitored::Collection("topoetcone40_shift_rel", topoetcone40_shift_rel_vec );
812 auto ptvarcone20_rel_col = Monitored::Collection("ptvarcone20_rel", ptvarcone20_rel_vec );
813 auto pt_col = Monitored::Collection("pt", pt_vec );
814 auto mu_col = Monitored::Collection("mu", mu_vec );
815 auto pt_track_col = Monitored::Collection("pt_track", pt_track_vec );
816 auto z0_col = Monitored::Collection("z0", z0_vec );
817 auto res_etVsEt_col = Monitored::Collection("res_etVsEt", res_etVsEt_vec );
818 auto res_eprobht_col = Monitored::Collection("res_eprobht", res_eprobht_vec );
819 auto res_cnv_et_col = Monitored::Collection("res_cnv_et", res_cnv_et_vec );
820
821 for ( const auto *eg : eg_vec ){
822
823 if(!eg) continue;
824
825 Rhad_vec.push_back( getShowerShape_Rhad(eg));
826 Rhad1_vec.push_back( getShowerShape_Rhad(eg));
827 Reta_vec.push_back( getShowerShape_Reta(eg));
828 Rphi_vec.push_back( getShowerShape_Rphi(eg));
829 weta1_vec.push_back( getShowerShape_weta1(eg));
830 weta2_vec.push_back( getShowerShape_weta2(eg));
831 f1_vec.push_back( getShowerShape_f1(eg));
832 f3_vec.push_back( getShowerShape_f3(eg));
833 eratio_vec.push_back( getShowerShape_Eratio(eg));
834 et_vec.push_back( eg->pt()/Gaudi::Units::GeV);
835 highet_vec.push_back( eg->pt()/Gaudi::Units::GeV);
836 eta_vec.push_back( eg->eta());
837 phi_vec.push_back( eg->phi());
838 topoetcone20_vec.push_back( getIsolation_topoetcone20(eg)/Gaudi::Units::GeV);
839 topoetcone40_shift_vec.push_back( (getIsolation_topoetcone40(eg)-2450)/Gaudi::Units::GeV );
840
841 if (eg->pt() > 0) {
842 topoetcone20_rel_vec.push_back( getIsolation_topoetcone20(eg)/eg->pt());
843 topoetcone40_shift_rel_vec.push_back( (getIsolation_topoetcone40(eg)-2450)/eg->pt() );
844 }
845
846 }// Loop over egamma objects
847
848 fill( monGroup, Rhad_col, Rhad1_col, Reta_col, Rphi_col, weta1_col, weta2_col,
849 f1_col, f3_col, eratio_col, et_col, highet_col , eta_col, phi_col, topoetcone20_col, topoetcone40_shift_col,
850 topoetcone20_rel_col, topoetcone40_shift_rel_col, ptvarcone20_rel_col, pt_col, mu_col, pt_track_col, z0_col, res_etVsEt_col, res_eprobht_col, res_cnv_et_col);
851
852}

◆ fillTracking()

void TrigEgammaMonitorAnalysisAlgorithm::fillTracking ( const EventContext & ctx,
const std::string & trigger,
const std::vector< const xAOD::Electron * > & eg_vec,
bool online ) const
private

Definition at line 855 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

856{
857
858 ATH_MSG_DEBUG("Fill tracking");
859
860 auto monGroup = getGroup( trigger + ( online ? "_Distributions_HLT" : "_Distributions_Offline") );
861
862 std::vector<float> deta1_vec, deta1_EMECA_vec, deta1_EMECC_vec, deta1_EMEBA_vec, deta1_EMEBC_vec, deta2_vec, dphi2_vec,
863 dphiresc_vec, eprobht_vec, npixhits_vec, nscthits_vec, charge_vec, ptcone20_vec, ptvarcone20_vec, ptcone30_vec, ptvarcone30_vec, z0_vec, d0_vec, d0sig_vec,
864 pt_vec,pt_trk_vec, ptcone20_rel_vec, ptvarcone20_rel_vec, ptcone30_rel_vec, ptvarcone30_rel_vec, eta_vec, mu_vec;
865
866 auto deta1_col = Monitored::Collection( "deta1" , deta1_vec );
867 auto deta1_EMECA_col = Monitored::Collection( "deta1_EMECA" , deta1_EMECA_vec );
868 auto deta1_EMECC_col = Monitored::Collection( "deta1_EMECC" , deta1_EMECC_vec );
869 auto deta1_EMEBA_col = Monitored::Collection( "deta1_EMEBA" , deta1_EMEBA_vec );
870 auto deta1_EMEBC_col = Monitored::Collection( "deta1_EMEBC" , deta1_EMEBC_vec );
871 auto deta2_col = Monitored::Collection( "deta2" , deta2_vec );
872 auto dphi2_col = Monitored::Collection( "dphi2" , dphi2_vec );
873 auto dphiresc_col = Monitored::Collection( "dphiresc" , dphiresc_vec );
874 auto eprobht_col = Monitored::Collection( "eprobht" , eprobht_vec );
875 auto npixhits_col = Monitored::Collection( "npixhits" , npixhits_vec );
876 auto nscthits_col = Monitored::Collection( "nscthits" , nscthits_vec );
877 auto charge_col = Monitored::Collection( "charge" , charge_vec );
878 auto ptcone20_col = Monitored::Collection( "ptcone20" , ptcone20_vec );
879 auto ptvarcone20_col = Monitored::Collection( "ptvarcone20" , ptvarcone20_vec );
880 auto ptcone30_col = Monitored::Collection( "ptcone30" , ptcone30_vec );
881 auto ptvarcone30_col = Monitored::Collection( "ptvarcone30" , ptvarcone30_vec );
882 auto z0_col = Monitored::Collection( "z0" , z0_vec );
883 auto d0_col = Monitored::Collection( "d0" , d0_vec );
884 auto d0sig_col = Monitored::Collection( "d0sig" , d0sig_vec );
885 auto pt_col = Monitored::Collection( "pt" , pt_vec );
886 auto pt_trk_col = Monitored::Collection( "pt_track" , pt_trk_vec );
887 auto ptcone20_rel_col = Monitored::Collection( "ptcone20_rel", ptcone20_rel_vec );
888 auto ptvarcone20_rel_col = Monitored::Collection( "ptvarcone20_rel" , ptvarcone20_rel_vec );
889 auto ptcone30_rel_col = Monitored::Collection( "ptcone30_rel", ptcone30_rel_vec );
890 auto ptvarcone30_rel_col = Monitored::Collection( "ptvarcone30_rel" , ptvarcone30_rel_vec );
891
892 auto eta_col = Monitored::Collection( "eta" , eta_vec );
893 auto mu_col = Monitored::Collection( "mu" , mu_vec );
894
895
896 for ( const auto *eg : eg_vec ){
897
898 if(!eg) continue;
899
900 float cleta = 0.;
901 if(eg->caloCluster()) cleta=eg->caloCluster()->eta();
902 else cleta=eg->eta();
903
904 deta1_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
905
906 if(cleta > 1.375 && cleta < 3.2)
907 deta1_EMECA_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
908 if(cleta < -1.375 && cleta > -3.2)
909 deta1_EMECC_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
910 if(cleta > 0 && cleta < 1.375)
911 deta1_EMEBA_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
912 if(cleta < 0 && cleta > -1.375)
913 deta1_EMEBC_vec.push_back( getCaloTrackMatch_deltaEta1(eg));
914
915 deta2_vec.push_back( getCaloTrackMatch_deltaEta2(eg));
916 dphi2_vec.push_back( getCaloTrackMatch_deltaPhi2(eg));
917 dphiresc_vec.push_back( getCaloTrackMatch_deltaPhiRescaled2(eg));
918 eprobht_vec.push_back( getTrackSummaryFloat_eProbabilityHT(eg));
919 npixhits_vec.push_back( getTrackSummary_numberOfPixelHits(eg));
920 nscthits_vec.push_back( getTrackSummary_numberOfSCTHits(eg));
921 charge_vec.push_back( eg->charge());
922 ptcone20_vec.push_back( getIsolation_ptcone20(eg)/Gaudi::Units::GeV);
923 ptvarcone20_vec.push_back( getIsolation_ptvarcone20(eg)/Gaudi::Units::GeV);
924 ptcone30_vec.push_back( getIsolation_ptcone30(eg)/Gaudi::Units::GeV);
925 ptvarcone30_vec.push_back( getIsolation_ptvarcone30(eg)/Gaudi::Units::GeV);
926
927 // Quantities directly from tracks
928 ATH_MSG_DEBUG("Get track Quantities");
929 z0_vec.push_back( getTrack_z0(eg));
930 d0_vec.push_back( getTrack_d0(eg));
931 d0sig_vec.push_back(getD0sig(eg));
932 pt_vec.push_back( eg->pt()/Gaudi::Units::GeV);
933 pt_trk_vec.push_back( getTrack_pt(eg)/Gaudi::Units::GeV);
934 eta_vec.push_back(eg->eta());
935
936 const float avgmu=lbAverageInteractionsPerCrossing( ctx );
937 mu_vec.push_back( avgmu );
938
939 if (eg->pt() > 0) {
940 ptcone20_rel_vec.push_back( getIsolation_ptcone20(eg)/eg->pt());
941 ptvarcone20_rel_vec.push_back( getIsolation_ptvarcone20(eg)/eg->pt());
942 ptcone30_rel_vec.push_back( getIsolation_ptcone30(eg)/eg->pt());
943 ptvarcone30_rel_vec.push_back( getIsolation_ptvarcone30(eg)/eg->pt());
944 }
945
946 }
947
948
949 fill( monGroup, deta1_col, deta1_EMECA_col, deta1_EMECC_col, deta1_EMEBA_col, deta1_EMEBC_col, deta2_col, dphi2_col,
950 dphiresc_col, eprobht_col, npixhits_col, nscthits_col, charge_col, ptcone20_col, ptvarcone20_col, ptcone30_col, ptvarcone30_col, z0_col, d0_col, d0sig_col,
951 pt_col, ptcone20_rel_col, ptvarcone20_rel_col, ptcone30_rel_col, ptvarcone30_rel_col, eta_col, mu_col,pt_trk_col);
952}

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

96 {
97 return execState( ctx ).filterPassed();
98 }
AthCommonReentrantAlgorithm::filterPassed
virtual bool filterPassed(const EventContext &ctx) const
Definition AthCommonReentrantAlgorithm.h:96

◆ getD0sig()

float TrigEgammaMonitorBaseAlgorithm::getD0sig ( const xAOD::Electron * eg) const
protectedinherited

Definition at line 386 of file TrigEgammaMonitorBaseAlgorithm.cxx.

386 {
387 const xAOD::TrackParticle* t = eg->trackParticle();
388 float d0sigma=0.;
389 if (t)
390 {
391 float vard0 = t->definingParametersCovMatrix()(0,0);
392 if (vard0 > 0) {
393 d0sigma=sqrtf(vard0);
394 }
395 else return -99.;
396
397 if (fabs(d0sigma) < 1e-6) return -99.;
398 return t->d0()/d0sigma;
399 }
400 else return -99.;
401}
xAOD::Electron_v1::trackParticle
const xAOD::TrackParticle * trackParticle(size_t index=0) const
Pointer to the xAOD::TrackParticle/s that match the electron candidate.
Definition Electron_v1.cxx:60
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:8
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13

◆ getDEmaxs1()

float TrigEgammaMonitorBaseAlgorithm::getDEmaxs1 ( const xAOD::Egamma * eg) const
protectedinherited

Definition at line 336 of file TrigEgammaMonitorBaseAlgorithm.cxx.

336 {
337 if(eg){
338 float emax2=0.;
339 eg->showerShapeValue(emax2, xAOD::EgammaParameters::e2tsts1);
340 float emax=0.;
341 eg->showerShapeValue(emax, xAOD::EgammaParameters::emaxs1);
342 float den = emax+emax2;
343
344 if (fabs(den) < 1e-6) return -99.;
345
346 float val = (emax-emax2)/(den);
347 return val;
348 }
349 else return -99.;
350}
xAOD::Egamma_v1::showerShapeValue
bool showerShapeValue(float &value, const EgammaParameters::ShowerShapeType information) const
Accessor for ShowerShape values.
Definition Egamma_v1.cxx:196
Pythia8_RapidityOrderMPI.val
val
Definition Pythia8_RapidityOrderMPI.py:14
xAOD::EgammaParameters::emaxs1
@ emaxs1
energy of strip with maximal energy deposit
Definition EgammaEnums.h:146
xAOD::EgammaParameters::e2tsts1
@ e2tsts1
energy of the cell corresponding to second energy maximum in the first sampling
Definition EgammaEnums.h:109

◆ getE0Eaccordion()

float TrigEgammaMonitorBaseAlgorithm::getE0Eaccordion ( const xAOD::Egamma * eg) const
protectedinherited

Definition at line 452 of file TrigEgammaMonitorBaseAlgorithm.cxx.

452 {
453 if(eg && (eg->caloCluster())){
454 const xAOD::CaloCluster* cluster = eg->caloCluster();
455 float ebe0 = cluster->energyBE(0);
456 float ebe1 = cluster->energyBE(1);
457 float ebe2 = cluster->energyBE(2);
458 float ebe3 = cluster->energyBE(3);
459 float eacc = ebe1+ebe2+ebe3;
460 if(eacc==0.) return 0.;
461 return (ebe0/eacc);
462 }
463 else return 0.;
464}
xAOD::CaloCluster_v1::energyBE
float energyBE(const unsigned layer) const
Get the energy in one layer of the EM Calo.
Definition CaloCluster_v1.cxx:623
xAOD::CaloCluster
CaloCluster_v1 CaloCluster
Define the latest version of the calorimeter cluster class.
Definition Event/xAOD/xAODCaloEvent/xAODCaloEvent/CaloCluster.h:19

◆ getEaccordion()

float TrigEgammaMonitorBaseAlgorithm::getEaccordion ( const xAOD::Egamma * eg) const
protectedinherited

Definition at line 440 of file TrigEgammaMonitorBaseAlgorithm.cxx.

440 {
441 if(eg && (eg->caloCluster())){
442 const xAOD::CaloCluster* cluster = eg->caloCluster();
443 float ebe1 = cluster->energyBE(1);
444 float ebe2 = cluster->energyBE(2);
445 float ebe3 = cluster->energyBE(3);
446 return (ebe1+ebe2+ebe3);
447 }
448 else return 0.;
449}

◆ getEnergyBE0()

float TrigEgammaMonitorBaseAlgorithm::getEnergyBE0 ( const xAOD::Egamma * eg) const
protectedinherited

Definition at line 404 of file TrigEgammaMonitorBaseAlgorithm.cxx.

404 {
405 if(eg && (eg->caloCluster())){
406 const xAOD::CaloCluster* cluster = eg->caloCluster();
407 return cluster->energyBE(0);
408 }
409 else return 0;
410}

◆ getEnergyBE1()

float TrigEgammaMonitorBaseAlgorithm::getEnergyBE1 ( const xAOD::Egamma * eg) const
protectedinherited

Definition at line 413 of file TrigEgammaMonitorBaseAlgorithm.cxx.

413 {
414 if(eg && (eg->caloCluster())){
415 const xAOD::CaloCluster* cluster = eg->caloCluster();
416 return cluster->energyBE(1);
417 }
418 else return 0.;
419}

◆ getEnergyBE2()

float TrigEgammaMonitorBaseAlgorithm::getEnergyBE2 ( const xAOD::Egamma * eg) const
protectedinherited

Definition at line 422 of file TrigEgammaMonitorBaseAlgorithm.cxx.

422 {
423 if(eg && (eg->caloCluster())){
424 const xAOD::CaloCluster* cluster = eg->caloCluster();
425 return cluster->energyBE(2);
426 }
427 else return 0.;
428}

◆ getEnergyBE3()

float TrigEgammaMonitorBaseAlgorithm::getEnergyBE3 ( const xAOD::Egamma * eg) const
protectedinherited

Definition at line 431 of file TrigEgammaMonitorBaseAlgorithm.cxx.

431 {
432 if(eg && (eg->caloCluster())){
433 const xAOD::CaloCluster* cluster = eg->caloCluster();
434 return cluster->energyBE(3);
435 }
436 else return 0.;
437}

◆ getEt()

float TrigEgammaMonitorBaseAlgorithm::getEt ( const xAOD::Electron * eg) const
protectedinherited

Definition at line 315 of file TrigEgammaMonitorBaseAlgorithm.cxx.

315 {
316 if(eg && (eg->caloCluster()) && (eg->trackParticle())){
317 const xAOD::TrackParticle *trk=eg->trackParticle();
318 const xAOD::CaloCluster *clus=eg->caloCluster();
319 float eta = fabs(trk->eta());
320 return clus->e()/cosh(eta);
321 }
322 else return -99.;
323}
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition CaloCluster_v1.cxx:265
xAOD::TrackParticle_v1::eta
virtual double eta() const override final
The pseudorapidity ( ) of the particle.
Definition TrackParticle_v1.cxx:79

◆ getEta2()

float TrigEgammaMonitorBaseAlgorithm::getEta2 ( const xAOD::Egamma * eg) const
protectedinherited

Features helper.

Helper functions now part of base class

Definition at line 306 of file TrigEgammaMonitorBaseAlgorithm.cxx.

306 {
307 if(eg && (eg->caloCluster())){
308 const xAOD::CaloCluster* cluster = eg->caloCluster();
309 return fabs(cluster->etaBE(2));
310 }
311 else return -99.;
312}
xAOD::CaloCluster_v1::etaBE
float etaBE(const unsigned layer) const
Get the eta in one layer of the EM Calo.
Definition CaloCluster_v1.cxx:628

◆ getEtCluster37()

float TrigEgammaMonitorBaseAlgorithm::getEtCluster37 ( const xAOD::Egamma * eg) const
protectedinherited

Definition at line 326 of file TrigEgammaMonitorBaseAlgorithm.cxx.

326 {
327 if(eg && (eg->caloCluster())){
328 const xAOD::CaloCluster* cluster = eg->caloCluster();
329 float eta2 = fabs(cluster->etaBE(2));
330 return cluster->e()/cosh(eta2);
331 }
332 else return -99.;
333}
ParticleGun_SamplingFraction.eta2
eta2
Definition ParticleGun_SamplingFraction.py:96

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

111 {
112 return SG::ReadHandle<xAOD::EventInfo>(m_EventInfoKey, ctx);
113}
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition AthMonitorAlgorithm.h:367

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

168 {
169 // get the pointer to the tool, and check that it exists
170 auto idx = m_toolLookupMap.find(name);
171 //Check if the tool exists in the map
172 if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
173 return m_tools[idx->second];
174 }
175 else {
176 //Check if the map is empty
177 if (m_toolLookupMap.empty()) {
178 ATH_MSG_FATAL("The m_toolLookupMap is empty. The tool " << name << " cannot be found in an empty map.");
179 return m_dummy;
180 }
181 //If the map is not empty and the tool was not found, print a fatal error
182 if (!m_toolLookupMap.empty()) {
183 std::string available = std::accumulate(
184 m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
185 [](const std::string& s, auto h) { return s + "," + h.first; });
186 ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
187 << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
188 << "your python configuration and c++ filling code. Note: your available groups are {"
189 << available << "}.");
190
191 return m_dummy;
192 }
193 if (!isInitialized()) {
194 ATH_MSG_FATAL(
195 "It seems that the AthMonitorAlgorithm::initialize was not called "
196 "in derived class initialize method, group name: " << name);
197 }
198 }
199 return m_dummy;
200}
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition AthMsgStreamMacros.h:34
ATH_LIKELY
#define ATH_LIKELY(x)
Definition AthUnlikelyMacros.h:16
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t > m_toolLookupMap
Definition AthMonitorAlgorithm.h:372
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition AthMonitorAlgorithm.h:374
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition AthMonitorAlgorithm.h:341
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition LArNewCalib_DelayDump_OFC_Cali.py:69

◆ getL1Item()

std::string TrigEgammaMonitorBaseAlgorithm::getL1Item ( const std::string & trigger) const
protectedinherited

Creates static map to return L1 item from trigger name.

Definition at line 935 of file TrigEgammaMonitorBaseAlgorithm.cxx.

935 {
936 std::vector<std::string> parts;
937 boost::split(parts,trigger,boost::is_any_of("_"));
938 // L1EMXX
939 std::string l1seed = parts.back();
940 return l1seed;
941}

◆ getProbeInformation()

std::string TrigEgammaMonitorBaseAlgorithm::getProbeInformation ( const std::vector< ChainNameParser::LegInfo > & LegParts,
const std::string & signature ) const
inherited

◆ getProbeTriggerLeg()

std::vector< ChainNameParser::LegInfo > TrigEgammaMonitorBaseAlgorithm::getProbeTriggerLeg ( const std::string & triggerName) const
inherited

Definition at line 755 of file TrigEgammaMonitorBaseAlgorithm.cxx.

756{
757 std::vector<ChainNameParser::LegInfo> result;
758
759 for (const ChainNameParser::LegInfo& legInfo : ChainNameParser::HLTChainInfo(triggerName))
760 {
761 ATH_MSG_DEBUG("Full trigger name = " << triggerName
762 << ", multiplicity = " << legInfo.multiplicity
763 << ", signature = " << legInfo.signature
764 << ", threshold = " << legInfo.threshold
765 << ", leg parts = "<< legInfo.legParts); //Gives the pidname
766
767 result.push_back(legInfo);
768 }
769
770 return result;
771}
get_generator_info.result
result
Definition get_generator_info.py:21

◆ getSigmaD0()

float TrigEgammaMonitorBaseAlgorithm::getSigmaD0 ( const xAOD::Electron * eg) const
protectedinherited

Definition at line 370 of file TrigEgammaMonitorBaseAlgorithm.cxx.

370 {
371 const xAOD::TrackParticle* t = eg->trackParticle();
372 float d0sigma=0.;
373 if (t)
374 {
375 float vard0 = t->definingParametersCovMatrix()(0,0);
376 if (vard0 > 0) {
377 d0sigma=sqrtf(vard0);
378 }
379 else return -99.;
380 return d0sigma;
381 }
382 else return -99.;
383}

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

203 {
204 return m_trigDecTool;
205}

◆ getTrigInfo()

TrigInfo TrigEgammaMonitorBaseAlgorithm::getTrigInfo ( const std::string & trigger) const
protectedinherited

Get the trigger info parsed from the chain name (only single lepton triggers).

Definition at line 607 of file TrigEgammaMonitorBaseAlgorithm.cxx.

607 {
608 return m_trigInfo.at(trigger);
609}
TrigEgammaMonitorBaseAlgorithm::m_trigInfo
std::map< std::string, TrigInfo > m_trigInfo
creates map of trigger name and TrigInfo struct
Definition TrigEgammaMonitorBaseAlgorithm.h:89

◆ getTrigInfoMap()

const std::map< std::string, TrigInfo > & TrigEgammaMonitorBaseAlgorithm::getTrigInfoMap ( ) const
inlineprotectedinherited

Helper methods.

Get the trig info map

Definition at line 138 of file TrigEgammaMonitorBaseAlgorithm.h.

138{ return m_trigInfo; }

◆ getTrigInfoMapR3()

const std::map< std::string, TrigInfo > & TrigEgammaMonitorBaseAlgorithm::getTrigInfoMapR3 ( ) const
inlineprotectedinherited

Definition at line 139 of file TrigEgammaMonitorBaseAlgorithm.h.

139{ return m_trigInfoR3; }
TrigEgammaMonitorBaseAlgorithm::m_trigInfoR3
std::map< std::string, TrigInfo > m_trigInfoR3
Definition TrigEgammaMonitorBaseAlgorithm.h:90

◆ getTrigInfoR3()

TrigInfo TrigEgammaMonitorBaseAlgorithm::getTrigInfoR3 ( const std::string & trigger) const
protectedinherited

Definition at line 611 of file TrigEgammaMonitorBaseAlgorithm.cxx.

611 {
612 return m_trigInfoR3.at(trigger);
613}

◆ initialize()

StatusCode TrigEgammaMonitorAnalysisAlgorithm::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from TrigEgammaMonitorBaseAlgorithm.

Reimplemented in TrigEgammaMonitorElectronAlgorithm, TrigEgammaMonitorPhotonAlgorithm, TrigEgammaMonitorTagAndProbeAlgorithm, and TrigEgammaMonitorTagAndProbeAlgorithmZeeg.

Definition at line 17 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

18{
19 ATH_MSG_INFO("TrigEgammaMonitorAnalysisAlgorithm::initialize()...");
20 ATH_CHECK(TrigEgammaMonitorBaseAlgorithm::initialize());
21
22 return StatusCode::SUCCESS;
23}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
TrigEgammaMonitorBaseAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition TrigEgammaMonitorBaseAlgorithm.cxx:26

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

50{
51 // Reentrant algorithms are clonable.
52 return true;
53}

◆ isHLTTruncated()

bool TrigEgammaMonitorBaseAlgorithm::isHLTTruncated ( ) const
protectedinherited

Definition at line 944 of file TrigEgammaMonitorBaseAlgorithm.cxx.

944 {
945 return m_trigdec->ExperimentalAndExpertMethods().isHLTTruncated();
946}
TrigEgammaMonitorBaseAlgorithm::m_trigdec
ToolHandle< Trig::TrigDecisionTool > m_trigdec
Trigger decision tool.
Definition TrigEgammaMonitorBaseAlgorithm.h:87

◆ isIsolated()

bool TrigEgammaMonitorBaseAlgorithm::isIsolated ( const xAOD::Electron * eg,
const std::string & isolation ) const
protectedinherited

Check if electron fulfils isolation criteria.

Definition at line 116 of file TrigEgammaMonitorBaseAlgorithm.cxx.

116 {
117 ATH_MSG_DEBUG("Apply Isolation " << isolation);
118 float ptcone20=0;
119 bool isoStat=eg->isolationValue(ptcone20, xAOD::Iso::ptcone20);
120 if (!isoStat) {
121 ATH_MSG_DEBUG("Electron doesn't provide isolation for ptcone20");
122 return false;
123 }
124 if (!(fabs(eg->pt()) > 0)) {
125 ATH_MSG_DEBUG("Electron pt is zero, can't calculate relative isolation");
126 return false;
127 }
128 ATH_MSG_DEBUG("ptcone20 " << ptcone20);
129 float ptcone20_rel = ptcone20/eg->pt();
130 ATH_MSG_DEBUG("Relative isolation value " << ptcone20_rel);
131 if (isolation == "loose"){
132 if (ptcone20_rel > 0.1) {
133 ATH_MSG_DEBUG("Probe failing isolation");
134 return false;
135 } else {
136 ATH_MSG_DEBUG("Probe passing isolation");
137 return true;
138 }
139 }
140 else {
141 ATH_MSG_DEBUG("No valid working point defined for " << isolation << " continue without isolation");
142 }
143 return false;
144}
xAOD::Egamma_v1::isolationValue
bool isolationValue(float &value, const Iso::IsolationType information) const
old Accessor for Isolation values.
Definition Egamma_v1.h:251
xAOD::Iso::ptcone20
@ ptcone20
Track isolation.
Definition IsolationType.h:40

◆ isPrescaled()

bool TrigEgammaMonitorBaseAlgorithm::isPrescaled ( const std::string & trigger) const
protectedinherited

Check if the event is prescaled.

Definition at line 148 of file TrigEgammaMonitorBaseAlgorithm.cxx.

148 {
149
150 bool efprescale=false;
151 bool l1prescale=false;
152 bool prescale=false;
153 bool rerun=true; //assume rerun for l1
154 std::string l1item="";
155
156 if(trigger.starts_with( "L1" ))
157 l1item=trigger;
158 if(trigger.starts_with("HLT")){
159 l1item = getL1Item(trigger);
160 const unsigned int bit=tdt()->isPassedBits(trigger);
161 efprescale=bit & TrigDefs::EF_prescaled;
162 rerun=bit&TrigDefs::EF_resurrected; //Rerun, only check for HLT
163 }
164
165
166 ATH_MSG_DEBUG("Checking prescale for " << trigger << " " << l1item);
167 const unsigned int l1bit=tdt()->isPassedBits(l1item);
168 bool l1_afterpre=l1bit&TrigDefs::L1_isPassedAfterPrescale;
169 bool l1_beforepre=l1bit&TrigDefs::L1_isPassedBeforePrescale;
170 l1prescale=l1_beforepre && !l1_afterpre;
171 prescale=efprescale || l1prescale;
172 ATH_MSG_DEBUG("L1 prescale " << l1item << " " << l1prescale << " before " << l1_beforepre << " after " << l1_afterpre);
173 ATH_MSG_DEBUG("EF prescale " << trigger << " " << efprescale << " Prescale " << prescale);
174 if(rerun) return false; // Rerun use the event
175 if(prescale) return true; // Prescaled, reject event
176 return false; // Not prescaled, use event
177}
TrigEgammaMonitorBaseAlgorithm::getL1Item
std::string getL1Item(const std::string &trigger) const
Creates static map to return L1 item from trigger name.
Definition TrigEgammaMonitorBaseAlgorithm.cxx:935
HI::bit
constexpr unsigned int bit(int n)
Definition IHIEventSelectionToolRun3.h:34

◆ match()

const ToolHandle< TrigEgammaMatchingToolMT > & TrigEgammaMonitorBaseAlgorithm::match ( ) const
inlineprotectedinherited

Get the e/g match tool.

Definition at line 148 of file TrigEgammaMonitorBaseAlgorithm.h.

148{return m_matchTool;}
TrigEgammaMonitorBaseAlgorithm::m_matchTool
ToolHandle< TrigEgammaMatchingToolMT > m_matchTool
Definition TrigEgammaMonitorBaseAlgorithm.h:96

◆ matchR3()

const ToolHandle< Trig::IMatchingTool > & TrigEgammaMonitorBaseAlgorithm::matchR3 ( ) const
inlineprotectedinherited

Definition at line 149 of file TrigEgammaMonitorBaseAlgorithm.h.

149{return m_matchTool_R3;}
TrigEgammaMonitorBaseAlgorithm::m_matchTool_R3
ToolHandle< Trig::IMatchingTool > m_matchTool_R3
Definition TrigEgammaMonitorBaseAlgorithm.h:97

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

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

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

350 {
351 std::string item;
352 std::stringstream ss(line);
353
354 ATH_MSG_DEBUG( "AthMonitorAlgorithm::parseList()" );
355
356 while ( std::getline(ss, item, ',') ) {
357 std::stringstream iss(item); // remove whitespace
358 iss >> item;
359 result.push_back(item);
360 }
361
362 return StatusCode::SUCCESS;
363}
ss
static Double_t ss
Definition LArPhysWaveHECTool.cxx:37

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

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

◆ rTRT()

float TrigEgammaMonitorBaseAlgorithm::rTRT ( const xAOD::Electron * eg) const
protectedinherited

Definition at line 353 of file TrigEgammaMonitorBaseAlgorithm.cxx.

353 {
354 if(eg && eg->trackParticle()){
355 uint8_t trtHits = 0;
356 eg->trackParticleSummaryValue(trtHits,xAOD::numberOfTRTHits);
357 uint8_t trtHTHits = 0;
358 eg->trackParticleSummaryValue(trtHTHits,xAOD::numberOfTRTHighThresholdHits);
359 if (fabs(trtHits) < 1e-6) {
360 return -99.;
361 }
362 else{
363 return ( (double)trtHTHits / (double)trtHits );
364 }
365 }
366 else return -99.;
367}
xAOD::Electron_v1::trackParticleSummaryValue
bool trackParticleSummaryValue(uint8_t &value, const SummaryType information, int index=0) const
Accessor to the matching track(s) float information (index = 0 is the best match) If 'information' is...
Definition Electron_v1.cxx:145
xAOD::numberOfTRTHits
@ numberOfTRTHits
number of TRT hits [unit8_t].
Definition TrackingPrimitives.h:276
xAOD::numberOfTRTHighThresholdHits
@ numberOfTRTHighThresholdHits
number of TRT hits which pass the high threshold (only xenon counted) [unit8_t].
Definition TrackingPrimitives.h:279

◆ setAccept()

asg::AcceptData TrigEgammaMonitorBaseAlgorithm::setAccept ( const TrigCompositeUtils::Decision * dec,
const TrigInfo & info,
const bool onlyHLT ) const
protectedinherited

Set the accept object for all trigger levels.

Definition at line 181 of file TrigEgammaMonitorBaseAlgorithm.cxx.

181 {
182
183 ATH_MSG_DEBUG("setAccept");
184
185 unsigned int condition=TrigDefs::includeFailedDecisions;
186
187 asg::AcceptData acceptData (&m_accept);
188
189 bool passedL1Calo=false;
190 bool passedL2Calo=false;
191 bool passedEFCalo=false;
192 bool passedL2=false;
193 bool passedEFTrk=false;
194 bool passedEF=false;
195
196 if (dec) {
197 auto trigger = info.trigger;
198 if (!onlyHLT){
199 // Step 1
200 passedL1Calo = match()->ancestorPassed<TrigRoiDescriptorCollection>( dec , trigger , "initialRois", condition);
201
202 if( passedL1Calo ){ // HLT item get full decision
203 // Step 2
204 passedL2Calo = match()->ancestorPassed<xAOD::TrigEMClusterContainer>(dec, trigger, match()->key("FastCalo"), condition);
205
206 if(passedL2Calo){
207
208 // Step 3
209 if(info.signature == "Electron" or info.signature == "e"){
210 std::string key = match()->key("FastElectrons");
211 if(info.lrt) key = match()->key("FastElectrons_LRT");
212 passedL2 = match()->ancestorPassed<xAOD::TrigElectronContainer>(dec, trigger, key, condition);
213 }else if(info.signature == "Photon" or info.signature == "g"){
214 passedL2 = match()->ancestorPassed<xAOD::TrigPhotonContainer>(dec, trigger, match()->key("FastPhotons"), condition);
215 }
216
217 if(passedL2){
218
219 // Step 4
220 std::string key = match()->key("PrecisionCalo_Electron");
221 if(info.signature == "Photon" or info.signature == "g") key = match()->key("PrecisionCalo_Photon");
222 if(info.lrt) key = match()->key("PrecisionCalo_LRT");
223 if(info.ion) key = match()->key("PrecisionCalo_HI");
224
225 passedEFCalo = match()->ancestorPassed<xAOD::CaloClusterContainer>(dec, trigger, key, condition);
226
227 if(passedEFCalo){
228
229 // Step 5
230 passedEFTrk=true;// Assume true for photons
231
232 // Step 6
233 if(info.signature == "Electron" or info.signature == "e"){
234 if( info.etcut || info.idperf){// etcut or idperf
235 passedEF = true; // since we dont run the preciseElectron step
236 }else{
237 std::string key = match()->key("Electrons_GSF");
238 if(info.lrt) key = match()->key("Electrons_LRT");
239 if(info.nogsf) key = match()->key("Electrons");
240 passedEF = match()->ancestorPassed<xAOD::ElectronContainer>(dec, trigger, key, condition);
241 }
242
243 }else if(info.signature == "Photon" or info.signature == "g"){
244 if (info.etcut){
245 passedEF = true; // since we dont run the precisePhoton step
246 }else{
247 passedEF = match()->ancestorPassed<xAOD::PhotonContainer>(dec, trigger, match()->key("Photons"), condition);
248 }
249 }
250 } // EFCalo
251 }// L2
252 }// L2Calo
253 }// L2Calo
254
255 }
256 else{
257 if(info.signature == "Electron" or info.signature == "e"){
258 if( info.etcut || info.idperf){// etcut or idperf
259 passedEF = true; // since we dont run the preciseElectron step
260 }else{
261 std::string key = match()->key("Electrons_GSF");
262 if(info.lrt) key = match()->key("Electrons_LRT");
263 if(info.nogsf) key = match()->key("Electrons");
264 passedEF = match()->ancestorPassed<xAOD::ElectronContainer>(dec, trigger, key, condition);
265 }
266
267 }else if(info.signature == "Photon" or info.signature == "g"){
268 if (info.etcut){
269 passedEF = true; // since we dont run the precisePhoton step
270 }else{
271 passedEF = match()->ancestorPassed<xAOD::PhotonContainer>(dec, trigger, match()->key("Photons"), condition);
272 }
273 }
274 }
275 }
276
277 acceptData.setCutResult("L1Calo",passedL1Calo);
278 acceptData.setCutResult("L2Calo",passedL2Calo);
279 acceptData.setCutResult("L2",passedL2);
280 acceptData.setCutResult("EFCalo",passedEFCalo);
281 acceptData.setCutResult("EFTrack",passedEFTrk);
282 acceptData.setCutResult("HLT",passedEF);
283 ATH_MSG_DEBUG("Accept results:");
284 ATH_MSG_DEBUG("L1: "<< passedL1Calo);
285 ATH_MSG_DEBUG("L2Calo: " << passedL2Calo);
286 ATH_MSG_DEBUG("L2: "<< passedL2);
287 ATH_MSG_DEBUG("EFCalo: "<< passedEFCalo);
288 ATH_MSG_DEBUG("HLT: "<<passedEF);
289
290 return acceptData;
291}
TrigDefs::includeFailedDecisions
static const unsigned int includeFailedDecisions
Run3 synonym of alsoDeactivateTEs.
Definition TrigEvent/TrigDecisionInterface/TrigDecisionInterface/Conditions.h:40

◆ setFilterPassed()

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

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

100 {
101 execState( ctx ).setFilterPassed( state );
102 }
AthCommonReentrantAlgorithm::setFilterPassed
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Definition AthCommonReentrantAlgorithm.h:100

◆ setTrigInfo()

void TrigEgammaMonitorBaseAlgorithm::setTrigInfo ( const std::string & trigger)
protectedinherited

Set the trigger info parsed from the chain name.

Definition at line 619 of file TrigEgammaMonitorBaseAlgorithm.cxx.

619 {
620
621 /********************************************
622 // Trigger Information struct
623 typedef struct _triginfo
624 {
625 // L1 information
626 bool L1Legacy;
627 std::string L1Threshold; //EM22VHI
628 // HLT information
629 std::string trigger; //Trigger Name
630 std::string signature; //Electron or Photon
631 float etthr; // HLT Et threshold
632 // if trigger is etcut OR idperf, pidname should be default (usually lhloose)
633 std::string pidname; // Offline loose, medium, tight, etc...
634 // extra HLT information
635 bool idperf; // Performance chain
636 bool etcut; // Et cut only chain
637 bool nogsf; // chain without gsf reconstruction
638 bool lrt; // LRT chain
639 bool ion; // Heavy Ion chain
640 std::string isolation;
641 bool isolated;
642 } TrigInfo;
643 *******************************************/
644
645 std::map<std::string, std::string> pidMap = { {"vloose" , "loose" },
646 {"loose" , "loose" },
647 {"medium" , "medium" },
648 {"tight" , "tight" },
649 {"loose1" , "loose" },
650 {"medium1" , "medium" },
651 {"tight1" , "tight" },
652 {"lhvloose" , "lhvloose" },
653 {"lhloose" , "lhloose" },
654 {"lhmedium" , "lhmedium" },
655 {"lhtight" , "lhtight" },
656 {"dnnloose" , "dnnloose" },
657 {"dnnmedium", "dnnmedium"},
658 {"dnntight" , "dnntight" },
659 {"nopid" , "nopid" } };
660
661 std::vector<std::string> isoNames = {"ivarloose","ivarmedium","ivartight","icaloloose","icalomedium","icalotight"};
662
663 bool nogsf = false;
664 bool lrt = false;
665 bool ion = false;
666 bool etcut = false;
667 bool idperf = false;
668 bool isolated = false;
669
670 std::string isolation="";
671 bool l1legacy=true;
672
673 std::string hltinfo=trigger;
674 std::string signature = "";
675 float threshold = 0;
676 // HLT_e/gXX_(pidname/etcut/idperf)_*_L1EMXX to e/gXX_(pidname/etcut/idperf)_*_L1EMXX
677 if(boost::contains(hltinfo,"HLT")) hltinfo.erase(0,4);
678
679
680 std::vector<std::string> parts;
681 boost::split(parts,hltinfo,boost::is_any_of("_"));
682 std::string pidname;
683
684 // e/gXX_(pidname/etcut/idperf)_*_L1EMXX
685 if(boost::contains(parts.at(0),"e")) {
686 signature = "Electron";
687 pidname = m_defaultProbePidElectron;
688 }else if(boost::contains(parts.at(0),"g")) {
689 signature = "Photon";
690 pidname = m_defaultProbePidPhoton;
691 }else {
692 ATH_MSG_ERROR("Cannot set trigger type from name");
693 }
694
695 ATH_MSG_DEBUG(parts.at(1));
696 if(parts.at(1) == "idperf"){
697 ATH_MSG_DEBUG("This is idperf");
698 idperf=true;
699 }
700 else if( parts.at(1)== "etcut"){
701 ATH_MSG_DEBUG("This is etcut");
702 etcut=true;
703 }
704 else { // remap online pidname to offline pidname
705 ATH_MSG_DEBUG("This is nominal");
706 if (pidMap.count(parts.at(1)) != 1) {
707 ATH_MSG_ERROR("Unknown trigger type: " << parts.at(1) << " (" << trigger << ")");
708 }
709 pidname = pidMap.at(parts.at(1));
710 }
711
712
713 // extra information
714 nogsf = boost::contains(trigger,"nogsf");
715 lrt = boost::contains(trigger,"lrt");
716 ion = boost::contains(trigger,"ion");
717
718 for(auto& iso : isoNames){
719 if(boost::contains(trigger, iso)){
720 isolation=iso; isolated=true; break;
721 }
722 }
723
724 // Get the threshold
725 std::string str_thr = parts.at(0);
726 str_thr.erase( 0, 1);
727 threshold = atof(str_thr.c_str());
728
729 // L1EMXX
730 std::string l1seed = getL1Item(trigger);
731 l1legacy = !boost::contains(l1seed, "eEM");
732
733
734 ATH_MSG_DEBUG("=================== Chain Parser =======================");
735 ATH_MSG_DEBUG( "trigger : " << trigger );
736 ATH_MSG_DEBUG( "threshold : " << threshold);
737 ATH_MSG_DEBUG( "Pidname : " << pidname );
738 ATH_MSG_DEBUG( "signature : " << signature);
739 ATH_MSG_DEBUG( "etcut : " << (etcut?"Yes":"No"));
740 ATH_MSG_DEBUG( "idperf : " << (idperf?"Yes":"No"));
741 ATH_MSG_DEBUG( "nogsf : " << (nogsf?"Yes":"No"));
742 ATH_MSG_DEBUG( "lrt : " << (lrt?"Yes":"No"));
743 ATH_MSG_DEBUG( "HeavyIon : " << (ion?"Yes":"No"));
744 ATH_MSG_DEBUG( "Isolation : " << isolation);
745 ATH_MSG_DEBUG( "Isolated : " << (isolated?"Yes":"No"));
746 ATH_MSG_DEBUG( "L1Seed : " << l1seed << " (Is Legacy? " << (l1legacy?"Yes":"No") << ")");
747 ATH_MSG_DEBUG("========================================================");
748
749 TrigInfo info{l1legacy,l1seed,trigger,signature,threshold,pidname,idperf,etcut,nogsf,lrt,ion,isolation,isolated};
750 m_trigInfo[trigger] = info;
751
752}
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
TrigInfo
struct _triginfo TrigInfo
TrigEgammaMonitorBaseAlgorithm::m_defaultProbePidPhoton
Gaudi::Property< std::string > m_defaultProbePidPhoton
default probe pid for photon trigitems that don't have pid in their name
Definition TrigEgammaMonitorBaseAlgorithm.h:122
TrigEgammaMonitorBaseAlgorithm::m_defaultProbePidElectron
Gaudi::Property< std::string > m_defaultProbePidElectron
default probe pid for electron trigitems that don't have pid in their name
Definition TrigEgammaMonitorBaseAlgorithm.h:120
CxxUtils::atof
double atof(std::string_view str)
Converts a string into a double / float.
Definition Control/CxxUtils/Root/StringUtils.cxx:46

◆ setTrigInfoR3()

void TrigEgammaMonitorBaseAlgorithm::setTrigInfoR3 ( const std::string & trigger)
protectedinherited

Definition at line 776 of file TrigEgammaMonitorBaseAlgorithm.cxx.

776 {
777
778 ATH_MSG_DEBUG("Entering function");
779 /********************************************
780 // Trigger Information struct
781 typedef struct _triginfo
782 {
783 // L1 information
784 bool L1Legacy; (done)
785 std::string L1Threshold; //EM22VHI
786 // HLT information
787 std::string trigger; //Trigger Name (done)
788 std::string signature; //Electron or Photon (done)
789 float etthr; // HLT Et threshold (done)
790 // if trigger is etcut OR idperf, pidname should be default (usually lhloose)
791 std::string pidname; // Offline loose, medium, tight, etc...(done)
792 // extra HLT information
793 bool idperf; // Performance chain
794 bool etcut; // Et cut only chain
795 bool nogsf; // chain without gsf reconstruction
796 bool lrt; // LRT chain
797 bool ion; // Heavy Ion chain
798 std::string isolation;
799 bool isolated;
800 } TrigInfo;
801 *******************************************/
802
803 std::map<std::string, std::string> pidMap = { {"vloose" , "loose" },
804 {"loose" , "loose" },
805 {"medium" , "medium" },
806 {"tight" , "tight" },
807 {"loose1" , "loose" },
808 {"medium1" , "medium" },
809 {"tight1" , "tight" },
810 {"lhvloose" , "lhvloose" },
811 {"lhloose" , "lhloose" },
812 {"lhmedium" , "lhmedium" },
813 {"lhtight" , "lhtight" },
814 {"dnnloose" , "dnnloose" },
815 {"dnnmedium", "dnnmedium"},
816 {"dnntight" , "dnntight" },
817 {"nopid" , "nopid" } };
818
819 //Get information about each signature of the trigger
820 //Each signature counts as a leg
821 //HLT_2e17_medium_g22_medium_probe_L12eEM24H
822 //Leg 1 : 2e17_medium
823 //Leg2: g22_medium_probe
824
825 float threshold = 0;
826 std::string signature = "";
827 std::string etthr = "";
828 std::string pidname = "";
829
830
831 auto LegParts = getProbeTriggerLeg(trigger);
832
833 //Get the probe leg
834 if(!LegParts.empty())
835 {
836 //Looping over signatures
837 for( const auto& leg: LegParts)
838 {
839 //Grab the requested signature
840 if (leg.signature != "g") continue;
841
842 //Building the probe trigger name
843 signature = leg.signature;
844 if (signature == "g"){
845 signature = "Photon";
846 }
847 threshold = leg.threshold;
848 //threshold = std::to_string(leg.threshold);
849 pidname = leg.legParts[0];
850 }
851 }
852
853
854 bool l1legacy=true;
855 // L1EMXX
856 std::string l1seed = getL1Item(trigger);
857 l1legacy = !boost::contains(l1seed, "eEM");
858
859
860 std::vector<std::string> isoNames = {"ivarloose","ivarmedium","ivartight","icaloloose","icalomedium","icalotight"};
861
862 bool nogsf = false;
863 bool lrt = false;
864 bool ion = false;
865 bool etcut = false;
866 bool idperf = false;
867 bool isolated = false;
868
869 std::string isolation="";
870
871 // extra information
872 nogsf = boost::contains(trigger,"nogsf");
873 lrt = boost::contains(trigger,"lrt");
874 ion = boost::contains(trigger,"ion");
875
876 for(auto& iso : isoNames){
877 if(boost::contains(trigger, iso)){
878 isolation=iso; isolated=true; break;
879 }
880 }
881
882 std::vector<std::string> parts;
883 boost::split(parts, trigger, boost::is_any_of("_"));
884
885 if(boost::contains(trigger, "idperf")){
886 ATH_MSG_DEBUG("This is idperf");
887 idperf=true;
888 }
889 else if(boost::contains(trigger, "etcut")){
890 ATH_MSG_DEBUG("This is etcut");
891 etcut=true;
892 }
893 else { // remap online pidname to offline pidname
894 //ATH_MSG_DEBUG("Problem: 3");
895 // ATH_MSG_DEBUG("This is nominal");
896 // if (pidMap.count(parts.at(4)) != 4) {
897 // ATH_MSG_DEBUG("Unknown trigger type: " << parts.at(4) << " (" << trigger << ")");
898 // }
899 // pidname = pidMap.at(parts.at(4));
900 }
901
902
903 ATH_MSG_DEBUG("Problem: 5");
904 ATH_MSG_DEBUG("=================== R3 Chain Parser R3 =======================");
905 ATH_MSG_DEBUG( "trigger : " << trigger );
906 ATH_MSG_DEBUG( "threshold : " << threshold);
907 ATH_MSG_DEBUG( "Pidname : " << pidname );
908 ATH_MSG_DEBUG( "signature : " << signature);
909 ATH_MSG_DEBUG( "etcut : " << (etcut?"Yes":"No"));
910 ATH_MSG_DEBUG( "idperf : " << (idperf?"Yes":"No"));
911 ATH_MSG_DEBUG( "nogsf : " << (nogsf?"Yes":"No"));
912 ATH_MSG_DEBUG( "lrt : " << (lrt?"Yes":"No"));
913 ATH_MSG_DEBUG( "HeavyIon : " << (ion?"Yes":"No"));
914 ATH_MSG_DEBUG( "Isolation : " << isolation);
915 ATH_MSG_DEBUG( "Isolated : " << (isolated?"Yes":"No"));
916 ATH_MSG_DEBUG( "L1Seed : " << l1seed << " (Is Legacy? " << (l1legacy?"Yes":"No") << ")");
917 ATH_MSG_DEBUG("========================================================");
918
919 TrigInfo info{l1legacy,l1seed,trigger,signature,threshold,pidname,idperf,etcut,nogsf,lrt,ion,isolation,isolated};
920 m_trigInfoR3[trigger] = info;
921
922}
TrigEgammaMonitorBaseAlgorithm::getProbeTriggerLeg
std::vector< ChainNameParser::LegInfo > getProbeTriggerLeg(const std::string &triggerName) const
Definition TrigEgammaMonitorBaseAlgorithm.cxx:755
compute_lumi.leg
leg
Definition compute_lumi.py:95

◆ sysExecute()

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

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

75{
76 return BaseAlg::sysExecute (ctx);
77}

◆ sysInitialize()

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

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

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

◆ tdt()

const ToolHandle< Trig::TrigDecisionTool > & TrigEgammaMonitorBaseAlgorithm::tdt ( ) const
inlineprotectedinherited

Get the TDT.

Definition at line 145 of file TrigEgammaMonitorBaseAlgorithm.h.

145{return m_trigdec;};

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

208 {
209
210
211 // If no triggers were given, return true.
212 if (vTrigNames.empty()) return true;
213
214
215 // Trigger: Check if this Algorithm is being run as an Express Stream job.
216 // Events are entering the express stream are chosen randomly, and by chain,
217 // Hence an additional check should be aplied to see if the chain(s)
218 // monitored here are responsible for the event being selected for
219 // the express stream.
220
221 const auto group = m_trigDecTool->getChainGroup(vTrigNames);
222 if (m_enforceExpressTriggers){
223 const auto passedBits = m_trigDecTool->isPassedBits(group);
224 bool expressPass = passedBits & TrigDefs::Express_passed; //bitwise AND
225 if(!expressPass) {
226 return false;
227 }
228 }
229
230 // monitor the event if any of the chains in the chain group passes the event.
231 return group->isPassed();
232
233}
AthMonitorAlgorithm::m_enforceExpressTriggers
Gaudi::Property< bool > m_enforceExpressTriggers
Definition AthMonitorAlgorithm.h:377
CaloLCW_tf.group
group
Definition CaloLCW_tf.py:28

◆ 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

◆ m_accept

asg::AcceptInfo TrigEgammaMonitorBaseAlgorithm::m_accept
protectedinherited

Definition at line 133 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 356 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 358 of file AthMonitorAlgorithm.h.

358{this,"DataType","userDefined"};

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 365 of file AthMonitorAlgorithm.h.

365{this,"DefaultLBDuration",60.};

◆ m_defaultProbePidElectron

Gaudi::Property<std::string> TrigEgammaMonitorBaseAlgorithm::m_defaultProbePidElectron {this, "DefaultProbeSelectionElectron", "lhloose"}
protectedinherited

default probe pid for electron trigitems that don't have pid in their name

Definition at line 120 of file TrigEgammaMonitorBaseAlgorithm.h.

120{this, "DefaultProbeSelectionElectron", "lhloose"};

◆ m_defaultProbePidPhoton

Gaudi::Property<std::string> TrigEgammaMonitorBaseAlgorithm::m_defaultProbePidPhoton {this, "DefaultProbeSelectionPhoton", "loose"}
protectedinherited

default probe pid for photon trigitems that don't have pid in their name

Definition at line 122 of file TrigEgammaMonitorBaseAlgorithm.h.

122{this, "DefaultProbeSelectionPhoton", "loose"};

◆ m_detailedHists

Gaudi::Property<bool> TrigEgammaMonitorBaseAlgorithm::m_detailedHists {this, "DetailedHistograms", false}
protectedinherited

Include more detailed histograms.

Definition at line 130 of file TrigEgammaMonitorBaseAlgorithm.h.

130{this, "DetailedHistograms", false};

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 366 of file AthMonitorAlgorithm.h.

366{this,"DetailLevel",0};

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

Gaudi::Property<std::vector<std::string> > TrigEgammaMonitorBaseAlgorithm::m_dnnname {this, "DNNResultNames", {}, }
protectedinherited

dnn names

Definition at line 128 of file TrigEgammaMonitorBaseAlgorithm.h.

128{this, "DNNResultNames", {}, };

◆ m_doEffwithDNN

Gaudi::Property<bool> TrigEgammaMonitorBaseAlgorithm::m_doEffwithDNN {this, "ComputeEffDNN", false}
protectedinherited

Definition at line 115 of file TrigEgammaMonitorBaseAlgorithm.h.

115{this, "ComputeEffDNN", false};

◆ m_doEffwithLH

Gaudi::Property<bool> TrigEgammaMonitorBaseAlgorithm::m_doEffwithLH {this, "ComputeEffLH", false}
protectedinherited

Definition at line 114 of file TrigEgammaMonitorBaseAlgorithm.h.

114{this, "ComputeEffLH", false};

◆ m_doEmulation

Gaudi::Property<bool> TrigEgammaMonitorBaseAlgorithm::m_doEmulation {this, "DoEmulation", false }
protectedinherited

Do emulation.

Definition at line 112 of file TrigEgammaMonitorBaseAlgorithm.h.

112{this, "DoEmulation", false };

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 346 of file AthMonitorAlgorithm.h.

346{this,"FilterTools",{}};

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 374 of file AthMonitorAlgorithm.h.

◆ m_electronDNNTool

ToolHandleArray<IAsgElectronLikelihoodTool> TrigEgammaMonitorBaseAlgorithm::m_electronDNNTool { this, "ElectronDNNSelectorTool", {},"DNN tools" }
protectedinherited

Offline DNN Selectors.

Definition at line 106 of file TrigEgammaMonitorBaseAlgorithm.h.

106{ this, "ElectronDNNSelectorTool", {},"DNN tools" };

◆ m_electronIsEMTool

ToolHandleArray<IAsgElectronIsEMSelector> TrigEgammaMonitorBaseAlgorithm::m_electronIsEMTool {this,"ElectronIsEMSelector",{}}
protectedinherited

Offline isEM Selectors.

Definition at line 102 of file TrigEgammaMonitorBaseAlgorithm.h.

102{this,"ElectronIsEMSelector",{}};

◆ m_electronLHTool

ToolHandleArray<IAsgElectronLikelihoodTool> TrigEgammaMonitorBaseAlgorithm::m_electronLHTool {this,"ElectronLikelihoodTool",{}}
protectedinherited

Offline LH Selectors.

Definition at line 104 of file TrigEgammaMonitorBaseAlgorithm.h.

104{this,"ElectronLikelihoodTool",{}};

◆ m_emulatorTool

ToolHandle<Trig::TrigEgammaEmulationToolMT> TrigEgammaMonitorBaseAlgorithm::m_emulatorTool
protectedinherited

Definition at line 100 of file TrigEgammaMonitorBaseAlgorithm.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 377 of file AthMonitorAlgorithm.h.

377 {this,
378 "EnforceExpressTriggers", false,
379 "Requires that matched triggers made the event enter the express stream"};

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 355 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 357 of file AthMonitorAlgorithm.h.

357{this,"Environment","user"};

◆ m_EventInfoKey

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

Key for retrieving EventInfo from StoreGate.

Definition at line 367 of file AthMonitorAlgorithm.h.

367{this,"EventInfoKey","EventInfo"};

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

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

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_fileKey

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

Internal Athena name for file.

Definition at line 363 of file AthMonitorAlgorithm.h.

363{this,"FileKey",""};

◆ m_isemname

Gaudi::Property<std::vector<std::string> > TrigEgammaMonitorBaseAlgorithm::m_isemname {this, "isEMResultNames", {} }
protectedinherited

isem names

Definition at line 124 of file TrigEgammaMonitorBaseAlgorithm.h.

124{this, "isEMResultNames", {} };

◆ m_lbDurationDataKey

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

Definition at line 350 of file AthMonitorAlgorithm.h.

351{this,"LBDurationCondDataKey","LBDurationCondData","SG Key of LBDurationCondData object"};

◆ m_lhname

Gaudi::Property<std::vector<std::string> > TrigEgammaMonitorBaseAlgorithm::m_lhname {this, "LHResultNames", {} }
protectedinherited

lh names

Definition at line 126 of file TrigEgammaMonitorBaseAlgorithm.h.

126{this, "LHResultNames", {} };

◆ m_lumiDataKey

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

Definition at line 348 of file AthMonitorAlgorithm.h.

349{this,"LuminosityCondDataKey","LuminosityCondData","SG Key of LuminosityCondData object"};

◆ m_matchTool

ToolHandle<TrigEgammaMatchingToolMT> TrigEgammaMonitorBaseAlgorithm::m_matchTool
protectedinherited

Definition at line 96 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_matchTool_R3

ToolHandle<Trig::IMatchingTool> TrigEgammaMonitorBaseAlgorithm::m_matchTool_R3
protectedinherited

Definition at line 97 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 371 of file AthMonitorAlgorithm.h.

◆ m_photonIsEMTool

ToolHandleArray<IAsgPhotonIsEMSelector> TrigEgammaMonitorBaseAlgorithm::m_photonIsEMTool {this,"PhotonIsEMSelector",{}}
protectedinherited

Offline isEM Photon Selectors.

Definition at line 108 of file TrigEgammaMonitorBaseAlgorithm.h.

108{this,"PhotonIsEMSelector",{}};

◆ m_toolLookupMap

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

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

341{this,"GMTools",{}};

◆ m_tp

Gaudi::Property<bool> TrigEgammaMonitorBaseAlgorithm::m_tp {this, "TPTrigger", false }
protectedinherited

TP Trigger Analysis.

Definition at line 118 of file TrigEgammaMonitorBaseAlgorithm.h.

118{this, "TPTrigger", false };

◆ m_trigdec

ToolHandle<Trig::TrigDecisionTool> TrigEgammaMonitorBaseAlgorithm::m_trigdec
privateinherited

Trigger decision tool.

Definition at line 87 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_trigDecTool

PublicToolHandle<Trig::TrigDecisionTool> AthMonitorAlgorithm::m_trigDecTool
protectedinherited

Tool to tell whether a specific trigger is passed.

Definition at line 345 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 360 of file AthMonitorAlgorithm.h.

360{this,"TriggerChain",""};

◆ m_trigInfo

std::map<std::string,TrigInfo> TrigEgammaMonitorBaseAlgorithm::m_trigInfo
privateinherited

creates map of trigger name and TrigInfo struct

Definition at line 89 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_trigInfoR3

std::map<std::string,TrigInfo> TrigEgammaMonitorBaseAlgorithm::m_trigInfoR3
privateinherited

Definition at line 90 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 352 of file AthMonitorAlgorithm.h.

353{this,"TrigLiveFractionCondDataKey","TrigLiveFractionCondData", "SG Key of TrigLiveFractionCondData object"};

◆ m_useLumi

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

Allows use of various luminosity functions.

Definition at line 364 of file AthMonitorAlgorithm.h.

364{this,"EnableLumi",false};

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.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 361 of file AthMonitorAlgorithm.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.16.1