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

#include <TrigEgammaMonitorPhotonAlgorithm.h>

Inheritance diagram for TrigEgammaMonitorPhotonAlgorithm:
Collaboration diagram for TrigEgammaMonitorPhotonAlgorithm:

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

 TrigEgammaMonitorPhotonAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
virtual ~TrigEgammaMonitorPhotonAlgorithm () 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=Gaudi::Hive::currentContext()) const
 Calculate the average mu, i.e.
virtual float lbInteractionsPerCrossing (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate instantaneous number of interactions, i.e.
virtual float lbAverageLuminosity (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate average luminosity (in ub-1 s-1 => 10^30 cm-2 s-1).
virtual float lbLuminosityPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the instantaneous luminosity per bunch crossing.
virtual double lbDuration (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the duration of the luminosity block (in seconds)
virtual float lbAverageLivefraction (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the average luminosity livefraction.
virtual float livefractionPerBCID (const EventContext &ctx=Gaudi::Hive::currentContext()) const
 Calculate the live fraction per bunch crossing ID.
virtual double lbLumiWeight (const EventContext &ctx=Gaudi::Hive::currentContext()) 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 std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &, const bool) const
void fillDistributions (const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &) const
void fillResolutions (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 xAOD::Electron *eg, const std::string &) const
 Get offline electron decision.
bool ApplyPhotonPid (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 TrigInfo &info, std::vector< std::pair< std::shared_ptr< const xAOD::Egamma >, const TrigCompositeUtils::Decision * > > &) const
 navigation method called by executeNavigation
void fillEfficiency (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 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 std::string &trigger, const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
void fillHLTPhotonResolution (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::string > m_photonPid {this, "PhotonPid","Tight" }
 Photon pid word.
Gaudi::Property< bool > m_doUnconverted {this, "DoUnconverted", false}
 doUnconverted analysis
Gaudi::Property< std::vector< std::string > > m_trigInputList {this, "TriggerList", {}}
 List of triggers from menu.
Gaudi::Property< std::map< std::string, std::string > > m_BSTrigMap {this, "BootstrapTriggerMap", {{"",""}}, "Dictionary of Triggers (as keys) and Bootstraps (value) to configure Bootstrapping of photon triggers" }
Gaudi::Property< std::string > m_anatype {this, "Analysis", "Photon"}
 Directory name for each algorithm.
Gaudi::Property< bool > m_forcePidSelection { this, "ForcePidSelection", true}
 force pid selection into photon navigation
Gaudi::Property< bool > m_onlyHLT { this, "OnlyHLT", false}
 Compute only final HLT decision.
SG::ReadHandleKey< xAOD::PhotonContainer > m_offPhotonKey { this, "PhotonKey", "Photons", ""}
 Event Wise offline PhotonContainer Access and end iterator.
SG::ReadDecorHandleKeyArray< xAOD::PhotonContainer > m_offPhotonIsolationKeys {this, "PhotonIsolationKeys", {"Photons.topoetcone20", "Photons.topoetcone40"} }
 Ensure offline photon isolation decoration is retrieved after being created.
SG::ReadDecorHandleKey< xAOD::EventInfo > m_eventInfoDecorKey {this, "LArStatusFlag", "EventInfo.larFlags", "Key for EventInfo object"}
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 TrigEgammaMonitorPhotonAlgorithm.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:561

◆ 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

◆ TrigEgammaMonitorPhotonAlgorithm()

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

Definition at line 14 of file TrigEgammaMonitorPhotonAlgorithm.cxx.

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

◆ ~TrigEgammaMonitorPhotonAlgorithm()

TrigEgammaMonitorPhotonAlgorithm::~TrigEgammaMonitorPhotonAlgorithm ( )
overridevirtual

Definition at line 19 of file TrigEgammaMonitorPhotonAlgorithm.cxx.

20{}

Member Function Documentation

◆ ApplyElectronPid()

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

Get offline electron decision.

Definition at line 49 of file TrigEgammaMonitorBaseAlgorithm.cxx.

50{
51 const auto& ctx = Gaudi::Hive::currentContext() ;
52 if (pidname == "tight"){
53 return (bool) this->m_electronIsEMTool[0]->accept(ctx,eg);
54 }
55 else if (pidname == "medium"){
56 return (bool) this->m_electronIsEMTool[1]->accept(ctx,eg);
57 }
58 else if (pidname == "loose"){
59 return (bool) this->m_electronIsEMTool[2]->accept(ctx,eg);
60 }
61 else if (pidname == "lhtight"){
62 if (!m_doEffwithDNN) return (bool) this->m_electronLHTool[0]->accept(ctx,eg);
63 else return (bool) this->m_electronDNNTool[0]->accept(ctx,eg);
64 }
65 else if (pidname == "lhmedium"){
66 if (!m_doEffwithDNN) return (bool) this->m_electronLHTool[1]->accept(ctx,eg);
67 else return (bool) this->m_electronDNNTool[1]->accept(ctx,eg);
68 }
69 else if (pidname == "lhloose"){
70 if (!m_doEffwithDNN) return (bool) this->m_electronLHTool[2]->accept(ctx,eg);
71 else return (bool) this->m_electronDNNTool[2]->accept(ctx,eg);
72 }
73 else if (pidname == "lhvloose"){
74 return (bool) this->m_electronLHTool[3]->accept(ctx,eg);
75 }
76 else if (pidname == "dnntight"){
77 if (!m_doEffwithLH) return (bool) this->m_electronDNNTool[0]->accept(ctx,eg);
78 else return (bool) this->m_electronLHTool[0]->accept(ctx,eg);
79 }
80 else if (pidname == "dnnmedium"){
81 if (!m_doEffwithLH) return (bool) this->m_electronDNNTool[1]->accept(ctx,eg);
82 else return (bool) this->m_electronLHTool[1]->accept(ctx,eg);
83 }
84 else if (pidname == "dnnloose"){
85 if (!m_doEffwithLH) return (bool) this->m_electronDNNTool[2]->accept(ctx,eg);
86 else return (bool) this->m_electronLHTool[2]->accept(ctx,eg);
87 }
88 else ATH_MSG_DEBUG("No Pid tool, continue without PID");
89 return false;
90}
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 xAOD::Photon * eg,
const std::string & pidname ) const
protectedinherited

Get offline electron decision.

Definition at line 97 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

64{
65 return 0;
66}

◆ dataType()

DataType_t AthMonitorAlgorithm::dataType ( ) const
inlineinherited

Accessor functions for the data type.

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

Definition at line 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 298 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ environment()

Environment_t AthMonitorAlgorithm::environment ( ) const
inlineinherited

Accessor functions for the environment.

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

Definition at line 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()) {
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:203
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 TrigEgammaMonitorPhotonAlgorithm::executeNavigation ( const EventContext & ctx,
const TrigInfo & info,
std::vector< std::pair< std::shared_ptr< const xAOD::Egamma >, const TrigCompositeUtils::Decision * > > & pairObjs ) const
private

navigation method called by executeNavigation

default is true

Definition at line 122 of file TrigEgammaMonitorPhotonAlgorithm.cxx.

125{
126 ATH_MSG_DEBUG("Apply navigation selection for Photons");
127
128 SG::ReadHandle<xAOD::PhotonContainer> offPhotons(m_offPhotonKey, ctx);
129
130 if(!offPhotons.isValid())
131 {
132 ATH_MSG_DEBUG("Failed to retrieve offline photons ");
133 return StatusCode::FAILURE;
134 }
135 const std::string trigItem = info.trigger;
136 const float etthr = info.etthr;
137 const std::string pidName = info.pidname;
138 const std::string decorName="is"+pidName;
139
140 for(const auto *const eg : *offPhotons ){
141 const TrigCompositeUtils::Decision *dec=nullptr;
142 if(!eg->caloCluster()){
143 ATH_MSG_DEBUG("No caloCluster");
144 continue;
145 }
146 if( !(getCluster_et(eg) > (etthr-5.)*Gaudi::Units::GeV)) continue; //Take 5 GeV below threshold
147 if(!info.etcut){
148 if(!eg->passSelection(m_photonPid)) {
149 ATH_MSG_DEBUG("Fails PhotonID: " << m_photonPid);
150 continue; // reject offline photons reproved by tight requiriment
151 }
152 }
153 if(m_forcePidSelection){
154 if(!ApplyPhotonPid(eg,pidName)){
155 ATH_MSG_DEBUG("Fails PhotonID: "<< pidName << " Trigger: " << trigItem);
156 continue;
157 }
158 ATH_MSG_DEBUG("Passes PhotonID "<< pidName);
159 }
160 // default is false: if true, skip converted photons
161 if(m_doUnconverted){
162 if (eg->vertex()){
163 ATH_MSG_DEBUG("Removing converted photons, continuing...");
164 continue;
165 }
166 }
167 const auto ph = std::make_shared<const xAOD::Photon>(*eg);
168 SG::Decorator<bool> decor (decorName);
169 decor(*ph)=static_cast<bool>(true);
170 match()->match(ph.get(), trigItem, dec, TrigDefs::includeFailedDecisions);
171 //match()->match(ph, trigItem, dec);
172 pairObjs.emplace_back(ph, dec);
173 // }
174
175 }
176
177 ATH_MSG_DEBUG("BaseToolMT::Photon TEs " << pairObjs.size() << " found.");
178 return StatusCode::SUCCESS;
179}
TrigEgammaMonitorBaseAlgorithm::ApplyPhotonPid
bool ApplyPhotonPid(const xAOD::Photon *eg, const std::string &) const
Get offline electron decision.
Definition TrigEgammaMonitorBaseAlgorithm.cxx:97
TrigEgammaMonitorBaseAlgorithm::match
const ToolHandle< TrigEgammaMatchingToolMT > & match() const
Get the e/g match tool.
Definition TrigEgammaMonitorBaseAlgorithm.h:138
TrigEgammaMonitorPhotonAlgorithm::m_forcePidSelection
Gaudi::Property< bool > m_forcePidSelection
force pid selection into photon navigation
Definition TrigEgammaMonitorPhotonAlgorithm.h:51
TrigEgammaMonitorPhotonAlgorithm::m_doUnconverted
Gaudi::Property< bool > m_doUnconverted
doUnconverted analysis
Definition TrigEgammaMonitorPhotonAlgorithm.h:41
TrigEgammaMonitorPhotonAlgorithm::m_photonPid
Gaudi::Property< std::string > m_photonPid
Photon pid word.
Definition TrigEgammaMonitorPhotonAlgorithm.h:39
TrigEgammaMonitorPhotonAlgorithm::m_offPhotonKey
SG::ReadHandleKey< xAOD::PhotonContainer > m_offPhotonKey
Event Wise offline PhotonContainer Access and end iterator.
Definition TrigEgammaMonitorPhotonAlgorithm.h:57
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.

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

◆ fillDistributions()

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

Definition at line 420 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

712{
713
714 auto monGroup = getGroup( trigger + "_Distributions_EFCalo" );
715
716
717 std::vector<float> energyBE0_vec, energyBE1_vec, energyBE2_vec, energyBE3_vec,
718 energy_vec, et_vec, eta_vec, phi_vec, eta_calo_vec, phi_calo_vec, highet_vec;
719
720
721
722 auto energyBE0_col = Monitored::Collection("energyBE0", energyBE0_vec);
723 auto energyBE1_col = Monitored::Collection("energyBE1", energyBE1_vec);
724 auto energyBE2_col = Monitored::Collection("energyBE2", energyBE2_vec);
725 auto energyBE3_col = Monitored::Collection("energyBE3", energyBE3_vec);
726 auto energy_col = Monitored::Collection("energy" , energy_vec );
727 auto et_col = Monitored::Collection("et" , et_vec );
728 auto highet_col = Monitored::Collection("highet" , highet_vec );
729 auto eta_col = Monitored::Collection("eta" , eta_vec );
730 auto phi_col = Monitored::Collection("phi" , phi_vec );
731 auto eta_calo_col = Monitored::Collection("eta_calo" , eta_calo_vec );
732 auto phi_calo_col = Monitored::Collection("phi_calo" , phi_calo_vec );
733
734 for ( const auto *clus : clus_vec )
735 {
736 double tmpeta = -999.;
737 if(!clus->retrieveMoment(xAOD::CaloCluster::ETACALOFRAME,tmpeta))
738 tmpeta=-999.;
739 double tmpphi = -999.;
740 if(!clus->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi))
741 tmpphi=-999.;
742
743 energyBE0_vec.push_back( clus->energyBE(0)/Gaudi::Units::GeV );
744 energyBE1_vec.push_back( clus->energyBE(1)/Gaudi::Units::GeV );
745 energyBE2_vec.push_back( clus->energyBE(2)/Gaudi::Units::GeV );
746 energyBE3_vec.push_back( clus->energyBE(3)/Gaudi::Units::GeV );
747 energy_vec.push_back( clus->e()/Gaudi::Units::GeV );
748 et_vec.push_back( clus->et()/Gaudi::Units::GeV );
749 highet_vec.push_back( clus->et()/Gaudi::Units::GeV );
750 eta_vec.push_back( clus->eta() );
751 phi_vec.push_back( clus->phi() );
752 eta_calo_vec.push_back( tmpeta );
753 phi_calo_vec.push_back( tmpphi );
754
755 }
756
757
758 fill( monGroup, energyBE0_col, energyBE1_col, energyBE2_col, energyBE3_col,
759 energy_col, et_col, eta_col, phi_col, eta_calo_col, phi_calo_col, highet_col);
760}
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 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.

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

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

◆ fillHistograms()

StatusCode TrigEgammaMonitorPhotonAlgorithm::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 47 of file TrigEgammaMonitorPhotonAlgorithm.cxx.

48{
49 ATH_MSG_DEBUG("Executing TrigEgammaMonitorPhotonAlgorithm");
50
51
52 if(isHLTTruncated()){
53 ATH_MSG_DEBUG("HLTResult truncated, skip trigger analysis");
54 return StatusCode::SUCCESS;
55 }
56
57 // Noise burst protection
58 SG::ReadHandle<xAOD::EventInfo> thisEvent(GetEventInfo(ctx));
59 ATH_CHECK(thisEvent.isValid());
60 if ( thisEvent->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO)) {
61 ATH_MSG_DEBUG("LAr Noise Burst Veto, skip trigger analysis");
62 return StatusCode::SUCCESS;
63 }
64
65 ATH_MSG_DEBUG("Chains for Analysis " << m_trigList);
66
67 for(const auto& trigger : m_trigList){
68
69 const TrigInfo info = getTrigInfo(trigger);
70 ATH_MSG_DEBUG("Start Chain Analysis ============================= " << trigger << " " << info.trigger);
71
72 // Check if this trigger is in the bootstrap map
73 auto it = m_BSTrigMap.find(trigger);
74
75 if ( it != m_BSTrigMap.end() ) {
76
77 ATH_MSG_DEBUG( trigger << " is a bootstrapped trigger");
78
79 std::string bootstrap = it->second;
80 ATH_MSG_DEBUG( "Bootstrapping " << trigger << " from " << bootstrap );
81
82
83 if (!tdt()->isPassed(bootstrap)){
84 ATH_MSG_DEBUG("Not passed BS trigger. Skipping! ========================== " << trigger);
85 continue;
86 } else {
87 ATH_MSG_DEBUG("BS trigger passed!");
88 }
89
90 }
91
92 std::vector< std::pair<std::shared_ptr<const xAOD::Egamma>, const TrigCompositeUtils::Decision * >> pairObjs;
93
94 if ( executeNavigation( ctx,info,pairObjs).isFailure() )
95 {
96 ATH_MSG_DEBUG("executeNavigation Fails");
97 return StatusCode::SUCCESS;
98 }
99
100 std::vector< std::pair<const xAOD::Egamma*, const TrigCompositeUtils::Decision*>> pairObjsRaw;
101 pairObjsRaw.reserve(pairObjs.size());
102 for (const auto& itr : pairObjs) {
103 pairObjsRaw.emplace_back(itr.first.get(), itr.second);
104 }
105
106 fillDistributions( pairObjsRaw, info );
107 fillEfficiencies( pairObjsRaw, info, m_onlyHLT );
108 fillResolutions( pairObjsRaw, info );
109
110
111 ATH_MSG_DEBUG("End Chain Analysis ============================= " << trigger);
112 } // End loop over trigger list
113
114
115 return StatusCode::SUCCESS;
116}
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 std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &, const bool) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:42
TrigEgammaMonitorAnalysisAlgorithm::fillResolutions
void fillResolutions(const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &pairObjs, const TrigInfo &info) const
*****************************************************************************************************...
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:935
TrigEgammaMonitorAnalysisAlgorithm::fillDistributions
void fillDistributions(const std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > &, const TrigInfo &) const
Definition TrigEgammaMonitorAnalysisAlgorithm.cxx:420
TrigEgammaMonitorBaseAlgorithm::getTrigInfo
TrigInfo getTrigInfo(const std::string &) const
Get the trigger info parsed from the chain name (only single lepton triggers)
Definition TrigEgammaMonitorBaseAlgorithm.cxx:609
TrigEgammaMonitorPhotonAlgorithm::executeNavigation
StatusCode executeNavigation(const EventContext &ctx, const TrigInfo &info, std::vector< std::pair< std::shared_ptr< const xAOD::Egamma >, const TrigCompositeUtils::Decision * > > &) const
navigation method called by executeNavigation
Definition TrigEgammaMonitorPhotonAlgorithm.cxx:122
TrigEgammaMonitorPhotonAlgorithm::m_BSTrigMap
Gaudi::Property< std::map< std::string, std::string > > m_BSTrigMap
Definition TrigEgammaMonitorPhotonAlgorithm.h:47
TrigEgammaMonitorPhotonAlgorithm::m_trigList
std::vector< std::string > m_trigList
List of triggers to study.
Definition TrigEgammaMonitorPhotonAlgorithm.h:37
TrigEgammaMonitorPhotonAlgorithm::m_onlyHLT
Gaudi::Property< bool > m_onlyHLT
Compute only final HLT decision.
Definition TrigEgammaMonitorPhotonAlgorithm.h:53
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition EventInfo_v1.h:335

◆ fillHLTElectronResolution()

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

Definition at line 1049 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillHLTPhotonResolution()

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

Definition at line 1427 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

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

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

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

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

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

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

◆ fillL1eEM()

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

Definition at line 604 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillL2Calo()

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

Definition at line 635 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

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

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

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

◆ fillL2Photon()

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

Definition at line 686 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ 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 std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision * > > & pairObjs,
const TrigInfo & info ) const
protectedinherited

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

