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
TrigEgammaMonitorElectronAlgorithm Class Reference

#include <TrigEgammaMonitorElectronAlgorithm.h>

Inheritance diagram for TrigEgammaMonitorElectronAlgorithm:
Collaboration diagram for TrigEgammaMonitorElectronAlgorithm:

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

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

Protected Member Functions

void fillLabel (const ToolHandle< GenericMonitoringTool > &groupHandle, const std::string &histname, const std::string &label) const
void fillEfficiencies (const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &, const bool) const
void fillDistributions (const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &) const
void fillResolutions (const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
 ***********************************************************************************************************************8
void fillInefficiency (const std::string &pidword, const TrigInfo &info, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const std::vector< asg::AcceptData > &acceptObjs) const
const std::map< std::string, TrigInfo > & getTrigInfoMap ()
 Helper methods.
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.
asg::AcceptData setAccept (const TrigCompositeUtils::Decision *, const TrigInfo &, const bool) const
 Set the accept object for all trigger levels.
TrigInfo getTrigInfo (const std::string &) const
 Get the trigger info parsed from the chain name (only single lepton triggers).
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.
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::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

StatusCode executeNavigation (const EventContext &ctx, const std::string &trigItem, float, const std::string &, std::vector< std::pair< std::shared_ptr< const xAOD::Egamma >, const TrigCompositeUtils::Decision * > > &) const
 navigation method called by executeNavigation
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

std::vector< std::string > m_trigList
 List of triggers to study.
Gaudi::Property< std::vector< std::string > > m_trigInputList {this, "TriggerList", {}}
 List of triggers from menu.
Gaudi::Property< std::string > m_anatype {this, "Analysis", "Electron"}
 Directory name for each algorithm.
Gaudi::Property< std::string > m_offProbeIsolation { this, "OfflineProbeIsolation", "Loose"}
 Define isolation working point for Probe electron.
Gaudi::Property< bool > m_forceProbeIsolation {this, "ForceProbeIsolation", false}
 force probe isolation
Gaudi::Property< bool > m_forcePidSelection { this, "ForcePidSelection", true}
 force pid and crack selection into electron navigation
Gaudi::Property< bool > m_forceEtThr { this, "ForceEtThreshold", true}
Gaudi::Property< bool > m_forceVetoVeryLoose { this, "ForceVetoVeryLoose", false}
Gaudi::Property< bool > m_rmCrack { this, "RemoveCrack", true}
 Remove crack region for Probe default True.
SG::ReadHandleKey< xAOD::ElectronContainer > m_offElectronKey { this, "ElectronKey", "Electrons", ""}
 Event Wise offline ElectronContainer Access and end iterator.
SG::ReadDecorHandleKey< xAOD::EventInfo > m_eventInfoDecorKey {this, "LArStatusFlag", "EventInfo.larFlags", "Key for EventInfo object"}
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronIsolationKeyPtCone20 { this, "PtCone20Decoration", m_offElectronKey, "ptcone20", "Decoration key for the ptcone20 isolation decoration" }
 Ensure offline electron isolation decoration is retrieved after being created.
ToolHandle< Trig::TrigDecisionTool > m_trigdec
 Trigger decision tool.
std::map< std::string, TrigInfo > m_trigInfo
 creates map of trigger name and TrigInfo struct
std::string m_name
std::unordered_map< std::string, size_t > m_toolLookupMap
const ToolHandle< GenericMonitoringTool > m_dummy
Gaudi::Property< bool > m_enforceExpressTriggers
DataObjIDColl m_extendedExtraObjects
 Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default).
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * > m_vhka
bool m_varHandleArraysDeclared

Detailed Description

Definition at line 14 of file TrigEgammaMonitorElectronAlgorithm.h.

Member Typedef Documentation

◆ MonVarVec_t

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

Definition at line 370 of file AthMonitorAlgorithm.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ DataType_t

enum class AthMonitorAlgorithm::DataType_t
stronginherited

Specifies what type of input data is being monitored.

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

Enumerator
userDefined 
monteCarlo 
collisions 
cosmics 
heavyIonCollisions 

Definition at line 194 of file AthMonitorAlgorithm.h.

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

◆ Environment_t

enum class AthMonitorAlgorithm::Environment_t
stronginherited

Specifies the processing environment.

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

Enumerator
user 
online 
tier0 
tier0Raw 
tier0ESD 
AOD 
altprod 

Definition at line 175 of file AthMonitorAlgorithm.h.

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

Constructor & Destructor Documentation

◆ TrigEgammaMonitorElectronAlgorithm()

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

Definition at line 13 of file TrigEgammaMonitorElectronAlgorithm.cxx.

13 :
14 TrigEgammaMonitorAnalysisAlgorithm( name, pSvcLocator )
15{}
TrigEgammaMonitorAnalysisAlgorithm::TrigEgammaMonitorAnalysisAlgorithm
TrigEgammaMonitorAnalysisAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:8

◆ ~TrigEgammaMonitorElectronAlgorithm()

TrigEgammaMonitorElectronAlgorithm::~TrigEgammaMonitorElectronAlgorithm ( )
overridevirtual

Definition at line 17 of file TrigEgammaMonitorElectronAlgorithm.cxx.

18{}

Member Function Documentation

◆ ApplyElectronPid()

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

Get offline electron decision.

Definition at line 49 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ ApplyPhotonPid()

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

Get offline electron decision.

Definition at line 96 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const
overridevirtualinherited

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

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

62{
63 return 0;
64}

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

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

Definition at line 224 of file AthMonitorAlgorithm.h.

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

◆ dataTypeStringToEnum()

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

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

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

Definition at line 144 of file AthMonitorAlgorithm.cxx.

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

◆ declareGaudiProperty()

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95{ return m_detStore; }

◆ dR()

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

Get delta R.

Definition at line 296 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

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

Definition at line 208 of file AthMonitorAlgorithm.h.

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

◆ envStringToEnum()

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

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

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

Definition at line 116 of file AthMonitorAlgorithm.cxx.

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

◆ evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85{ return m_evtStore; }

◆ execute()

StatusCode AthMonitorAlgorithm::execute ( const EventContext & ctx) const
overridevirtualinherited

Applies filters and trigger requirements.

Then, calls fillHistograms().

Parameters
ctxevent context for reentrant Athena call
Returns
StatusCode

Definition at line 77 of file AthMonitorAlgorithm.cxx.

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

◆ executeNavigation()

StatusCode TrigEgammaMonitorElectronAlgorithm::executeNavigation ( const EventContext & ctx,
const std::string & trigItem,
float etthr,
const std::string & pidName,
std::vector< std::pair< std::shared_ptr< const xAOD::Egamma >, const TrigCompositeUtils::Decision * > > & pairObjs ) const
private

navigation method called by executeNavigation

default is true

default is true

default is true

default is false

default is Loose

default is false

Definition at line 103 of file TrigEgammaMonitorElectronAlgorithm.cxx.

