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 (std::string_view groupName, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &&variables) const
 Fills a vector of variables to a group by name.
void fill (std::string_view groupName, const std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &variables) const
 Fills a vector of variables to a group by name.
template<typename S, typename... T>
requires std::convertible_to<S, std::string_view>
void fill (S &&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 (std::string_view 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 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
 Get filter decision:
virtual void setFilterPassed (bool state, const EventContext &ctx) const
 Set filter decision:
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 EventContext &ctx, 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, CxxUtils::TransparentStringHash, std::equal_to<> > 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 379 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 203 of file AthMonitorAlgorithm.h.

203 {
204 userDefined = 0,
205 monteCarlo,
206 collisions,
207 cosmics,
208 heavyIonCollisions,
209 };
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 184 of file AthMonitorAlgorithm.h.

184 {
185 user = 0,
186 online,
187 tier0,
188 tier0Raw,
189 tier0ESD,
190 AOD,
191 altprod,
192 };

Constructor & Destructor Documentation

◆ TrigEgammaMonitorAnalysisAlgorithm()

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

Definition at line 10 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ ~TrigEgammaMonitorAnalysisAlgorithm()

TrigEgammaMonitorAnalysisAlgorithm::~TrigEgammaMonitorAnalysisAlgorithm ( )
overridevirtual

Definition at line 15 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

16{}

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 51 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ ApplyPhotonPid()

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

Get offline electron decision.

Definition at line 98 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

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

233{ return m_dataType; }
AthMonitorAlgorithm::m_dataType
AthMonitorAlgorithm::DataType_t m_dataType
Instance of the DataType_t enum.
Definition AthMonitorAlgorithm.h:365

◆ 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:46
tolower
void tolower(std::string &s)
Definition AthenaSummarySvc.cxx:100

◆ 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 298 of file TrigEgammaMonitorBaseAlgorithm.cxx.

298 {
299 float deta = fabs(eta1 - eta2);
300 float dphi = fabs(phi1 - phi2) < TMath::Pi() ? fabs(phi1 - phi2) : 2*TMath:: \
301 Pi() - fabs(phi1 - phi2);
302 return sqrt(deta*deta + dphi*dphi);
303}
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 217 of file AthMonitorAlgorithm.h.

217{ return m_environment; }
AthMonitorAlgorithm::m_environment
AthMonitorAlgorithm::Environment_t m_environment
Instance of the Environment_t enum.
Definition AthMonitorAlgorithm.h:364

◆ 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:370
AthMonitorAlgorithm::m_trigDecTool
PublicToolHandle< Trig::TrigDecisionTool > m_trigDecTool
Tool to tell whether a specific trigger is passed.
Definition AthMonitorAlgorithm.h:354
AthMonitorAlgorithm::m_DQFilterTools
ToolHandleArray< IDQFilterTool > m_DQFilterTools
Array of Data Quality filter tools.
Definition AthMonitorAlgorithm.h:355

◆ 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 & AthCommonAlgorithm< 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 89 of file AthCommonAlgorithm.cxx.

54{
55 // If we didn't find any symlinks to add, just return the collection
56 // from the base class. Otherwise, return the extended collection.
57 if (!m_extendedExtraObjects.empty()) {
58 return m_extendedExtraObjects;
59 }
60 return BaseAlg::extraOutputDeps();
61}
AthCommonAlgorithm
Common base class for algorithms.
Definition AthCommonAlgorithm.h:38

◆ 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 443 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

445{
446
447 const std::string trigger = info.trigger;
448
449 unsigned int condition=TrigDefs::Physics;
450
451 // Offline
452 std::vector<const xAOD::Egamma*> eg_vec;
453 std::vector<const xAOD::Electron*> el_vec;
454 for( auto pairObj: pairObjs )
455 {
456 eg_vec.push_back(pairObj.first);
457 if( xAOD::EgammaHelpers::isElectron(pairObj.first)){
458 const xAOD::Electron* elOff = static_cast<const xAOD::Electron*> (pairObj.first);
459 el_vec.push_back(elOff);
460 }
461 }
462
463 // Offline
464 fillShowerShapes( trigger, eg_vec, false );
465 fillTracking( ctx, trigger, el_vec, false );
466
467 // L1Calo
468 {
469 // Fill L1 features
470 auto initRois = tdt()->features<TrigRoiDescriptorCollection>(trigger,condition,"",TrigDefs::allFeaturesOfType,"initialRoI");
471
472 if (info.L1Legacy){
473 std::vector<const xAOD::EmTauRoI*> l1_vec;
474 for( auto &initRoi: initRois ){
475 if( !initRoi.link.isValid() ) continue;
476 const auto *feat = match()->getL1Feature( ctx, initRoi.source );
477 if(feat) l1_vec.push_back(feat);
478 }
479 fillL1Calo( trigger, l1_vec );
480 }else{
481 std::vector<const xAOD::eFexEMRoI*> l1_vec;
482 for( auto &initRoi: initRois ){
483 if( !initRoi.link.isValid() ) continue;
484 const auto *feat = match()->getL1eEMFeature( ctx, initRoi.source );
485 if(feat) l1_vec.push_back(feat);
486 }
487 fillL1eEM( trigger, l1_vec );
488 }
489
490 }
491
492
493 // L2Calo
494 {
495 std::vector<const xAOD::TrigEMCluster*> emCluster_vec;
496 auto vec = tdt()->features<xAOD::TrigEMClusterContainer>(trigger,condition ,match()->key("FastCalo") );
497 for(auto &featLinkInfo : vec ){
498 if(! featLinkInfo.isValid() ) continue;
499 const auto *feat = *(featLinkInfo.link);
500 if(!feat) continue;
501 emCluster_vec.push_back(feat);
502 }
503 fillL2Calo( trigger, emCluster_vec );
504 }
505 // EFCalo
506 {
507 std::string key = match()->key("PrecisionCalo_Electron");
508 if(info.signature == "Photon" or info.signature == "g") key = match()->key("PrecisionCalo_Photon");
509 if(info.lrt) key = match()->key("PrecisionCalo_LRT");
510 if(info.ion) key = match()->key("PrecisionCalo_HI");
511
512 std::vector<const xAOD::CaloCluster* > clus_vec;
513 auto vec = tdt()->features<xAOD::CaloClusterContainer>(trigger,condition,key);
514 for(auto &featLinkInfo : vec ){
515 if(! featLinkInfo.isValid() ) continue;
516 const auto *feat = *(featLinkInfo.link);
517 if(!feat) continue;
518 clus_vec.push_back(feat);
519 }
520 fillEFCalo( trigger, clus_vec );
521 }
522
523 if ( info.signature == "Electron" or info.signature == "e" ){
524
525 // L2 Electron
526 {
527 std::string key = match()->key("FastElectrons");
528 if(info.lrt) key = match()->key("FastElectrons_LRT");
529
530 std::vector<const xAOD::TrigElectron*> el_vec;
531 // Get only passed objects
532 auto vec = tdt()->features<xAOD::TrigElectronContainer>(trigger,condition,key );
533 for( auto &featLinkInfo : vec ){
534 if(! featLinkInfo.isValid() ) continue;
535 const auto *feat = *(featLinkInfo.link);
536 if(!feat) continue;
537 el_vec.push_back(feat);
538 }
539 fillL2Electron( trigger, el_vec );
540 }
541 // HLT Electron
542 {
543 std::string key = match()->key("Electrons_GSF");
544 if(info.nogsf) key = match()->key("Electrons");
545 if(info.lrt) key = match()->key("Electrons_LRT");
546
547 std::vector<const xAOD::Electron*> el_vec;
548 std::vector<const xAOD::Egamma*> eg_vec;
549 auto vec = tdt()->features<xAOD::ElectronContainer>(trigger, condition ,key );
550 for( auto &featLinkInfo : vec ){
551 if(! featLinkInfo.isValid() ) continue;
552 const auto *feat = *(featLinkInfo.link);
553 if(!feat) continue;
554 el_vec.push_back(feat);
555 eg_vec.push_back(feat);
556 }
557 fillShowerShapes( trigger, eg_vec, true );
558 fillTracking( ctx, trigger, el_vec, true );
559 }
560 }else if ( info.signature == "Photon" or info.signature == "g"){
561 // Fast Photon
562 {
563 std::string key = match()->key("FastPhotons");
564 std::vector<const xAOD::TrigPhoton*> ph_vec;
565 // Get only passed objects
566 auto vec = tdt()->features<xAOD::TrigPhotonContainer>(trigger,condition,key );
567 for( auto &featLinkInfo : vec ){
568 if(! featLinkInfo.isValid() ) continue;
569 const auto *feat = *(featLinkInfo.link);
570 if(!feat) continue;
571 ph_vec.push_back(feat);
572 }
573 fillL2Photon( trigger, ph_vec );
574 }
575
576 // HLT Photon
577 {
578 std::vector<const xAOD::Egamma*> ph_vec;
579 auto vec = tdt()->features<xAOD::PhotonContainer>(trigger,condition ,match()->key("Photons") );
580 for( auto &featLinkInfo : vec ){
581 if(! featLinkInfo.isValid() ) continue;
582 const auto *feat = *(featLinkInfo.link);
583 if(!feat) continue;
584 ph_vec.push_back(feat);
585 }
586 fillShowerShapes( trigger, ph_vec, true );
587 }
588 }else{
589 ATH_MSG_INFO( "Chain type not specified" );
590 }
591
592}
ATH_MSG_INFO
#define ATH_MSG_INFO(x,...)
Definition AthMsgStreamMacros.h:45
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:858
TrigEgammaMonitorAnalysisAlgorithm::fillEFCalo
void fillEFCalo(const std::string &trigger, const std::vector< const xAOD::CaloCluster * > &clus_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:733
TrigEgammaMonitorAnalysisAlgorithm::fillShowerShapes
void fillShowerShapes(const std::string &trigger, const std::vector< const xAOD::Egamma * > &eg_vec, bool online) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:788
TrigEgammaMonitorAnalysisAlgorithm::fillL2Calo
void fillL2Calo(const std::string &trigger, const std::vector< const xAOD::TrigEMCluster * > &emCluster_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:657
TrigEgammaMonitorAnalysisAlgorithm::fillL1eEM
void fillL1eEM(const std::string &trigger, const std::vector< const xAOD::eFexEMRoI * > &l1_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:626
TrigEgammaMonitorAnalysisAlgorithm::fillL2Photon
void fillL2Photon(const std::string &trigger, const std::vector< const xAOD::TrigPhoton * > &eg_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:708
TrigEgammaMonitorAnalysisAlgorithm::fillL2Electron
void fillL2Electron(const std::string &trigger, const std::vector< const xAOD::TrigElectron * > &el_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:684
TrigEgammaMonitorAnalysisAlgorithm::fillL1Calo
void fillL1Calo(const std::string &trigger, const std::vector< const xAOD::EmTauRoI * > &l1_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:597
TrigEgammaMonitorBaseAlgorithm::match
const ToolHandle< TrigEgammaMatchingToolMT > & match() const
Get the e/g match tool.
Definition TrigEgammaMonitorBaseAlgorithm.h:147
TrigEgammaMonitorBaseAlgorithm::tdt
const ToolHandle< Trig::TrigDecisionTool > & tdt() const
Get the TDT.
Definition TrigEgammaMonitorBaseAlgorithm.h:144
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 733 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

734{
735
736 const auto & monGroup = getGroup( trigger + "_Distributions_EFCalo" );
737
738
739 std::vector<float> energyBE0_vec, energyBE1_vec, energyBE2_vec, energyBE3_vec,
740 energy_vec, et_vec, eta_vec, phi_vec, eta_calo_vec, phi_calo_vec, highet_vec;
741
742
743
744 auto energyBE0_col = Monitored::Collection("energyBE0", energyBE0_vec);
745 auto energyBE1_col = Monitored::Collection("energyBE1", energyBE1_vec);
746 auto energyBE2_col = Monitored::Collection("energyBE2", energyBE2_vec);
747 auto energyBE3_col = Monitored::Collection("energyBE3", energyBE3_vec);
748 auto energy_col = Monitored::Collection("energy" , energy_vec );
749 auto et_col = Monitored::Collection("et" , et_vec );
750 auto highet_col = Monitored::Collection("highet" , highet_vec );
751 auto eta_col = Monitored::Collection("eta" , eta_vec );
752 auto phi_col = Monitored::Collection("phi" , phi_vec );
753 auto eta_calo_col = Monitored::Collection("eta_calo" , eta_calo_vec );
754 auto phi_calo_col = Monitored::Collection("phi_calo" , phi_calo_vec );
755
756 for ( const auto *clus : clus_vec )
757 {
758 double tmpeta = -999.;
759 if(!clus->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta))
760 tmpeta=-999.;
761 double tmpphi = -999.;
762 if(!clus->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi))
763 tmpphi=-999.;
764
765 energyBE0_vec.push_back( clus->energyBE(0)/Gaudi::Units::GeV );
766 energyBE1_vec.push_back( clus->energyBE(1)/Gaudi::Units::GeV );
767 energyBE2_vec.push_back( clus->energyBE(2)/Gaudi::Units::GeV );
768 energyBE3_vec.push_back( clus->energyBE(3)/Gaudi::Units::GeV );
769 energy_vec.push_back( clus->e()/Gaudi::Units::GeV );
770 et_vec.push_back( clus->et()/Gaudi::Units::GeV );
771 highet_vec.push_back( clus->et()/Gaudi::Units::GeV );
772 eta_vec.push_back( clus->eta() );
773 phi_vec.push_back( clus->phi() );
774 eta_calo_vec.push_back( tmpeta );
775 phi_calo_vec.push_back( tmpphi );
776
777 }
778
779
780 fill( monGroup, energyBE0_col, energyBE1_col, energyBE2_col, energyBE3_col,
781 energy_col, et_col, eta_col, phi_col, eta_calo_col, phi_calo_col, highet_col);
782}
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(std::string_view 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 44 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

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

75{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 1079 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

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

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

◆ fillL1Calo()

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

Definition at line 597 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ 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 1051 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ 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 1021 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillL1eEM()

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

Definition at line 626 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillL2Calo()

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

Definition at line 657 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ 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 1769 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

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

◆ fillL2Photon()

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

Definition at line 708 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillLabel()

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

Definition at line 32 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

35{
36 auto mon = Monitored::Scalar<std::string>( histname, label );
37 fill( groupHandle, mon );
38}
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 964 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

967{
968
969 std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pair_l1_vec;
970 std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_eg_vec;
971 const std::string trigger = info.trigger;
972
973 SG::Decorator<bool> pidnameDec("is"+info.pidname);
974 for( auto pairObj : pairObjs ){
975
976 const xAOD::Egamma* eg = pairObj.first;
977 const auto *feat = pairObj.second;
978
979 if (feat){
980
981 //
982 // Get only off and l1 where the offline object passed by the offline pid selector
983 //
984 const auto *l1 = match()->getL1Feature( ctx, feat );
985 if(eg->type()==xAOD::Type::Electron){
986 const xAOD::Electron* el = static_cast<const xAOD::Electron*>(eg);
987 float et = getEt(el)/Gaudi::Units::GeV;
988 if( et < info.etthr-5.0) continue;
989 if(!pidnameDec(*eg)) continue;
990 pair_eg_vec.emplace_back(el,feat);
991 if(l1) pair_l1_vec.emplace_back(eg,l1 );
992 }
993 else if(eg->type()==xAOD::Type::Photon){
994 float et = getCluster_et(eg)/Gaudi::Units::GeV;
995 if( et < info.etthr-5.0) continue;
996 pair_eg_vec.emplace_back(eg,feat);
997 if(l1) pair_l1_vec.emplace_back(eg,l1 );
998 }
999 }
1000
1001 }
1002
1003 // Fill L1Calo for all level 1 objects found
1004 fillL1CaloResolution( trigger, pair_l1_vec );
1005 fillL1CaloAbsResolution( trigger, pair_l1_vec );
1006 fillL2CaloResolution( trigger, pair_eg_vec );
1007
1008 // Fill HLT electron for all onl objects found
1009 if ( info.signature=="Electron" or info.signature == "e"){
1010 fillHLTElectronResolution( ctx, trigger, pair_eg_vec, info );
1011 }
1012 else if ( info.signature=="Photon" or info.signature == "g"){
1013 fillHLTPhotonResolution( ctx, trigger, pair_eg_vec, info );
1014 }
1015
1016}
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:1459
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:1079
TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloAbsResolution
void fillL1CaloAbsResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1051
TrigEgammaMonitorAnalysisAlgorithm::fillL2CaloResolution
void fillL2CaloResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1769
TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloResolution
void fillL1CaloResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1021
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 788 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ 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 858 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ filterPassed()

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

Get filter decision:

Definition at line 93 of file AthCommonAlgorithm.h.

93 {
94 return execState( ctx ).filterPassed();
95 }
AthCommonAlgorithm::filterPassed
virtual bool filterPassed(const EventContext &ctx) const
Get filter decision:
Definition AthCommonAlgorithm.h:93

◆ getD0sig()

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

Definition at line 388 of file TrigEgammaMonitorBaseAlgorithm.cxx.

388 {
389 const xAOD::TrackParticle* t = eg->trackParticle();
390 float d0sigma=0.;
391 if (t)
392 {
393 float vard0 = t->definingParametersCovMatrix()(0,0);
394 if (vard0 > 0) {
395 d0sigma=sqrtf(vard0);
396 }
397 else return -99.;
398
399 if (fabs(d0sigma) < 1e-6) return -99.;
400 return t->d0()/d0sigma;
401 }
402 else return -99.;
403}
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 338 of file TrigEgammaMonitorBaseAlgorithm.cxx.

338 {
339 if(eg){
340 float emax2=0.;
341 eg->showerShapeValue(emax2, xAOD::EgammaParameters::e2tsts1);
342 float emax=0.;
343 eg->showerShapeValue(emax, xAOD::EgammaParameters::emaxs1);
344 float den = emax+emax2;
345
346 if (fabs(den) < 1e-6) return -99.;
347
348 float val = (emax-emax2)/(den);
349 return val;
350 }
351 else return -99.;
352}
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 454 of file TrigEgammaMonitorBaseAlgorithm.cxx.

454 {
455 if(eg && (eg->caloCluster())){
456 const xAOD::CaloCluster* cluster = eg->caloCluster();
457 float ebe0 = cluster->energyBE(0);
458 float ebe1 = cluster->energyBE(1);
459 float ebe2 = cluster->energyBE(2);
460 float ebe3 = cluster->energyBE(3);
461 float eacc = ebe1+ebe2+ebe3;
462 if(eacc==0.) return 0.;
463 return (ebe0/eacc);
464 }
465 else return 0.;
466}
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 442 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE0()

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

Definition at line 406 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE1()

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

Definition at line 415 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE2()

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

Definition at line 424 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE3()

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

Definition at line 433 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEt()

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

Definition at line 317 of file TrigEgammaMonitorBaseAlgorithm.cxx.

317 {
318 if(eg && (eg->caloCluster()) && (eg->trackParticle())){
319 const xAOD::TrackParticle *trk=eg->trackParticle();
320 const xAOD::CaloCluster *clus=eg->caloCluster();
321 float eta = fabs(trk->eta());
322 return clus->e()/cosh(eta);
323 }
324 else return -99.;
325}
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 308 of file TrigEgammaMonitorBaseAlgorithm.cxx.

308 {
309 if(eg && (eg->caloCluster())){
310 const xAOD::CaloCluster* cluster = eg->caloCluster();
311 return fabs(cluster->etaBE(2));
312 }
313 else return -99.;
314}
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 328 of file TrigEgammaMonitorBaseAlgorithm.cxx.

328 {
329 if(eg && (eg->caloCluster())){
330 const xAOD::CaloCluster* cluster = eg->caloCluster();
331 float eta2 = fabs(cluster->etaBE(2));
332 return cluster->e()/cosh(eta2);
333 }
334 else return -99.;
335}
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:376

◆ getGroup()

const ToolHandle< GenericMonitoringTool > & AthMonitorAlgorithm::getGroup ( std::string_view 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 (idx != m_toolLookupMap.end()) [[likely]] {
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:48
AthMonitorAlgorithm::m_dummy
const ToolHandle< GenericMonitoringTool > m_dummy
Definition AthMonitorAlgorithm.h:383
AthMonitorAlgorithm::m_toolLookupMap
std::unordered_map< std::string, size_t, CxxUtils::TransparentStringHash, std::equal_to<> > m_toolLookupMap
Definition AthMonitorAlgorithm.h:381
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition AthMonitorAlgorithm.h:350
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition LArNewCalib_DelayDump_OFC_Cali.py:69
likely
#define likely(x)
Definition pythonic_coracool.cxx:8

◆ getL1Item()

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

Creates static map to return L1 item from trigger name.

Definition at line 925 of file TrigEgammaMonitorBaseAlgorithm.cxx.

925 {
926 const auto pos = trigger.rfind('_');
927 return pos == std::string::npos ? trigger : trigger.substr(pos + 1);
928}

◆ 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 756 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getSigmaD0()

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

Definition at line 372 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ 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 609 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getTrigInfoMap()

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

Helper methods.

Get the trig info map

Definition at line 137 of file TrigEgammaMonitorBaseAlgorithm.h.

137{ return m_trigInfo; }

◆ getTrigInfoMapR3()

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

Definition at line 138 of file TrigEgammaMonitorBaseAlgorithm.h.

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

◆ getTrigInfoR3()

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

Definition at line 613 of file TrigEgammaMonitorBaseAlgorithm.cxx.

613 {
614 return m_trigInfoR3.at(trigger);
615}

◆ initialize()

StatusCode TrigEgammaMonitorAnalysisAlgorithm::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from TrigEgammaMonitorBaseAlgorithm.

Reimplemented in TrigEgammaMonitorElectronAlgorithm, TrigEgammaMonitorPhotonAlgorithm, TrigEgammaMonitorTagAndProbeAlgorithm, and TrigEgammaMonitorTagAndProbeAlgorithmZeeg.

Definition at line 19 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

20{
21 ATH_MSG_INFO("TrigEgammaMonitorAnalysisAlgorithm::initialize()...");
22 ATH_CHECK(TrigEgammaMonitorBaseAlgorithm::initialize());
23
24 return StatusCode::SUCCESS;
25}
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:28

◆ 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()

virtual bool AthCommonAlgorithm< Gaudi::Algorithm >::isClonable ( ) const
inlineoverridevirtualinherited

Specify if the algorithm is clonable.

Only relevant for non-reentrant algorithms. Actual number of clones needs to be set via the "Cardinality" property.

Reimplemented in AFP_DigiTop, AlgB, AlgT, BCM_Digitization, CscDigitBuilder, CscDigitToCscRDO, G4AtlasAlg, G4RunAlg, HGTD_Digitization, HiveAlgBase, InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ISF::SimKernelMT, ITk::StripDigitization, ITkPixelCablingAlg, ITkStripCablingAlg, LArHitEMapMaker, LArTTL1Maker, LUCID_DigiTop, LVL1::L1TopoSimulation, MergeCalibHits, MergeGenericMuonSimHitColl, MergeHijingPars, MergeMcEventCollection, MergeTrackRecordCollection, MergeTruthJets, MergeTruthParticles, MuonDigitizer, PileUpMTAlg, PixelDigitization, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_Digitization, 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, SGInputLoader, Simulation::BeamEffectsAlg, TileHitVecToCnt, TileMuonFitter, TilePulseForTileMuonReceiver, TileRawChannelMaker, TRTDigitization, and ZDC_DigiTop.

Definition at line 68 of file AthCommonAlgorithm.h.

68 {
69 return true;
70 }

◆ isHLTTruncated()

bool TrigEgammaMonitorBaseAlgorithm::isHLTTruncated ( ) const
protectedinherited

Definition at line 931 of file TrigEgammaMonitorBaseAlgorithm.cxx.

931 {
932 return m_trigdec->ExperimentalAndExpertMethods().isHLTTruncated();
933}
TrigEgammaMonitorBaseAlgorithm::m_trigdec
ToolHandle< Trig::TrigDecisionTool > m_trigdec
Trigger decision tool.
Definition TrigEgammaMonitorBaseAlgorithm.h:86

◆ isIsolated()

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

Check if electron fulfils isolation criteria.

Definition at line 118 of file TrigEgammaMonitorBaseAlgorithm.cxx.

118 {
119 ATH_MSG_DEBUG("Apply Isolation " << isolation);
120 float ptcone20=0;
121 bool isoStat=eg->isolationValue(ptcone20, xAOD::Iso::ptcone20);
122 if (!isoStat) {
123 ATH_MSG_DEBUG("Electron doesn't provide isolation for ptcone20");
124 return false;
125 }
126 if (!(fabs(eg->pt()) > 0)) {
127 ATH_MSG_DEBUG("Electron pt is zero, can't calculate relative isolation");
128 return false;
129 }
130 ATH_MSG_DEBUG("ptcone20 " << ptcone20);
131 float ptcone20_rel = ptcone20/eg->pt();
132 ATH_MSG_DEBUG("Relative isolation value " << ptcone20_rel);
133 if (isolation == "loose"){
134 if (ptcone20_rel > 0.1) {
135 ATH_MSG_DEBUG("Probe failing isolation");
136 return false;
137 } else {
138 ATH_MSG_DEBUG("Probe passing isolation");
139 return true;
140 }
141 }
142 else {
143 ATH_MSG_DEBUG("No valid working point defined for " << isolation << " continue without isolation");
144 }
145 return false;
146}
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 150 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ match()

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

Get the e/g match tool.

Definition at line 147 of file TrigEgammaMonitorBaseAlgorithm.h.

147{return m_matchTool;}
TrigEgammaMonitorBaseAlgorithm::m_matchTool
ToolHandle< TrigEgammaMatchingToolMT > m_matchTool
Definition TrigEgammaMonitorBaseAlgorithm.h:95

◆ matchR3()

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

Definition at line 148 of file TrigEgammaMonitorBaseAlgorithm.h.

148{return m_matchTool_R3;}
TrigEgammaMonitorBaseAlgorithm::m_matchTool_R3
ToolHandle< Trig::IMatchingTool > m_matchTool_R3
Definition TrigEgammaMonitorBaseAlgorithm.h:96

◆ 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 355 of file TrigEgammaMonitorBaseAlgorithm.cxx.

355 {
356 if(eg && eg->trackParticle()){
357 uint8_t trtHits = 0;
358 eg->trackParticleSummaryValue(trtHits,xAOD::numberOfTRTHits);
359 uint8_t trtHTHits = 0;
360 eg->trackParticleSummaryValue(trtHTHits,xAOD::numberOfTRTHighThresholdHits);
361 if (fabs(trtHits) < 1e-6) {
362 return -99.;
363 } else {
364 //coverity[DIVIDE_BY_ZERO:FALSE]
365 return ( (double)trtHTHits / (double)trtHits );
366 }
367 }
368 else return -99.;
369}
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 EventContext & ctx,
const TrigCompositeUtils::Decision * dec,
const TrigInfo & info,
const bool onlyHLT ) const
protectedinherited

Set the accept object for all trigger levels.

Definition at line 183 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ setFilterPassed()

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

Set filter decision:

Reimplemented in AthFilterAlgorithm.

Definition at line 99 of file AthCommonAlgorithm.h.

99 {
100 execState( ctx ).setFilterPassed( state );
101 }
AthCommonAlgorithm::setFilterPassed
virtual void setFilterPassed(bool state, const EventContext &ctx) const
Set filter decision:
Definition AthCommonAlgorithm.h:99

◆ setTrigInfo()

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

Set the trigger info parsed from the chain name.

Definition at line 621 of file TrigEgammaMonitorBaseAlgorithm.cxx.

621 {
622
623 /********************************************
624 // Trigger Information struct
625 typedef struct _triginfo
626 {
627 // L1 information
628 bool L1Legacy;
629 std::string L1Threshold; //EM22VHI
630 // HLT information
631 std::string trigger; //Trigger Name
632 std::string signature; //Electron or Photon
633 float etthr; // HLT Et threshold
634 // if trigger is etcut OR idperf, pidname should be default (usually lhloose)
635 std::string pidname; // Offline loose, medium, tight, etc...
636 // extra HLT information
637 bool idperf; // Performance chain
638 bool etcut; // Et cut only chain
639 bool nogsf; // chain without gsf reconstruction
640 bool lrt; // LRT chain
641 bool ion; // Heavy Ion chain
642 std::string isolation;
643 bool isolated;
644 } TrigInfo;
645 *******************************************/
646
647 std::map<std::string, std::string> pidMap = { {"vloose" , "loose" },
648 {"loose" , "loose" },
649 {"medium" , "medium" },
650 {"tight" , "tight" },
651 {"loose1" , "loose" },
652 {"medium1" , "medium" },
653 {"tight1" , "tight" },
654 {"lhvloose" , "lhvloose" },
655 {"lhloose" , "lhloose" },
656 {"lhmedium" , "lhmedium" },
657 {"lhtight" , "lhtight" },
658 {"dnnloose" , "dnnloose" },
659 {"dnnmedium", "dnnmedium"},
660 {"dnntight" , "dnntight" },
661 {"nopid" , "nopid" } };
662
663 std::vector<std::string> isoNames = {"ivarloose","ivarmedium","ivartight","icaloloose","icalomedium","icalotight"};
664
665 bool nogsf = false;
666 bool lrt = false;
667 bool ion = false;
668 bool etcut = false;
669 bool idperf = false;
670 bool isolated = false;
671
672 std::string isolation="";
673 bool l1legacy=true;
674
675 std::string hltinfo=trigger;
676 std::string signature = "";
677 float threshold = 0;
678 // HLT_e/gXX_(pidname/etcut/idperf)_*_L1EMXX to e/gXX_(pidname/etcut/idperf)_*_L1EMXX
679 if(hltinfo.contains("HLT")) hltinfo.erase(0,4);
680 std::vector<std::string> parts;
681 for (auto&& part : hltinfo | std::views::split('_')) parts.emplace_back(part.begin(), part.end());
682 std::string pidname;
683
684 // e/gXX_(pidname/etcut/idperf)_*_L1EMXX
685 if(parts.at(0).contains("e")) {
686 signature = "Electron";
687 pidname = m_defaultProbePidElectron;
688 }else if(parts.at(0).contains("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 = trigger.contains("nogsf");
715 lrt = trigger.contains("lrt");
716 ion = trigger.contains("ion");
717
718 for(auto& iso : isoNames){
719 if(trigger.contains(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 = !l1seed.contains("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,std::move(l1seed),trigger,std::move(signature),threshold,
750 std::move(pidname),idperf,etcut,nogsf,lrt,ion,std::move(isolation),isolated};
751 m_trigInfo[trigger] = std::move(info);
752
753}
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x,...)
Definition AthMsgStreamMacros.h:47
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:121
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:119
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 777 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ sysExecute()

StatusCode AthCommonAlgorithm< 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.

Reimplemented in AthAnalysisAlgorithm.

Definition at line 80 of file AthCommonAlgorithm.cxx.

41{
42 return BaseAlg::sysExecute (ctx);
43}

◆ sysInitialize()

StatusCode AthCommonAlgorithm< 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 AthAnalysisAlgorithm, AthFilterAlgorithm, AthHistogramAlgorithm, HypoBase, InputMakerBase, and PyAthena::Alg.

Definition at line 60 of file AthCommonAlgorithm.cxx.

71 {
72 StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
73
74 if (sc.isFailure()) {
75 return sc;
76 }
77
78 ServiceHandle<ICondSvc> cs("CondSvc",name());
79 for (auto h : outputHandles()) {
80 if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
81 // do this inside the loop so we don't create the CondSvc until needed
82 if ( cs.retrieve().isFailure() ) {
83 ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
84 return StatusCode::SUCCESS;
85 }
86 if (cs->regHandle(this,*h).isFailure()) {
87 sc = StatusCode::FAILURE;
88 ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
89 << " with CondSvc");
90 }
91 }
92 }
93 return sc;
94}
AthCommonAlgorithm< Gaudi::Algorithm >::sysInitialize
virtual StatusCode sysInitialize() override
Definition AthCommonAlgorithm.cxx:71
AthCommonAlgorithm< 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 144 of file TrigEgammaMonitorBaseAlgorithm.h.

144{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:386
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 132 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

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

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

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 374 of file AthMonitorAlgorithm.h.

374{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 119 of file TrigEgammaMonitorBaseAlgorithm.h.

119{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 121 of file TrigEgammaMonitorBaseAlgorithm.h.

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

◆ m_detailedHists

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

Include more detailed histograms.

Definition at line 129 of file TrigEgammaMonitorBaseAlgorithm.h.

129{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 375 of file AthMonitorAlgorithm.h.

375{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 127 of file TrigEgammaMonitorBaseAlgorithm.h.

127{this, "DNNResultNames", {}, };

◆ m_doEffwithDNN

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

Definition at line 114 of file TrigEgammaMonitorBaseAlgorithm.h.

114{this, "ComputeEffDNN", false};

◆ m_doEffwithLH

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

Definition at line 113 of file TrigEgammaMonitorBaseAlgorithm.h.

113{this, "ComputeEffLH", false};

◆ m_doEmulation

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

Do emulation.

Definition at line 111 of file TrigEgammaMonitorBaseAlgorithm.h.

111{this, "DoEmulation", false };

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 355 of file AthMonitorAlgorithm.h.

355{this,"FilterTools",{}};

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 383 of file AthMonitorAlgorithm.h.

◆ m_electronDNNTool

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

Offline DNN Selectors.

Definition at line 105 of file TrigEgammaMonitorBaseAlgorithm.h.

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

◆ m_electronIsEMTool

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

Offline isEM Selectors.

Definition at line 101 of file TrigEgammaMonitorBaseAlgorithm.h.

101{this,"ElectronIsEMSelector",{}};

◆ m_electronLHTool

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

Offline LH Selectors.

Definition at line 103 of file TrigEgammaMonitorBaseAlgorithm.h.

103{this,"ElectronLikelihoodTool",{}};

◆ m_emulatorTool

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

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

386 {this,
387 "EnforceExpressTriggers", false,
388 "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 364 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 366 of file AthMonitorAlgorithm.h.

366{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 376 of file AthMonitorAlgorithm.h.

376{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 AthCommonAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects
privateinherited

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

Empty if no symlinks were found.

Definition at line 108 of file AthCommonAlgorithm.h.

◆ m_fileKey

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

Internal Athena name for file.

Definition at line 372 of file AthMonitorAlgorithm.h.

372{this,"FileKey",""};

◆ m_isemname

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

isem names

Definition at line 123 of file TrigEgammaMonitorBaseAlgorithm.h.

123{this, "isEMResultNames", {} };

◆ m_lbDurationDataKey

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

Definition at line 359 of file AthMonitorAlgorithm.h.

360{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 125 of file TrigEgammaMonitorBaseAlgorithm.h.

125{this, "LHResultNames", {} };

◆ m_lumiDataKey

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

Definition at line 357 of file AthMonitorAlgorithm.h.

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

◆ m_matchTool

ToolHandle<TrigEgammaMatchingToolMT> TrigEgammaMonitorBaseAlgorithm::m_matchTool
protectedinherited

Definition at line 95 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_matchTool_R3

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

Definition at line 96 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 380 of file AthMonitorAlgorithm.h.

◆ m_photonIsEMTool

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

Offline isEM Photon Selectors.

Definition at line 107 of file TrigEgammaMonitorBaseAlgorithm.h.

107{this,"PhotonIsEMSelector",{}};

◆ m_toolLookupMap

std::unordered_map<std::string, size_t, CxxUtils::TransparentStringHash, std::equal_to<> > AthMonitorAlgorithm::m_toolLookupMap
privateinherited

Definition at line 381 of file AthMonitorAlgorithm.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 350 of file AthMonitorAlgorithm.h.

350{this,"GMTools",{}};

◆ m_tp

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

TP Trigger Analysis.

Definition at line 117 of file TrigEgammaMonitorBaseAlgorithm.h.

117{this, "TPTrigger", false };

◆ m_trigdec

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

Trigger decision tool.

Definition at line 86 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 354 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 369 of file AthMonitorAlgorithm.h.

369{this,"TriggerChain",""};

◆ m_trigInfo

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

creates map of trigger name and TrigInfo struct

Definition at line 88 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_trigInfoR3

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

Definition at line 89 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 361 of file AthMonitorAlgorithm.h.

362{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 373 of file AthMonitorAlgorithm.h.

373{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 370 of file AthMonitorAlgorithm.h.

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