Definition at line 935 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillShowerShapes()

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

Definition at line 766 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

◆ fillTracking()

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

Definition at line 829 of file TrigEgammaMonitorAnalysisAlgorithm.cxx.

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

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

388 {
389 const xAOD::TrackParticle* t = eg->trackParticle();
390 float d0sigma=0.;
391 if (t)
392 {
393 float vard0 = t->definingParametersCovMatrix()(0,0);
394 if (vard0 > 0) {
395 d0sigma=sqrtf(vard0);
396 }
397 else return -99.;
398
399 if (fabs(d0sigma) < 1e-6) return -99.;
400 return t->d0()/d0sigma;
401 }
402 else return -99.;
403}
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:5
xAOD::TrackParticle
TrackParticle_v1 TrackParticle
Reference the current persistent version:
Definition Event/xAOD/xAODTracking/xAODTracking/TrackParticle.h:13

◆ getDEmaxs1()

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

Definition at line 338 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getE0Eaccordion()

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

Definition at line 454 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEaccordion()

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

Definition at line 442 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE0()

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

Definition at line 406 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE1()

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

Definition at line 415 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE2()

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

Definition at line 424 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEnergyBE3()

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

Definition at line 433 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEt()

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

Definition at line 317 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEta2()

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

Features helper.