108{
109
110 ATH_MSG_DEBUG("Apply navigation selection ");
111
112 SG::ReadHandle<xAOD::ElectronContainer> offElectrons(m_offElectronKey, ctx);
113
114 if(!offElectrons.isValid())
115 {
116 ATH_MSG_DEBUG("Failed to retrieve offline Electrons ");
117 return StatusCode::FAILURE;
118 }
119
120
121 const std::string decorName="is"+pidName;
122 for(const auto *const eg : *offElectrons ){
123
124 const TrigCompositeUtils::Decision *dec=nullptr;
125
126 if(!eg->trackParticle()){
127 ATH_MSG_DEBUG("No track Particle");
128 continue;
129 }
130 if(!eg->caloCluster()){
131 ATH_MSG_DEBUG("No caloCluster");
132 continue;
133 }
134
135 if(m_forceEtThr){
136 if( !( getEt(eg) > (etthr-5.)*1.e3) ) continue;
137 }
138
139 if(m_rmCrack){
140 if ( (fabs(eg->eta())>1.37 && fabs(eg->eta())<1.52) || fabs(eg->eta())>2.47 ) continue;
141 }
142
143 if(m_forcePidSelection){
144 if(!ApplyElectronPid(ctx,eg,pidName)){
145 ATH_MSG_DEBUG("Fails ElectronID "<< pidName);
146 continue;
147 }
148 ATH_MSG_DEBUG("Passes ElectronID "<< pidName);
149 }
150
151 if (m_forceProbeIsolation) {
152 if (!isIsolated(eg, m_offProbeIsolation)) continue;
153 }
154
155 if(m_forceVetoVeryLoose){
156 bool veto = ApplyElectronPid(ctx,eg,"lhvloose");
157 if(veto) continue;
158 }
159
160 const auto el = std::make_shared<const xAOD::Electron>(*eg);
161 SG::Decorator<bool> decor (decorName);
162 decor(*el)=static_cast<bool>(true);
163
164 match()->match(el.get(), trigItem, dec, TrigDefs::includeFailedDecisions);
165 //match()->match(el, trigItem, dec);
166 pairObjs.emplace_back(el, dec);
167
168 }
169
170 ATH_MSG_DEBUG("BaseToolMT::Electron TEs " << pairObjs.size() << " found.");
171 return StatusCode::SUCCESS;
172}
TrigEgammaMonitorBaseAlgorithm::ApplyElectronPid
bool ApplyElectronPid(const EventContext &ctx, const xAOD::Electron *eg, const std::string &) const
Get offline electron decision.
Definition TrigEgammaMonitorBaseAlgorithm.cxx:49
TrigEgammaMonitorBaseAlgorithm::match
const ToolHandle< TrigEgammaMatchingToolMT > & match() const
Get the e/g match tool.
Definition TrigEgammaMonitorBaseAlgorithm.h:138
TrigEgammaMonitorBaseAlgorithm::getEt
float getEt(const xAOD::Electron *eg) const
Definition TrigEgammaMonitorBaseAlgorithm.cxx:315
TrigEgammaMonitorBaseAlgorithm::isIsolated
bool isIsolated(const xAOD::Electron *, const std::string &) const
Check if electron fulfils isolation criteria.
Definition TrigEgammaMonitorBaseAlgorithm.cxx:116
TrigEgammaMonitorElectronAlgorithm::m_rmCrack
Gaudi::Property< bool > m_rmCrack
Remove crack region for Probe default True.
Definition TrigEgammaMonitorElectronAlgorithm.h:55
TrigEgammaMonitorElectronAlgorithm::m_forceProbeIsolation
Gaudi::Property< bool > m_forceProbeIsolation
force probe isolation
Definition TrigEgammaMonitorElectronAlgorithm.h:47
TrigEgammaMonitorElectronAlgorithm::m_offElectronKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_offElectronKey
Event Wise offline ElectronContainer Access and end iterator.
Definition TrigEgammaMonitorElectronAlgorithm.h:57
TrigEgammaMonitorElectronAlgorithm::m_forcePidSelection
Gaudi::Property< bool > m_forcePidSelection
force pid and crack selection into electron navigation
Definition TrigEgammaMonitorElectronAlgorithm.h:49
TrigEgammaMonitorElectronAlgorithm::m_offProbeIsolation
Gaudi::Property< std::string > m_offProbeIsolation
Define isolation working point for Probe electron.
Definition TrigEgammaMonitorElectronAlgorithm.h:45
veto
std::vector< std::string > veto
these patterns are anded
Definition listroot.cxx:191
SG::Decorator
SG::Decorator< T, ALLOC > Decorator
Helper class to provide type-safe access to aux data, specialized for JaggedVecElt.
Definition AuxElement.h:576
TrigDefs::includeFailedDecisions
static const unsigned int includeFailedDecisions
Run3 synonym of alsoDeactivateTEs.
Definition TrigEvent/TrigDecisionInterface/TrigDecisionInterface/Conditions.h:40

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

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

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

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

◆ fillDistributions()

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

Definition at line 422 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