Helper functions now part of base class

Definition at line 308 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getEtCluster37()

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

Definition at line 328 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ GetEventInfo()

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

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

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

Definition at line 111 of file AthMonitorAlgorithm.cxx.

111 {
112 return SG::ReadHandle<xAOD::EventInfo>(m_EventInfoKey, ctx);
113}
AthMonitorAlgorithm::m_EventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_EventInfoKey
Key for retrieving EventInfo from StoreGate.
Definition AthMonitorAlgorithm.h: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 if (ATH_LIKELY(idx != m_toolLookupMap.end())) {
172 return m_tools[idx->second];
173 }
174 else {
175 // treat empty tool handle case as in Monitored::Group
176 if (m_toolLookupMap.empty()) {
177 return m_dummy;
178 }
179
180 if (!isInitialized()) {
181 ATH_MSG_FATAL(
182 "It seems that the AthMonitorAlgorithm::initialize was not called "
183 "in derived class initialize method");
184 } else {
185 std::string available = std::accumulate(
186 m_toolLookupMap.begin(), m_toolLookupMap.end(), std::string(""),
187 [](const std::string& s, auto h) { return s + "," + h.first; });
188 ATH_MSG_FATAL("The tool " << name << " could not be found in the tool array of the "
189 << "monitoring algorithm " << m_name << ". This probably reflects a discrepancy between "
190 << "your python configuration and c++ filling code. Note: your available groups are {"
191 << available << "}.");
192 }
193 }
194 return m_dummy;
195}
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 754 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getSigmaD0()

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

Definition at line 372 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ getTrigDecisionTool()

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

Get the trigger decision tool member.

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

Returns
m_trigDecTool

Definition at line 198 of file AthMonitorAlgorithm.cxx.

198 {
199 return m_trigDecTool;
200}

◆ getTrigInfo()

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

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

Definition at line 609 of file TrigEgammaMonitorBaseAlgorithm.cxx.

609 {
610 return m_trigInfo.at(trigger);
611}
TrigEgammaMonitorBaseAlgorithm::m_trigInfo
std::map< std::string, TrigInfo > m_trigInfo
creates map of trigger name and TrigInfo struct
Definition TrigEgammaMonitorBaseAlgorithm.h: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 TrigEgammaMonitorPhotonAlgorithm::initialize ( )
overridevirtual

initialize

Returns
StatusCode

Reimplemented from TrigEgammaMonitorAnalysisAlgorithm.

Definition at line 24 of file TrigEgammaMonitorPhotonAlgorithm.cxx.

25{
26
27 ATH_CHECK(TrigEgammaMonitorAnalysisAlgorithm::initialize());
28
29 ATH_CHECK(m_offPhotonKey.initialize());
30 ATH_CHECK(m_offPhotonIsolationKeys.initialize());
31 ATH_CHECK( m_eventInfoDecorKey.initialize() );
32
33 for(auto& trigName : m_trigInputList)
34 {
35 if(getTrigInfoMap().count(trigName) != 0){
36 ATH_MSG_DEBUG("Trigger already booked, removing from trigger list " << trigName);
37 }else {
38 m_trigList.push_back(trigName);
39 setTrigInfo(trigName);
40 }
41 }
42
43 return StatusCode::SUCCESS;
44}
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:617
TrigEgammaMonitorPhotonAlgorithm::m_trigInputList
Gaudi::Property< std::vector< std::string > > m_trigInputList
List of triggers from menu.
Definition TrigEgammaMonitorPhotonAlgorithm.h:43
TrigEgammaMonitorPhotonAlgorithm::m_offPhotonIsolationKeys
SG::ReadDecorHandleKeyArray< xAOD::PhotonContainer > m_offPhotonIsolationKeys
Ensure offline photon isolation decoration is retrieved after being created.
Definition TrigEgammaMonitorPhotonAlgorithm.h:59
TrigEgammaMonitorPhotonAlgorithm::m_eventInfoDecorKey
SG::ReadDecorHandleKey< xAOD::EventInfo > m_eventInfoDecorKey
Definition TrigEgammaMonitorPhotonAlgorithm.h:60
count
int count(std::string s, const std::string &regx)
count how many occurances of a regx are in a string
Definition hcg.cxx:146

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