424{
425
426 const std::string trigger = info.trigger;
427
428 unsigned int condition=TrigDefs::Physics;
429
430 // Offline
431 std::vector<const xAOD::Egamma*> eg_vec;
432 std::vector<const xAOD::Electron*> el_vec;
433 for( auto pairObj: pairObjs )
434 {
435 eg_vec.push_back(pairObj.first);
436 if( xAOD::EgammaHelpers::isElectron(pairObj.first)){
437 const xAOD::Electron* elOff = static_cast<const xAOD::Electron*> (pairObj.first);
438 el_vec.push_back(elOff);
439 }
440 }
441
442 // Offline
443 fillShowerShapes( trigger, eg_vec, false );
444 fillTracking( ctx, trigger, el_vec, false );
445
446 // L1Calo
447 {
448 // Fill L1 features
449 auto initRois = tdt()->features<TrigRoiDescriptorCollection>(trigger,condition,"",TrigDefs::allFeaturesOfType,"initialRoI");
450
451 if (info.L1Legacy){
452 std::vector<const xAOD::EmTauRoI*> l1_vec;
453 for( auto &initRoi: initRois ){
454 if( !initRoi.link.isValid() ) continue;
455 const auto *feat = match()->getL1Feature( initRoi.source );
456 if(feat) l1_vec.push_back(feat);
457 }
458 fillL1Calo( trigger, l1_vec );
459 }else{
460 std::vector<const xAOD::eFexEMRoI*> l1_vec;
461 for( auto &initRoi: initRois ){
462 if( !initRoi.link.isValid() ) continue;
463 const auto *feat = match()->getL1eEMFeature( initRoi.source );
464 if(feat) l1_vec.push_back(feat);
465 }
466 fillL1eEM( trigger, l1_vec );
467 }
468
469 }
470
471
472 // L2Calo
473 {
474 std::vector<const xAOD::TrigEMCluster*> emCluster_vec;
475 auto vec = tdt()->features<xAOD::TrigEMClusterContainer>(trigger,condition ,match()->key("FastCalo") );
476 for(auto &featLinkInfo : vec ){
477 if(! featLinkInfo.isValid() ) continue;
478 const auto *feat = *(featLinkInfo.link);
479 if(!feat) continue;
480 emCluster_vec.push_back(feat);
481 }
482 fillL2Calo( trigger, emCluster_vec );
483 }
484 // EFCalo
485 {
486 std::string key = match()->key("PrecisionCalo_Electron");
487 if(info.signature == "Photon") key = match()->key("PrecisionCalo_Photon");
488 if(info.lrt) key = match()->key("PrecisionCalo_LRT");
489 if(info.ion) key = match()->key("PrecisionCalo_HI");
490
491 std::vector<const xAOD::CaloCluster* > clus_vec;
492 auto vec = tdt()->features<xAOD::CaloClusterContainer>(trigger,condition,key);
493 for(auto &featLinkInfo : vec ){
494 if(! featLinkInfo.isValid() ) continue;
495 const auto *feat = *(featLinkInfo.link);
496 if(!feat) continue;
497 clus_vec.push_back(feat);
498 }
499 fillEFCalo( trigger, clus_vec );
500 }
501
502 if ( info.signature == "Electron" ){
503
504 // L2 Electron
505 {
506 std::string key = match()->key("FastElectrons");
507 if(info.lrt) key = match()->key("FastElectrons_LRT");
508
509 std::vector<const xAOD::TrigElectron*> el_vec;
510 // Get only passed objects
511 auto vec = tdt()->features<xAOD::TrigElectronContainer>(trigger,condition,key );
512 for( auto &featLinkInfo : vec ){
513 if(! featLinkInfo.isValid() ) continue;
514 const auto *feat = *(featLinkInfo.link);
515 if(!feat) continue;
516 el_vec.push_back(feat);
517 }
518 fillL2Electron( trigger, el_vec );
519 }
520 // HLT Electron
521 {
522 std::string key = match()->key("Electrons_GSF");
523 if(info.nogsf) key = match()->key("Electrons");
524 if(info.lrt) key = match()->key("Electrons_LRT");
525
526 std::vector<const xAOD::Electron*> el_vec;
527 std::vector<const xAOD::Egamma*> eg_vec;
528 auto vec = tdt()->features<xAOD::ElectronContainer>(trigger, condition ,key );
529 for( auto &featLinkInfo : vec ){
530 if(! featLinkInfo.isValid() ) continue;
531 const auto *feat = *(featLinkInfo.link);
532 if(!feat) continue;
533 el_vec.push_back(feat);
534 eg_vec.push_back(feat);
535 }
536 fillShowerShapes( trigger, eg_vec, true );
537 fillTracking( ctx, trigger, el_vec, true );
538 }
539 }else if ( info.signature == "Photon"){
540 // Fast Photon
541 {
542 std::string key = match()->key("FastPhotons");
543 std::vector<const xAOD::TrigPhoton*> ph_vec;
544 // Get only passed objects
545 auto vec = tdt()->features<xAOD::TrigPhotonContainer>(trigger,condition,key );
546 for( auto &featLinkInfo : vec ){
547 if(! featLinkInfo.isValid() ) continue;
548 const auto *feat = *(featLinkInfo.link);
549 if(!feat) continue;
550 ph_vec.push_back(feat);
551 }
552 fillL2Photon( trigger, ph_vec );
553 }
554
555 // HLT Photon
556 {
557 std::vector<const xAOD::Egamma*> ph_vec;
558 auto vec = tdt()->features<xAOD::PhotonContainer>(trigger,condition ,match()->key("Photons") );
559 for( auto &featLinkInfo : vec ){
560 if(! featLinkInfo.isValid() ) continue;
561 const auto *feat = *(featLinkInfo.link);
562 if(!feat) continue;
563 ph_vec.push_back(feat);
564 }
565 fillShowerShapes( trigger, ph_vec, true );
566 }
567 }else{
568 ATH_MSG_INFO( "Chain type not specified" );
569 }
570
571}
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
vec
std::vector< size_t > vec
Definition CombinationsGeneratorTest.cxx:9
TrigRoiDescriptorCollection
Athena::TPCnvVers::Current Athena::TPCnvVers::Old TrigRoiDescriptorCollection
Definition TrigSteeringEventTPCnv.cxx:78
TrigEgammaMonitorAnalysisAlgorithm::fillTracking
void fillTracking(const EventContext &ctx, const std::string &trigger, const std::vector< const xAOD::Electron * > &eg_vec, bool online) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:831
TrigEgammaMonitorAnalysisAlgorithm::fillEFCalo
void fillEFCalo(const std::string &trigger, const std::vector< const xAOD::CaloCluster * > &clus_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:713
TrigEgammaMonitorAnalysisAlgorithm::fillShowerShapes
void fillShowerShapes(const std::string &trigger, const std::vector< const xAOD::Egamma * > &eg_vec, bool online) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:768
TrigEgammaMonitorAnalysisAlgorithm::fillL2Calo
void fillL2Calo(const std::string &trigger, const std::vector< const xAOD::TrigEMCluster * > &emCluster_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:637
TrigEgammaMonitorAnalysisAlgorithm::fillL1eEM
void fillL1eEM(const std::string &trigger, const std::vector< const xAOD::eFexEMRoI * > &l1_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:606
TrigEgammaMonitorAnalysisAlgorithm::fillL2Photon
void fillL2Photon(const std::string &trigger, const std::vector< const xAOD::TrigPhoton * > &eg_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:688
TrigEgammaMonitorAnalysisAlgorithm::fillL2Electron
void fillL2Electron(const std::string &trigger, const std::vector< const xAOD::TrigElectron * > &el_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:664
TrigEgammaMonitorAnalysisAlgorithm::fillL1Calo
void fillL1Calo(const std::string &trigger, const std::vector< const xAOD::EmTauRoI * > &l1_vec) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:577
TrigEgammaMonitorBaseAlgorithm::tdt
const ToolHandle< Trig::TrigDecisionTool > & tdt() const
Get the TDT.
Definition TrigEgammaMonitorBaseAlgorithm.h:136
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
privateinherited

Definition at line 713 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

714{
715
716 auto monGroup = getGroup( trigger + "_Distributions_EFCalo" );
717
718
719 std::vector<float> energyBE0_vec, energyBE1_vec, energyBE2_vec, energyBE3_vec,
720 energy_vec, et_vec, eta_vec, phi_vec, eta_calo_vec, phi_calo_vec, highet_vec;
721
722
723
724 auto energyBE0_col = Monitored::Collection("energyBE0", energyBE0_vec);
725 auto energyBE1_col = Monitored::Collection("energyBE1", energyBE1_vec);
726 auto energyBE2_col = Monitored::Collection("energyBE2", energyBE2_vec);
727 auto energyBE3_col = Monitored::Collection("energyBE3", energyBE3_vec);
728 auto energy_col = Monitored::Collection("energy" , energy_vec );
729 auto et_col = Monitored::Collection("et" , et_vec );
730 auto highet_col = Monitored::Collection("highet" , highet_vec );
731 auto eta_col = Monitored::Collection("eta" , eta_vec );
732 auto phi_col = Monitored::Collection("phi" , phi_vec );
733 auto eta_calo_col = Monitored::Collection("eta_calo" , eta_calo_vec );
734 auto phi_calo_col = Monitored::Collection("phi_calo" , phi_calo_vec );
735
736 for ( const auto *clus : clus_vec )
737 {
738 double tmpeta = -999.;
739 if(!clus->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta))
740 tmpeta=-999.;
741 double tmpphi = -999.;
742 if(!clus->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi))
743 tmpphi=-999.;
744
745 energyBE0_vec.push_back( clus->energyBE(0)/Gaudi::Units::GeV );
746 energyBE1_vec.push_back( clus->energyBE(1)/Gaudi::Units::GeV );
747 energyBE2_vec.push_back( clus->energyBE(2)/Gaudi::Units::GeV );
748 energyBE3_vec.push_back( clus->energyBE(3)/Gaudi::Units::GeV );
749 energy_vec.push_back( clus->e()/Gaudi::Units::GeV );
750 et_vec.push_back( clus->et()/Gaudi::Units::GeV );
751 highet_vec.push_back( clus->et()/Gaudi::Units::GeV );
752 eta_vec.push_back( clus->eta() );
753 phi_vec.push_back( clus->phi() );
754 eta_calo_vec.push_back( tmpeta );
755 phi_calo_vec.push_back( tmpphi );
756
757 }
758
759
760 fill( monGroup, energyBE0_col, energyBE1_col, energyBE2_col, energyBE3_col,
761 energy_col, et_col, eta_col, phi_col, eta_calo_col, phi_calo_col, highet_col);
762}
AthMonitorAlgorithm::getGroup
const ToolHandle< GenericMonitoringTool > & getGroup(const std::string &name) const
Get a specific monitoring tool from the tool handle array.
Definition AthMonitorAlgorithm.cxx:168
xAOD::CaloCluster_v1::ETACALOFRAME
@ ETACALOFRAME
Eta in the calo frame (for egamma).
Definition CaloCluster_v1.h:190
xAOD::CaloCluster_v1::PHICALOFRAME
@ PHICALOFRAME
Phi in the calo frame (for egamma).
Definition CaloCluster_v1.h:191
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable > > &&variables) const
Fills a vector of variables to a group by reference.
Definition AthMonitorAlgorithm.cxx:99
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition MonitoredCollection.h:38
python.TIDAMonTool.monGroup
monGroup(analysis_chain)
Definition TIDAMonTool.py:324

◆ fillEfficiencies()

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

Definition at line 42 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

Definition at line 157 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

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

adds event to the monitoring histograms

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

Parameters
ctxforwarded from execute
Returns
StatusCode

Reimplemented from TrigEgammaMonitorBaseAlgorithm.

Definition at line 46 of file TrigEgammaMonitorElectronAlgorithm.cxx.

47{
48
49 ATH_MSG_DEBUG("Executing TrigEgammaMonitorElectronAlgorithm");
50
51 if(isHLTTruncated()){
52 ATH_MSG_DEBUG("HLTResult truncated, skip trigger analysis");
53 return StatusCode::SUCCESS;
54 }
55
56 // Noise burst protection
57 SG::ReadHandle<xAOD::EventInfo> thisEvent(GetEventInfo(ctx));
58 ATH_CHECK(thisEvent.isValid());
59 if ( thisEvent->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO)) {
60 ATH_MSG_DEBUG("LAr Noise Burst Veto, skip trigger analysis");
61 return StatusCode::SUCCESS;
62 }
63
64 ATH_MSG_DEBUG("Chains for Analysis " << m_trigList);
65
66 for(const auto& trigger : m_trigList){
67
68 const TrigInfo info = getTrigInfo(trigger);
69
70 ATH_MSG_DEBUG("Start Chain Analysis ============================= " << trigger << " " << info.trigger);
71
72 std::vector< std::pair<std::shared_ptr<const xAOD::Egamma>, const TrigCompositeUtils::Decision*>> pairObjs;
73 if ( executeNavigation( ctx, info.trigger,info.etthr,info.pidname, pairObjs).isFailure() )
74 {
75 ATH_MSG_DEBUG("executeNavigation Fails");
76 return StatusCode::SUCCESS;
77 }
78
79 std::vector< std::pair<const xAOD::Egamma*, const TrigCompositeUtils::Decision*>> pairObjsRaw;
80 pairObjsRaw.reserve(pairObjs.size());
81 for (const auto& itr : pairObjs) {
82 pairObjsRaw.emplace_back(itr.first.get(), itr.second);
83 }
84
85
86 fillDistributions( ctx, pairObjsRaw, info );
87 fillEfficiencies( ctx, pairObjsRaw, info, false );
88 fillResolutions( ctx, pairObjsRaw, info );
89
90 ATH_MSG_DEBUG("End Chain Analysis ============================= " << trigger);
91 } // End loop over trigger list
92
93
94 return StatusCode::SUCCESS;
95}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
TrigInfo
struct _triginfo TrigInfo
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.).
Definition AthMonitorAlgorithm.cxx:111
TrigEgammaMonitorAnalysisAlgorithm::fillEfficiencies
void fillEfficiencies(const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &, const bool) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:42
TrigEgammaMonitorAnalysisAlgorithm::fillDistributions
void fillDistributions(const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:422
TrigEgammaMonitorAnalysisAlgorithm::fillResolutions
void fillResolutions(const EventContext &ctx, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
*****************************************************************************************************...
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:937
TrigEgammaMonitorBaseAlgorithm::getTrigInfo
TrigInfo getTrigInfo(const std::string &) const
Get the trigger info parsed from the chain name (only single lepton triggers).
Definition TrigEgammaMonitorBaseAlgorithm.cxx:607
TrigEgammaMonitorElectronAlgorithm::executeNavigation
StatusCode executeNavigation(const EventContext &ctx, const std::string &trigItem, float, const std::string &, std::vector< std::pair< std::shared_ptr< const xAOD::Egamma >, const TrigCompositeUtils::Decision * > > &) const
navigation method called by executeNavigation
Definition TrigEgammaMonitorElectronAlgorithm.cxx:103
TrigEgammaMonitorElectronAlgorithm::m_trigList
std::vector< std::string > m_trigList
List of triggers to study.
Definition TrigEgammaMonitorElectronAlgorithm.h:39
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition EventInfo_v1.h:335

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

Definition at line 1052 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillHLTPhotonResolution()

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

Definition at line 1430 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

Definition at line 379 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

384{
385 auto monGroup = getGroup(info.trigger+"_Inefficiency");
386 unsigned iObj=0;
387 SG::Decorator<bool> pidwordDec("is"+pidword);
388 for( auto pairObj : pairObjs ){
389
390 bool pid=true;
391 bool isPassedL1Calo = acceptObjs[iObj].getCutResult( "L1Calo");
392 bool isPassedL2Calo = acceptObjs[iObj].getCutResult( "L2Calo");
393 bool isPassedL2 = acceptObjs[iObj].getCutResult( "L2" );
394 bool isPassedEFCalo = acceptObjs[iObj].getCutResult( "EFCalo");
395 bool isPassedHLT = acceptObjs[iObj].getCutResult( "HLT" );
396
397 const auto *eg = pairObj.first;
398 if(xAOD::EgammaHelpers::isElectron(eg)){
399 ATH_MSG_DEBUG("Offline Electron with pidword " << pidword);
400 const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg);
401 pid=pidwordDec(*el);
402 ATH_MSG_DEBUG("Electron pid " << pid);
403 }
404 if(pid){
405 if(!isPassedL1Calo){
406 fillLabel(monGroup, "InefficiencyCounts", "L1Calo" );
407 }if(!isPassedL2Calo){
408 fillLabel(monGroup, "InefficiencyCounts", "L2Calo" );
409 }if(!isPassedL2){
410 fillLabel(monGroup, "InefficiencyCounts", "L2" );
411 }if(!isPassedEFCalo){
412 fillLabel(monGroup, "InefficiencyCounts", "EFCalo" );
413 }if(!isPassedHLT){
414 fillLabel(monGroup, "InefficiencyCounts", "HLT" );
415 }
416 }
417 iObj++;
418 }
419}
TrigEgammaMonitorAnalysisAlgorithm::fillLabel
void fillLabel(const ToolHandle< GenericMonitoringTool > &groupHandle, const std::string &histname, const std::string &label) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:30

◆ fillL1Calo()

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

Definition at line 577 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

578{
579 auto monGroup = getGroup(trigger+"_Distributions_L1Calo");
580
581 std::vector<float> eta_vec, phi_vec, energy_vec, roi_et_vec, emIso_vec, hadCore_vec;
582
583 auto eta_col = Monitored::Collection( "eta" , eta_vec );
584 auto phi_col = Monitored::Collection( "phi" , phi_vec );
585 auto energy_col = Monitored::Collection( "energy" , energy_vec );
586 auto roi_et_col = Monitored::Collection( "roi_et" , roi_et_vec );
587 auto emIso_col = Monitored::Collection( "emIso" , emIso_vec );
588 auto hadCore_col = Monitored::Collection( "hadCore" , hadCore_vec );
589
590 for( const auto *l1 : l1_vec )
591 {
592 if(!l1) continue;
593 eta_vec.push_back( l1->eta() );
594 phi_vec.push_back( l1->phi() );
595 energy_vec.push_back( l1->emClus()/Gaudi::Units::GeV );
596 roi_et_vec.push_back( l1->eT()/Gaudi::Units::GeV );
597 emIso_vec.push_back( l1->emIsol()/Gaudi::Units::GeV );
598 hadCore_vec.push_back( l1->hadCore()/Gaudi::Units::GeV );
599 }
600
601 fill( monGroup, eta_col, phi_col, energy_col, roi_et_col, emIso_col, hadCore_col );
602
603}

◆ fillL1CaloAbsResolution()

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

Definition at line 1024 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillL1CaloResolution()

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

Definition at line 994 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

996{
997 auto monGroup = getGroup( trigger + "_Resolutions_L1Calo" );
998
999 std::vector<float> eta_vec, res_et_vec;
1000
1001 auto eta_col = Monitored::Collection( "eta" , eta_vec );
1002 auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1003
1004
1005 for (const auto & pairObj : pairObjs){
1006 const auto *off = pairObj.first;
1007 const auto *l1 = pairObj.second;
1008 ATH_MSG_DEBUG("Fill L1CaloResolution");
1009 if(off->type()==xAOD::Type::Electron){
1010 const xAOD::Electron* eloff =static_cast<const xAOD::Electron*> (off);
1011 eta_vec.push_back( l1->eta() );
1012 res_et_vec.push_back( (l1->emClus()-getEt(eloff))/getEt(eloff) ) ;
1013
1014 }
1015 }
1016
1017 fill( monGroup, eta_col, res_et_col );
1018}

◆ fillL1eEM()

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

Definition at line 606 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

607{
608 auto monGroup = getGroup(trigger+"_Distributions_L1Calo");
609
610 std::vector<float> eta_vec, phi_vec, et_vec, wstot_vec, reta_vec, rhad_vec;
611
612 auto et_col = Monitored::Collection( "et" , et_vec );
613 auto eta_col = Monitored::Collection( "eta" , eta_vec );
614 auto phi_col = Monitored::Collection( "phi" , phi_vec );
615 auto wstot_col = Monitored::Collection( "Wstot" , wstot_vec );
616 auto reta_col = Monitored::Collection( "Reta" , reta_vec );
617 auto rhad_col = Monitored::Collection( "Rhad" , rhad_vec );
618
619
620 for( const auto *l1 : l1_vec )
621 {
622 if(!l1) continue;
623 et_vec.push_back( l1->et()/Gaudi::Units::GeV );
624 eta_vec.push_back( l1->eta() );
625 phi_vec.push_back( l1->phi() );
626 wstot_vec.push_back( l1->Wstot() );
627 reta_vec.push_back( l1->Reta() );
628 rhad_vec.push_back( l1->Rhad() );
629 }
630
631 fill( monGroup, eta_col, phi_col, et_col, wstot_col, reta_col, rhad_col );
632
633}

◆ fillL2Calo()

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

Definition at line 637 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

638{
639 auto monGroup = getGroup(trigger+"_Distributions_L2Calo");
640
641 std::vector<float> et_vec,highet_vec, eta_vec, phi_vec;
642
643 auto et_col = Monitored::Collection("et" , et_vec );
644 auto highet_col = Monitored::Collection("highet" , highet_vec );
645 auto eta_col = Monitored::Collection("eta", eta_vec );
646 auto phi_col = Monitored::Collection("phi", phi_vec );
647
648 for ( const auto *emCluster : emCluster_vec )
649 {
650 if(!emCluster) continue;
651 et_vec.push_back( emCluster->et()/Gaudi::Units::GeV );
652 highet_vec.push_back( emCluster->et()/Gaudi::Units::GeV );
653 eta_vec.push_back( emCluster->eta() );
654 phi_vec.push_back( emCluster->phi() );
655 }
656
657 fill( monGroup, et_col, eta_col, phi_col, highet_col );
658
659
660}

◆ fillL2CaloResolution()

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

Definition at line 1735 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

1738{
1739 ATH_MSG_DEBUG("Fill L2Calo Resolution");
1740
1741 auto monGroup = getGroup( trigger + "_Resolutions_L2Calo" );
1742
1743 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,
1744 res_Rphi_vec, res_weta2_vec, res_f1_vec, res_f3_vec, res_eratio_vec, et_vec, eta_vec;
1745
1746
1747 auto et_col = Monitored::Collection( "et" , et_vec );
1748 auto eta_col = Monitored::Collection( "eta" , eta_vec );
1749 auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
1750 auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
1751 auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
1752 auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
1753 auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
1754 auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
1755 auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
1756 auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
1757 auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
1758 auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
1759 auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
1760 auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
1761 auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
1762
1763
1764 for ( const auto & pairObj : pairObjs ){
1765
1766
1767 const xAOD::Egamma *off = pairObj.first;
1768 const xAOD::TrigEMCluster *onl=nullptr;
1769
1770 { // Get the closest electron object from the trigger starting with deltaR = 0.15
1771 float maxDeltaR=0.05;
1772 auto vec = tdt()->features<xAOD::TrigEMClusterContainer>(trigger,TrigDefs::Physics ,match()->key("FastCalo") );
1773 for(auto &featLinkInfo : vec ){
1774 if(! featLinkInfo.isValid() ) continue;
1775 const auto *feat = *(featLinkInfo.link);
1776 if(!feat) continue;
1777 float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
1778 if( deltaR < maxDeltaR){
1779 maxDeltaR=deltaR;
1780 onl=feat;
1781 }
1782 }
1783 }
1784
1785 if(!onl) continue;
1786
1787 et_vec.push_back(onl->et()*1e-3);
1788 eta_vec.push_back(onl->eta());
1789 const float dummy=-999;
1790
1791 float val_off=0.;
1792
1793 val_off=off->caloCluster()->et();
1794 if(val_off!=0.){
1795 res_et_vec.push_back(((onl->et())-val_off)/val_off);
1796 }else{
1797 res_et_vec.push_back(dummy);
1798 }
1799
1800 val_off=off->caloCluster()->eta();
1801 if(val_off!=0.){
1802 res_eta_vec.push_back((onl->eta()-val_off)/val_off);
1803 }else{
1804 res_eta_vec.push_back(dummy);
1805 }
1806
1807 val_off=off->caloCluster()->phi();
1808 if(val_off!=0.){
1809 res_phi_vec.push_back((onl->phi()-val_off)/val_off);
1810 }else{
1811 res_phi_vec.push_back((onl->phi()-val_off)/val_off);
1812 }
1813
1814 float elonl_ethad = onl->energy( CaloSampling::HEC0 ); elonl_ethad += onl->energy( CaloSampling::HEC1 );
1815 elonl_ethad += onl->energy( CaloSampling::HEC2 ); elonl_ethad += onl->energy( CaloSampling::HEC3 );
1816 elonl_ethad += onl->energy( CaloSampling::TileBar0 ); elonl_ethad += onl->energy( CaloSampling::TileExt0 );
1817 elonl_ethad += onl->energy( CaloSampling::TileBar1 ); elonl_ethad += onl->energy( CaloSampling::TileExt1 );
1818 elonl_ethad += onl->energy( CaloSampling::TileBar2 ); elonl_ethad += onl->energy( CaloSampling::TileExt2 );
1819 elonl_ethad /= TMath::CosH(onl->eta() );
1820 val_off=getShowerShape_ethad(off);
1821 if(val_off!=0.){
1822 res_ethad_vec.push_back((elonl_ethad-val_off)/val_off);
1823 }else{
1824 res_ethad_vec.push_back(dummy);
1825 }
1826
1827 val_off=getShowerShape_ethad1(off);
1828 if(val_off!=0.){
1829 res_ethad1_vec.push_back(( (onl->ehad1()/TMath::Abs(onl->eta()) )-val_off)/val_off);
1830 }else{
1831 res_ethad1_vec.push_back(dummy);
1832 }
1833
1834 float elonl_Rhad = elonl_ethad / onl->energy() ;
1835 val_off=getShowerShape_Rhad(off);
1836 if(val_off!=0.){
1837 res_Rhad_vec.push_back(( elonl_Rhad-val_off)/val_off);
1838 }else{
1839 res_Rhad_vec.push_back(dummy);
1840 }
1841
1842 float elonl_Rhad1 = onl->ehad1() / onl->energy() ;
1843 val_off=getShowerShape_Rhad1(off);
1844 if(val_off!=0.){
1845 res_Rhad1_vec.push_back(( elonl_Rhad1-val_off)/val_off);
1846 }else{
1847 res_Rhad1_vec.push_back(dummy);
1848 }
1849
1850 float onl_reta= 999.0;
1851 if ( fabsf ( onl->e277() ) > 0.01 ) onl_reta = onl->e237() / onl->e277();
1852 val_off=getShowerShape_Reta(off);
1853 if(val_off!=0.){
1854 res_Reta_vec.push_back( (onl_reta -val_off)/val_off);
1855 }else{
1856 res_Reta_vec.push_back(dummy);
1857 }
1858
1859 val_off=getShowerShape_weta2(off);
1860 if(val_off!=0.){
1861 res_weta2_vec.push_back(( (onl->weta2())-val_off)/val_off);
1862 }else{
1863 res_weta2_vec.push_back(dummy);
1864 }
1865
1866 float onl_f1 = onl->energy(CaloSampling::EMB1)+onl->energy(CaloSampling::EME1);
1867 onl_f1 /= onl->energy();
1868 val_off=getShowerShape_f1(off);
1869 if(val_off!=0.){
1870 res_f1_vec.push_back(( (onl_f1)-val_off)/val_off);
1871 }else{
1872 res_f1_vec.push_back(dummy);
1873 }
1874
1875 float onl_f3 = onl->energy(CaloSampling::EMB3)+onl->energy(CaloSampling::EME3);
1876 onl_f3 /= onl->energy();
1877 val_off=getShowerShape_f3(off);
1878 if(val_off!=0.){
1879 res_f3_vec.push_back(( (onl_f3)-val_off)/val_off);
1880 }else{
1881 res_f3_vec.push_back(dummy);
1882 }
1883
1884 float onl_eratio = 999.0;
1885 if ( fabsf(onl->emaxs1() + onl->e2tsts1()) > 0.01 )
1886 onl_eratio = (onl->emaxs1() - onl->e2tsts1()) / (onl->emaxs1() + onl->e2tsts1());
1887 val_off=getShowerShape_Eratio(off);
1888 if(val_off!=0.){
1889 res_eratio_vec.push_back(( (onl_eratio)-val_off)/val_off);
1890 }else{
1891 res_eratio_vec.push_back(dummy);
1892 }
1893
1894 }// Loop over all pair objects
1895
1896
1897 // Fill everything
1898 fill( monGroup ,
1899 et_col ,
1900 eta_col ,
1901 res_et_col ,
1902 res_eta_col ,
1903 res_phi_col ,
1904 res_ethad_col ,
1905 res_ethad1_col ,
1906 res_Rhad_col ,
1907 res_Rhad1_col ,
1908 res_Reta_col ,
1909 res_Rphi_col ,
1910 res_weta2_col ,
1911 res_f1_col ,
1912 res_f3_col ,
1913 res_eratio_col
1914 );
1915
1916}
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
privateinherited

Definition at line 664 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

665{
666
667 auto monGroup = getGroup(trigger+"_Distributions_L2Electron");
668
669 std::vector<float> et_vec, eta_vec, phi_vec, highet_vec;
670
671 auto et_col = Monitored::Collection("et" , et_vec );
672 auto highet_col = Monitored::Collection("highet" , highet_vec );
673 auto eta_col = Monitored::Collection("eta", eta_vec );
674 auto phi_col = Monitored::Collection("phi", phi_vec );
675
676 for ( const auto *el : el_vec )
677 {
678 if(!el) continue;
679 et_vec.push_back( el->pt()/Gaudi::Units::GeV );
680 highet_vec.push_back( el->pt()/Gaudi::Units::GeV );
681 eta_vec.push_back( el->eta() );
682 phi_vec.push_back( el->phi() );
683 }
684
685 fill( monGroup, et_col, eta_col, phi_col, highet_col );
686}

◆ fillL2Photon()

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

Definition at line 688 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillLabel()

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

Definition at line 30 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillResolutions()

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

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

Definition at line 937 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

940{
941
942 std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pair_l1_vec;
943 std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_eg_vec;
944 const std::string trigger = info.trigger;
945
946 SG::Decorator<bool> pidnameDec("is"+info.pidname);
947 for( auto pairObj : pairObjs ){
948
949 const xAOD::Egamma* eg = pairObj.first;
950 const auto *feat = pairObj.second;
951
952 if (feat){
953
954 //
955 // Get only off and l1 where the offline object passed by the offline pid selector
956 //
957 const auto *l1 = match()->getL1Feature( feat );
958 if(eg->type()==xAOD::Type::Electron){
959 const xAOD::Electron* el = static_cast<const xAOD::Electron*>(eg);
960 float et = getEt(el)/Gaudi::Units::GeV;
961 if( et < info.etthr-5.0) continue;
962 if(!pidnameDec(*eg)) continue;
963 pair_eg_vec.emplace_back(el,feat);
964 if(l1) pair_l1_vec.emplace_back(eg,l1 );
965 }
966 else if(eg->type()==xAOD::Type::Photon){
967 float et = getCluster_et(eg)/Gaudi::Units::GeV;
968 if( et < info.etthr-5.0) continue;
969 pair_eg_vec.emplace_back(eg,feat);
970 if(l1) pair_l1_vec.emplace_back(eg,l1 );
971 }
972 }
973
974 }
975
976 // Fill L1Calo for all level 1 objects found
977 fillL1CaloResolution( trigger, pair_l1_vec );
978 fillL1CaloAbsResolution( trigger, pair_l1_vec );
979 fillL2CaloResolution( trigger, pair_eg_vec );
980
981 // Fill HLT electron for all onl objects found
982 if ( info.signature=="Electron"){
983 fillHLTElectronResolution( ctx, trigger, pair_eg_vec, info );
984 }
985 else if ( info.signature=="Photon"){
986 fillHLTPhotonResolution( ctx, trigger, pair_eg_vec, info );
987 }
988
989}
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:1430
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:1052
TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloAbsResolution
void fillL1CaloAbsResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1024
TrigEgammaMonitorAnalysisAlgorithm::fillL2CaloResolution
void fillL2CaloResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:1735
TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloResolution
void fillL1CaloResolution(const std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const xAOD::EmTauRoI * > > &pairObjs) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:994
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
privateinherited

Definition at line 768 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

769{
770
771 ATH_MSG_DEBUG("Fill SS distributions: " << trigger);
772 auto monGroup = getGroup( trigger + ( online ? "_Distributions_HLT" : "_Distributions_Offline") );
773
774 std::vector<float> Rhad_vec, Rhad1_vec, Reta_vec, Rphi_vec, weta1_vec, weta2_vec,
775 f1_vec, f3_vec, eratio_vec, et_vec, highet_vec , eta_vec, phi_vec, topoetcone20_vec, topoetcone40_shift_vec,
776 topoetcone20_rel_vec, topoetcone40_shift_rel_vec;
777
778
779 auto Rhad_col = Monitored::Collection("Rhad" , Rhad_vec );
780 auto Rhad1_col = Monitored::Collection("Rhad1" , Rhad1_vec );
781 auto Reta_col = Monitored::Collection("Reta" , Reta_vec );
782 auto Rphi_col = Monitored::Collection("Rphi" , Rphi_vec );
783 auto weta1_col = Monitored::Collection("weta1" , weta1_vec );
784 auto weta2_col = Monitored::Collection("weta2" , weta2_vec );
785 auto f1_col = Monitored::Collection("f1" , f1_vec );
786 auto f3_col = Monitored::Collection("f3" , f3_vec );
787 auto eratio_col = Monitored::Collection("eratio" , eratio_vec );
788 auto et_col = Monitored::Collection("et" , et_vec );
789 auto highet_col = Monitored::Collection("highet" , highet_vec );
790 auto eta_col = Monitored::Collection("eta" , eta_vec );
791 auto phi_col = Monitored::Collection("phi" , phi_vec );
792 auto topoetcone20_col = Monitored::Collection("topoetcone20", topoetcone20_vec);
793 auto topoetcone40_shift_col = Monitored::Collection("topoetcone40_shift", topoetcone40_shift_vec );
794 auto topoetcone20_rel_col = Monitored::Collection("topoetcone20_rel", topoetcone20_rel_vec);
795 auto topoetcone40_shift_rel_col = Monitored::Collection("topoetcone40_shift_rel", topoetcone40_shift_rel_vec );
796
797 for ( const auto *eg : eg_vec ){
798
799 if(!eg) continue;
800
801 Rhad_vec.push_back( getShowerShape_Rhad(eg));
802 Rhad1_vec.push_back( getShowerShape_Rhad(eg));
803 Reta_vec.push_back( getShowerShape_Reta(eg));
804 Rphi_vec.push_back( getShowerShape_Rphi(eg));
805 weta1_vec.push_back( getShowerShape_weta1(eg));
806 weta2_vec.push_back( getShowerShape_weta2(eg));
807 f1_vec.push_back( getShowerShape_f1(eg));
808 f3_vec.push_back( getShowerShape_f3(eg));
809 eratio_vec.push_back( getShowerShape_Eratio(eg));
810 et_vec.push_back( eg->pt()/Gaudi::Units::GeV);
811 highet_vec.push_back( eg->pt()/Gaudi::Units::GeV);
812 eta_vec.push_back( eg->eta());
813 phi_vec.push_back( eg->phi());
814 topoetcone20_vec.push_back( getIsolation_topoetcone20(eg)/Gaudi::Units::GeV);
815 topoetcone40_shift_vec.push_back( (getIsolation_topoetcone40(eg)-2450)/Gaudi::Units::GeV );
816
817 if (eg->pt() > 0) {
818 topoetcone20_rel_vec.push_back( getIsolation_topoetcone20(eg)/eg->pt());
819 topoetcone40_shift_rel_vec.push_back( (getIsolation_topoetcone40(eg)-2450)/eg->pt() );
820 }
821
822 }// Loop over egamma objects
823
824 fill( monGroup, Rhad_col, Rhad1_col, Reta_col, Rphi_col, weta1_col, weta2_col,
825 f1_col, f3_col, eratio_col, et_col, highet_col , eta_col, phi_col, topoetcone20_col, topoetcone40_shift_col,
826 topoetcone20_rel_col, topoetcone40_shift_rel_col );
827
828}

◆ fillTracking()

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

Definition at line 831 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ filterPassed()

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

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

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

◆ getD0sig()

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

Definition at line 386 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getDEmaxs1()

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

Definition at line 336 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getE0Eaccordion()

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

Definition at line 452 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEaccordion()

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

Definition at line 440 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE0()

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

Definition at line 404 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE1()

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

Definition at line 413 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE2()

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

Definition at line 422 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE3()

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

Definition at line 431 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEt()

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

Definition at line 315 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEta2()

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

Features helper.

Helper functions now part of base class

Definition at line 306 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEtCluster37()

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

Definition at line 326 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ GetEventInfo()

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

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

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

Definition at line 111 of file AthMonitorAlgorithm.cxx.

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

◆ getGroup()

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

Get a specific monitoring tool from the tool handle array.

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

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

Definition at line 168 of file AthMonitorAlgorithm.cxx.

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

◆ getL1Item()

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

Creates static map to return L1 item from trigger name.

Definition at line 752 of file TrigEgammaMonitorBaseAlgorithm.cxx.

752 {
753 std::vector<std::string> parts;
754 boost::split(parts,trigger,boost::is_any_of("_"));
755 // L1EMXX
756 std::string l1seed = parts.back();
757 return l1seed;
758}

◆ getSigmaD0()

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

Definition at line 370 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getTrigDecisionTool()

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

Get the trigger decision tool member.

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

Returns
m_trigDecTool

Definition at line 203 of file AthMonitorAlgorithm.cxx.

203 {
204 return m_trigDecTool;
205}

◆ getTrigInfo()

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

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

Definition at line 607 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getTrigInfoMap()

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

Helper methods.

Get the trig info map

Definition at line 130 of file TrigEgammaMonitorBaseAlgorithm.h.

130{ return m_trigInfo; }

◆ initialize()

StatusCode TrigEgammaMonitorElectronAlgorithm::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from TrigEgammaMonitorAnalysisAlgorithm.

Definition at line 22 of file TrigEgammaMonitorElectronAlgorithm.cxx.

23{
24 ATH_CHECK(TrigEgammaMonitorAnalysisAlgorithm::initialize());
25
26 ATH_CHECK(m_offElectronKey.initialize());
27 ATH_CHECK(m_electronIsolationKeyPtCone20.initialize());
28 ATH_CHECK( m_eventInfoDecorKey.initialize() );
29
30 for(auto& trigName : m_trigInputList)
31 {
32 if(getTrigInfoMap().count(trigName) != 0){
33 ATH_MSG_DEBUG("Trigger already booked, removing from trigger list " << trigName);
34 }else {
35 m_trigList.push_back(trigName);
36 setTrigInfo(trigName);
37 }
38 }
39
40
41 return StatusCode::SUCCESS;
42}
TrigEgammaMonitorAnalysisAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:17
TrigEgammaMonitorBaseAlgorithm::getTrigInfoMap
const std::map< std::string, TrigInfo > & getTrigInfoMap()
Helper methods.
Definition TrigEgammaMonitorBaseAlgorithm.h:130
TrigEgammaMonitorBaseAlgorithm::setTrigInfo
void setTrigInfo(const std::string &)
Set the trigger info parsed from the chain name.
Definition TrigEgammaMonitorBaseAlgorithm.cxx:615
TrigEgammaMonitorElectronAlgorithm::m_electronIsolationKeyPtCone20
SG::ReadDecorHandleKey< xAOD::ElectronContainer > m_electronIsolationKeyPtCone20
Ensure offline electron isolation decoration is retrieved after being created.
Definition TrigEgammaMonitorElectronAlgorithm.h:60
TrigEgammaMonitorElectronAlgorithm::m_eventInfoDecorKey
SG::ReadDecorHandleKey< xAOD::EventInfo > m_eventInfoDecorKey
Definition TrigEgammaMonitorElectronAlgorithm.h:58
TrigEgammaMonitorElectronAlgorithm::m_trigInputList
Gaudi::Property< std::vector< std::string > > m_trigInputList
List of triggers from menu.
Definition TrigEgammaMonitorElectronAlgorithm.h:41
count
int count(std::string s, const std::string &regx)
count how many occurances of a regx are in a string
Definition hcg.cxx:148

◆ inputHandles()

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

Return this algorithm's input handles.

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

◆ isClonable()

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

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

◆ isHLTTruncated()

bool TrigEgammaMonitorBaseAlgorithm::isHLTTruncated ( ) const
protectedinherited

Definition at line 761 of file TrigEgammaMonitorBaseAlgorithm.cxx.

761 {
762 return m_trigdec->ExperimentalAndExpertMethods().isHLTTruncated();
763}
TrigEgammaMonitorBaseAlgorithm::m_trigdec
ToolHandle< Trig::TrigDecisionTool > m_trigdec
Trigger decision tool.
Definition TrigEgammaMonitorBaseAlgorithm.h:82

◆ isIsolated()

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

Check if electron fulfils isolation criteria.

Definition at line 116 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ isPrescaled()

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

Check if the event is prescaled.

Definition at line 148 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ match()

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

Get the e/g match tool.

Definition at line 138 of file TrigEgammaMonitorBaseAlgorithm.h.

138{return m_matchTool;}
TrigEgammaMonitorBaseAlgorithm::m_matchTool
ToolHandle< TrigEgammaMatchingToolMT > m_matchTool
Definition TrigEgammaMonitorBaseAlgorithm.h:90

◆ 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
get_generator_info.result
result
Definition get_generator_info.py:21

◆ renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounce ( T & h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381 {
382 h.renounce();
383 PBASE::renounce (h);
384 }
AthCommonDataStore::renounce
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce(T &h)
Definition AthCommonDataStore.h:380

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::renounceArray ( SG::VarHandleKeyArray & handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364 {
365 handlesArray.renounce();
366 }

◆ rTRT()

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

Definition at line 353 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ setAccept()

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

Set the accept object for all trigger levels.

Definition at line 181 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ setFilterPassed()

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

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ setTrigInfo()

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

Set the trigger info parsed from the chain name.

Definition at line 615 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ sysExecute()

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

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysInitialize()

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

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ tdt()

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

Get the TDT.

Definition at line 136 of file TrigEgammaMonitorBaseAlgorithm.h.

136{return m_trigdec;};

◆ trigChainsArePassed()

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

Check whether triggers are passed.

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

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

Definition at line 208 of file AthMonitorAlgorithm.cxx.

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

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase & )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
312 std::vector<SG::VarHandleKey*> keys = a->keys();
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }

Member Data Documentation

◆ m_accept

asg::AcceptInfo TrigEgammaMonitorBaseAlgorithm::m_accept
protectedinherited

Definition at line 125 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_anatype

Gaudi::Property<std::string> TrigEgammaMonitorElectronAlgorithm::m_anatype {this, "Analysis", "Electron"}
private

Directory name for each algorithm.

Definition at line 43 of file TrigEgammaMonitorElectronAlgorithm.h.

43{this, "Analysis", "Electron"};

◆ m_dataType

AthMonitorAlgorithm::DataType_t AthMonitorAlgorithm::m_dataType
protectedinherited

Instance of the DataType_t enum.

Definition at line 356 of file AthMonitorAlgorithm.h.

◆ m_dataTypeStr

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

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

Definition at line 358 of file AthMonitorAlgorithm.h.

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

◆ m_defaultLBDuration

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

Default duration of one lumi block.

Definition at line 365 of file AthMonitorAlgorithm.h.

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

◆ m_defaultProbePidElectron

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

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

Definition at line 112 of file TrigEgammaMonitorBaseAlgorithm.h.

112{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 114 of file TrigEgammaMonitorBaseAlgorithm.h.

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

◆ m_detailedHists

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

Include more detailed histograms.

Definition at line 122 of file TrigEgammaMonitorBaseAlgorithm.h.

122{this, "DetailedHistograms", false};

◆ m_detailLevel

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

Sets the level of detail used in the monitoring.

Definition at line 366 of file AthMonitorAlgorithm.h.

366{this,"DetailLevel",0};

◆ m_detStore

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

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

◆ m_dnnname

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

dnn names

Definition at line 120 of file TrigEgammaMonitorBaseAlgorithm.h.

120{this, "DNNResultNames", {}, };

◆ m_doEffwithDNN

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

Definition at line 107 of file TrigEgammaMonitorBaseAlgorithm.h.

107{this, "ComputeEffDNN", false};

◆ m_doEffwithLH

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

Definition at line 106 of file TrigEgammaMonitorBaseAlgorithm.h.

106{this, "ComputeEffLH", false};

◆ m_doEmulation

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

Do emulation.

Definition at line 104 of file TrigEgammaMonitorBaseAlgorithm.h.

104{this, "DoEmulation", false };

◆ m_DQFilterTools

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

Array of Data Quality filter tools.

Definition at line 346 of file AthMonitorAlgorithm.h.

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

◆ m_dummy

const ToolHandle<GenericMonitoringTool> AthMonitorAlgorithm::m_dummy
privateinherited

Definition at line 374 of file AthMonitorAlgorithm.h.

◆ m_electronDNNTool

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

Offline DNN Selectors.

Definition at line 98 of file TrigEgammaMonitorBaseAlgorithm.h.

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

◆ m_electronIsEMTool

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

Offline isEM Selectors.

Definition at line 94 of file TrigEgammaMonitorBaseAlgorithm.h.

94{this,"ElectronIsEMSelector",{}};

◆ m_electronIsolationKeyPtCone20

SG::ReadDecorHandleKey<xAOD::ElectronContainer> TrigEgammaMonitorElectronAlgorithm::m_electronIsolationKeyPtCone20 { this, "PtCone20Decoration", m_offElectronKey, "ptcone20", "Decoration key for the ptcone20 isolation decoration" }
private

Ensure offline electron isolation decoration is retrieved after being created.

Definition at line 60 of file TrigEgammaMonitorElectronAlgorithm.h.

60{ this, "PtCone20Decoration", m_offElectronKey, "ptcone20", "Decoration key for the ptcone20 isolation decoration" };

◆ m_electronLHTool

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

Offline LH Selectors.

Definition at line 96 of file TrigEgammaMonitorBaseAlgorithm.h.

96{this,"ElectronLikelihoodTool",{}};

◆ m_emulatorTool

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

Definition at line 92 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_enforceExpressTriggers

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

Definition at line 377 of file AthMonitorAlgorithm.h.

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

◆ m_environment

AthMonitorAlgorithm::Environment_t AthMonitorAlgorithm::m_environment
protectedinherited

Instance of the Environment_t enum.

Definition at line 355 of file AthMonitorAlgorithm.h.

◆ m_environmentStr

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

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

Definition at line 357 of file AthMonitorAlgorithm.h.

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

◆ m_eventInfoDecorKey

SG::ReadDecorHandleKey<xAOD::EventInfo> TrigEgammaMonitorElectronAlgorithm::m_eventInfoDecorKey {this, "LArStatusFlag", "EventInfo.larFlags", "Key for EventInfo object"}
private

Definition at line 58 of file TrigEgammaMonitorElectronAlgorithm.h.

58{this, "LArStatusFlag", "EventInfo.larFlags", "Key for EventInfo object"}; //To get data-dependencies right

◆ m_EventInfoKey

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

Key for retrieving EventInfo from StoreGate.

Definition at line 367 of file AthMonitorAlgorithm.h.

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

◆ m_evtStore

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

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

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

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_fileKey

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

Internal Athena name for file.

Definition at line 363 of file AthMonitorAlgorithm.h.

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

◆ m_forceEtThr

Gaudi::Property<bool> TrigEgammaMonitorElectronAlgorithm::m_forceEtThr { this, "ForceEtThreshold", true}
private

Definition at line 51 of file TrigEgammaMonitorElectronAlgorithm.h.

51{ this, "ForceEtThreshold", true};

◆ m_forcePidSelection

Gaudi::Property<bool> TrigEgammaMonitorElectronAlgorithm::m_forcePidSelection { this, "ForcePidSelection", true}
private

force pid and crack selection into electron navigation

Definition at line 49 of file TrigEgammaMonitorElectronAlgorithm.h.

49{ this, "ForcePidSelection", true};

◆ m_forceProbeIsolation

Gaudi::Property<bool> TrigEgammaMonitorElectronAlgorithm::m_forceProbeIsolation {this, "ForceProbeIsolation", false}
private

force probe isolation

Definition at line 47 of file TrigEgammaMonitorElectronAlgorithm.h.

47{this, "ForceProbeIsolation", false};

◆ m_forceVetoVeryLoose

Gaudi::Property<bool> TrigEgammaMonitorElectronAlgorithm::m_forceVetoVeryLoose { this, "ForceVetoVeryLoose", false}
private

Definition at line 53 of file TrigEgammaMonitorElectronAlgorithm.h.

53{ this, "ForceVetoVeryLoose", false};

◆ m_isemname

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

isem names

Definition at line 116 of file TrigEgammaMonitorBaseAlgorithm.h.

116{this, "isEMResultNames", {} };

◆ m_lbDurationDataKey

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

Definition at line 350 of file AthMonitorAlgorithm.h.

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

◆ m_lhname

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

lh names

Definition at line 118 of file TrigEgammaMonitorBaseAlgorithm.h.

118{this, "LHResultNames", {} };

◆ m_lumiDataKey

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

Definition at line 348 of file AthMonitorAlgorithm.h.

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

◆ m_matchTool

ToolHandle<TrigEgammaMatchingToolMT> TrigEgammaMonitorBaseAlgorithm::m_matchTool
protectedinherited

Definition at line 90 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_name

std::string AthMonitorAlgorithm::m_name
privateinherited

Definition at line 371 of file AthMonitorAlgorithm.h.

◆ m_offElectronKey

SG::ReadHandleKey<xAOD::ElectronContainer> TrigEgammaMonitorElectronAlgorithm::m_offElectronKey { this, "ElectronKey", "Electrons", ""}
private

Event Wise offline ElectronContainer Access and end iterator.

Definition at line 57 of file TrigEgammaMonitorElectronAlgorithm.h.

57{ this, "ElectronKey", "Electrons", ""};

◆ m_offProbeIsolation

Gaudi::Property<std::string> TrigEgammaMonitorElectronAlgorithm::m_offProbeIsolation { this, "OfflineProbeIsolation", "Loose"}
private

Define isolation working point for Probe electron.

Definition at line 45 of file TrigEgammaMonitorElectronAlgorithm.h.

45{ this, "OfflineProbeIsolation", "Loose"};

◆ m_photonIsEMTool

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

Offline isEM Photon Selectors.

Definition at line 100 of file TrigEgammaMonitorBaseAlgorithm.h.

100{this,"PhotonIsEMSelector",{}};

◆ m_rmCrack

Gaudi::Property<bool> TrigEgammaMonitorElectronAlgorithm::m_rmCrack { this, "RemoveCrack", true}
private

Remove crack region for Probe default True.

Definition at line 55 of file TrigEgammaMonitorElectronAlgorithm.h.

55{ this, "RemoveCrack", true};

◆ m_toolLookupMap

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

Definition at line 372 of file AthMonitorAlgorithm.h.

◆ m_tools

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

Array of Generic Monitoring Tools.

Definition at line 341 of file AthMonitorAlgorithm.h.

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

◆ m_tp

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

TP Trigger Analysis.

Definition at line 110 of file TrigEgammaMonitorBaseAlgorithm.h.

110{this, "TPTrigger", false };

◆ m_trigdec

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

Trigger decision tool.

Definition at line 82 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_trigDecTool

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

Tool to tell whether a specific trigger is passed.

Definition at line 345 of file AthMonitorAlgorithm.h.

◆ m_triggerChainString

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

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

Definition at line 360 of file AthMonitorAlgorithm.h.

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

◆ m_trigInfo

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

creates map of trigger name and TrigInfo struct

Definition at line 84 of file TrigEgammaMonitorBaseAlgorithm.h.

◆ m_trigInputList

Gaudi::Property<std::vector<std::string> > TrigEgammaMonitorElectronAlgorithm::m_trigInputList {this, "TriggerList", {}}
private

List of triggers from menu.

Definition at line 41 of file TrigEgammaMonitorElectronAlgorithm.h.

41{this, "TriggerList", {}};

◆ m_trigList

std::vector<std::string> TrigEgammaMonitorElectronAlgorithm::m_trigList
private

List of triggers to study.

Definition at line 39 of file TrigEgammaMonitorElectronAlgorithm.h.

◆ m_trigLiveFractionDataKey

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

Definition at line 352 of file AthMonitorAlgorithm.h.

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

◆ m_useLumi

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

Allows use of various luminosity functions.

Definition at line 364 of file AthMonitorAlgorithm.h.

364{this,"EnableLumi",false};

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

◆ m_vTrigChainNames

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

Vector of trigger chain names parsed from trigger chain string.

Definition at line 361 of file AthMonitorAlgorithm.h.

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