52{
53 // Reentrant algorithms are clonable.
54 return true;
55}

◆ isHLTTruncated()

bool TrigEgammaMonitorBaseAlgorithm::isHLTTruncated ( ) const
protectedinherited

Definition at line 763 of file TrigEgammaMonitorBaseAlgorithm.cxx.

763 {
764 return m_trigdec->ExperimentalAndExpertMethods().isHLTTruncated();
765}
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 118 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

◆ isPrescaled()

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

Check if the event is prescaled.

Definition at line 150 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

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

345 {
346 std::string item;
347 std::stringstream ss(line);
348
349 ATH_MSG_DEBUG( "AthMonitorAlgorithm::parseList()" );
350
351 while ( std::getline(ss, item, ',') ) {
352 std::stringstream iss(item); // remove whitespace
353 iss >> item;
354 result.push_back(item);
355 }
356
357 return StatusCode::SUCCESS;
358}
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 355 of file TrigEgammaMonitorBaseAlgorithm.cxx.

355 {
356 if(eg && eg->trackParticle()){
357 uint8_t trtHits = 0;
358 eg->trackParticleSummaryValue(trtHits,xAOD::numberOfTRTHits);
359 uint8_t trtHTHits = 0;
360 eg->trackParticleSummaryValue(trtHTHits,xAOD::numberOfTRTHighThresholdHits);
361 if (fabs(trtHits) < 1e-6) {
362 return -99.;
363 }
364 else{
365 return ( (double)trtHTHits / (double)trtHits );
366 }
367 }
368 else return -99.;
369}
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 183 of file TrigEgammaMonitorBaseAlgorithm.cxx.

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

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

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

◆ sysExecute()

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

Execute an algorithm.

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

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

77{
78 return BaseAlg::sysExecute (ctx);
79}

◆ sysInitialize()

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

Override sysInitialize.

Override sysInitialize from the base class.

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

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

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

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

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

203 {
204
205
206 // If no triggers were given, return true.
207 if (vTrigNames.empty()) return true;
208
209
210 // Trigger: Check if this Algorithm is being run as an Express Stream job.
211 // Events are entering the express stream are chosen randomly, and by chain,
212 // Hence an additional check should be aplied to see if the chain(s)
213 // monitored here are responsible for the event being selected for
214 // the express stream.
215
216 const auto group = m_trigDecTool->getChainGroup(vTrigNames);
217 if (m_enforceExpressTriggers){
218 const auto passedBits = m_trigDecTool->isPassedBits(group);
219 bool expressPass = passedBits & TrigDefs::Express_passed; //bitwise AND
220 if(!expressPass) {
221 return false;
222 }
223 }
224
225 // monitor the event if any of the chains in the chain group passes the event.
226 return group->isPassed();
227
228}
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> TrigEgammaMonitorPhotonAlgorithm::m_anatype {this, "Analysis", "Photon"}
private

Directory name for each algorithm.

Definition at line 49 of file TrigEgammaMonitorPhotonAlgorithm.h.

49{this, "Analysis", "Photon"};

◆ m_BSTrigMap

Gaudi::Property< std::map<std::string, std::string> > TrigEgammaMonitorPhotonAlgorithm::m_BSTrigMap {this, "BootstrapTriggerMap", {{"",""}}, "Dictionary of Triggers (as keys) and Bootstraps (value) to configure Bootstrapping of photon triggers" }
private

Definition at line 47 of file TrigEgammaMonitorPhotonAlgorithm.h.

47{this, "BootstrapTriggerMap", {{"",""}}, "Dictionary of Triggers (as keys) and Bootstraps (value) to configure Bootstrapping of photon triggers" };

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

Gaudi::Property<bool> TrigEgammaMonitorPhotonAlgorithm::m_doUnconverted {this, "DoUnconverted", false}
private

doUnconverted analysis

Definition at line 41 of file TrigEgammaMonitorPhotonAlgorithm.h.

41{this, "DoUnconverted", 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_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> TrigEgammaMonitorPhotonAlgorithm::m_eventInfoDecorKey {this, "LArStatusFlag", "EventInfo.larFlags", "Key for EventInfo object"}
private

Definition at line 60 of file TrigEgammaMonitorPhotonAlgorithm.h.

60{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_forcePidSelection

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

force pid selection into photon navigation

Definition at line 51 of file TrigEgammaMonitorPhotonAlgorithm.h.

51{ this, "ForcePidSelection", true};

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

SG::ReadDecorHandleKeyArray<xAOD::PhotonContainer> TrigEgammaMonitorPhotonAlgorithm::m_offPhotonIsolationKeys {this, "PhotonIsolationKeys", {"Photons.topoetcone20", "Photons.topoetcone40"} }
private

Ensure offline photon isolation decoration is retrieved after being created.

Definition at line 59 of file TrigEgammaMonitorPhotonAlgorithm.h.

59{this, "PhotonIsolationKeys", {"Photons.topoetcone20", "Photons.topoetcone40"} };

◆ m_offPhotonKey

SG::ReadHandleKey<xAOD::PhotonContainer> TrigEgammaMonitorPhotonAlgorithm::m_offPhotonKey { this, "PhotonKey", "Photons", ""}
private

Event Wise offline PhotonContainer Access and end iterator.

Definition at line 57 of file TrigEgammaMonitorPhotonAlgorithm.h.

57{ this, "PhotonKey", "Photons", ""};

◆ m_onlyHLT

Gaudi::Property<bool> TrigEgammaMonitorPhotonAlgorithm::m_onlyHLT { this, "OnlyHLT", false}
private

Compute only final HLT decision.

Definition at line 53 of file TrigEgammaMonitorPhotonAlgorithm.h.

53{ this, "OnlyHLT", false};

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

Gaudi::Property<std::string> TrigEgammaMonitorPhotonAlgorithm::m_photonPid {this, "PhotonPid","Tight" }
private

Photon pid word.

Definition at line 39 of file TrigEgammaMonitorPhotonAlgorithm.h.

39{this, "PhotonPid","Tight" };

◆ 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> > TrigEgammaMonitorPhotonAlgorithm::m_trigInputList {this, "TriggerList", {}}
private

List of triggers from menu.

Definition at line 43 of file TrigEgammaMonitorPhotonAlgorithm.h.

43{this, "TriggerList", {}};

◆ m_trigList

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

List of triggers to study.

Definition at line 37 of file TrigEgammaMonitorPhotonAlgorithm.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.14.0