diff --git a/Trigger/TrigAnalysis/TrigEgammaMatchingTool/Root/TrigEgammaMatchingToolMT.cxx b/Trigger/TrigAnalysis/TrigEgammaMatchingTool/Root/TrigEgammaMatchingToolMT.cxx
index dda8ae6c3cb2a70e7ff46f25e2ad3a49df083ec0..f299f0a21a37c3fcb60bfe9a942eb36149d2df6d 100644
--- a/Trigger/TrigAnalysis/TrigEgammaMatchingTool/Root/TrigEgammaMatchingToolMT.cxx
+++ b/Trigger/TrigAnalysis/TrigEgammaMatchingTool/Root/TrigEgammaMatchingToolMT.cxx
@@ -11,7 +11,6 @@
#include <typeinfo>
#include <string>
-
using namespace TrigCompositeUtils;
using namespace Trig;
@@ -65,6 +64,7 @@ std::string TrigEgammaMatchingToolMT::key( std::string key) const
bool TrigEgammaMatchingToolMT::match(const xAOD::Egamma *eg,const std::string &trigger, const TrigCompositeUtils::Decision *&dec ) const
{
+
ATH_MSG_DEBUG("Match decec with trigger " << trigger);
if(xAOD::EgammaHelpers::isElectron(eg)){
const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg);
@@ -87,6 +87,8 @@ bool TrigEgammaMatchingToolMT::match(const xAOD::Egamma *eg,const std::string &t
const xAOD::Photon* ph =static_cast<const xAOD::Photon*> (eg);
if( matchL2Photon(ph,trigger,dec) ) return true;
}
+
+ if( matchL2Calo(eg,trigger,dec) ) return true;
if( matchL1(eg,trigger,dec) ) return true;
ATH_MSG_DEBUG("match() failed!");
@@ -160,6 +162,7 @@ bool TrigEgammaMatchingToolMT::matchL1( const xAOD::Egamma* eg, const std::strin
double deltaR=0.;
auto initRois = tdt()->features<TrigRoiDescriptorCollection>(trigger,TrigDefs::includeFailedDecisions,"",
TrigDefs::allFeaturesOfType,"initialRoI");
+
if( initRois.size() < 1) return false;
for( auto &initRoi: initRois ){
if( !initRoi.link.isValid() ) continue;
diff --git a/Trigger/TrigAnalysis/TrigEgammaMatchingTool/TrigEgammaMatchingTool/TrigEgammaMatchingToolMT.h b/Trigger/TrigAnalysis/TrigEgammaMatchingTool/TrigEgammaMatchingTool/TrigEgammaMatchingToolMT.h
index 6b7e759c1b3b152975463d54760ee3f2d55bddc2..0d08ee8f4346b78755e2c50b76041bd37253b31e 100644
--- a/Trigger/TrigAnalysis/TrigEgammaMatchingTool/TrigEgammaMatchingTool/TrigEgammaMatchingToolMT.h
+++ b/Trigger/TrigAnalysis/TrigEgammaMatchingTool/TrigEgammaMatchingTool/TrigEgammaMatchingToolMT.h
@@ -51,7 +51,9 @@ class TrigEgammaMatchingToolMT : public asg::AsgTool
const xAOD::EmTauRoI* getL1Feature( const TrigCompositeUtils::Decision * ) const;
-
+
+
+
private:
bool matchHLTElectron(const xAOD::Electron *,const std::string &, const TrigCompositeUtils::Decision *&) const;
diff --git a/Trigger/TrigAnalysis/TrigEgammaMatchingTool/TrigEgammaMatchingTool/TrigEgammaMatchingToolMT.icc b/Trigger/TrigAnalysis/TrigEgammaMatchingTool/TrigEgammaMatchingTool/TrigEgammaMatchingToolMT.icc
index 4671ed79eb418c5c4850ca81b69070f4cbc04d08..511c457b6413af800161b9f1a64e1b59f8b48671 100644
--- a/Trigger/TrigAnalysis/TrigEgammaMatchingTool/TrigEgammaMatchingTool/TrigEgammaMatchingToolMT.icc
+++ b/Trigger/TrigAnalysis/TrigEgammaMatchingTool/TrigEgammaMatchingTool/TrigEgammaMatchingToolMT.icc
@@ -60,6 +60,8 @@ inline bool TrigEgammaMatchingToolMT::closestObject( const xAOD::Egamma *eg, con
{
double deltaR=0.;
auto vec = tdt()->features<T>(trigger,TrigDefs::includeFailedDecisions ,key);
+
+
for( auto &featLinkInfo : vec ){
if(! featLinkInfo.isValid() ) continue;
const auto *feat = *(featLinkInfo.link);
diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitorAlgorithm.py b/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitorAlgorithm.py
index 0964efc7e06d3851e9aee52c4150b13495f5591e..4795740792dc79f06235e975fa23516482229706 100644
--- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitorAlgorithm.py
+++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitorAlgorithm.py
@@ -24,7 +24,7 @@ def TrigEgammaMonConfig(inputFlags):
helper = AthMonitorCfgHelper(inputFlags,'TrigEgammaAthMonitorCfg')
# configure alg and ana tools
from TrigEgammaMonitoring.TrigEgammaMonitoringMTConfig import TrigEgammaMonAlgBuilder
- monAlgCfg = TrigEgammaMonAlgBuilder( helper, '2018', detailedHistogram=True ) # Using 2018 e/g tunings
+ monAlgCfg = TrigEgammaMonAlgBuilder( helper, '2018', detailedHistograms=True ) # Using 2018 e/g tunings
# build monitor and book histograms
monAlgCfg.configure()
diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitoringMTConfig.py b/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitoringMTConfig.py
index df57fba3030fe00f7d5ffb4bcbd923e688bb6e98..b199a1d8490e8e7007e2441afc690550a9320836 100644
--- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitoringMTConfig.py
+++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/python/TrigEgammaMonitoringMTConfig.py
@@ -106,7 +106,8 @@ class TrigEgammaMonAlgBuilder:
self.activate_electron=True
self.activate_photon=True
-
+
+
def configure(self):
self.setProperties()
self.configureMonitor()
@@ -114,8 +115,6 @@ class TrigEgammaMonAlgBuilder:
-
-
def get_monitoring_mode(self):
# Implementation of https://its.cern.ch/jira/browse/ATR-13200
@@ -178,6 +177,7 @@ class TrigEgammaMonAlgBuilder:
self.electronList = monitoring_electron
self.photonList = monitoring_photon
self.tpList = monitoringTP_electron
+
self.jpsiList = []
self.tagItems = [] #monitoring_tags
self.jpsitagItems = [] #monitoring_jpsitags
@@ -361,34 +361,77 @@ class TrigEgammaMonAlgBuilder:
self.__logger.info( "Booking all histograms for alg: %s", monAlg.name )
for trigger in triggers:
- self.bookL1CaloDistributions( monAlg, trigger )
- self.bookL2CaloDistributions( monAlg, trigger )
- self.bookL2ElectronDistributions( monAlg, trigger )
- self.bookEFCaloDistributions( monAlg, trigger )
- self.bookShowerShapesAndTrackingDistributions( monAlg, trigger, online=True )
- self.bookShowerShapesAndTrackingDistributions( monAlg, trigger, online=False )
- self.bookEfficiencies( monAlg, trigger, "L1Calo" )
- self.bookEfficiencies( monAlg, trigger, "L2Calo" )
- self.bookEfficiencies( monAlg, trigger, "L2" )
- self.bookEfficiencies( monAlg, trigger, "EFCalo" )
- self.bookEfficiencies( monAlg, trigger, "HLT" )
-
- if self.detailedHistograms:
- for pid in self.isemnames + self.lhnames:
- self.bookEfficiencies( monAlg, trigger, "HLT", pid )
- self.bookEfficiencies( monAlg, trigger, "HLT", pid+"Iso" )
+
+ info = self.getTrigInfo(trigger)
+
+ if info.isL1Item():
+ self.bookL1CaloDistributions( monAlg, trigger )
+ self.bookEfficiencies( monAlg, trigger, "L1Calo" )
+ self.bookL1CaloResolutions( monAlg, trigger )
+ self.bookL1CaloAbsResolutions( monAlg, trigger )
+
+ else:
+ #
+ # Distributions
+ #
+ self.bookL1CaloDistributions( monAlg, trigger )
+ self.bookL2CaloDistributions( monAlg, trigger )
+ self.bookEFCaloDistributions( monAlg, trigger )
+
+ self.bookL1CaloResolutions( monAlg, trigger )
+ self.bookL1CaloAbsResolutions( monAlg, trigger )
+ self.bookL2CaloResolutions( monAlg, trigger )
+ self.bookHLTResolutions( monAlg, trigger )
+
+ if info.isElectron():
+ self.bookL2ElectronDistributions( monAlg, trigger )
+ # Offline and HLT
+ self.bookShowerShapesDistributions( monAlg, trigger, online=True )
+ self.bookShowerShapesDistributions( monAlg, trigger, online=False )
+ self.bookTrackingDistributions( monAlg, trigger, online=True )
+ self.bookTrackingDistributions( monAlg, trigger, online=False )
+ self.bookHLTElectronResolutions( monAlg, trigger, info.isIsolated() )
+
+ elif info.isPhoton():
+ # Should we include L2 for photon in the future?
+ self.bookShowerShapesDistributions( monAlg, trigger, online=True )
+ self.bookShowerShapesDistributions( monAlg, trigger, online=False )
+ self.bookHLTPhotonResolutions( monAlg, trigger, info.isIsolated() )
+
+
+ #
+ # Efficiecies
+ #
+ self.bookEfficiencies( monAlg, trigger, "L1Calo" )
+ self.bookEfficiencies( monAlg, trigger, "L2Calo" )
+ self.bookEfficiencies( monAlg, trigger, "L2" )
+ self.bookEfficiencies( monAlg, trigger, "EFCalo" )
+ self.bookEfficiencies( monAlg, trigger, "HLT" )
+
+ if self.detailedHistograms:
+ for pid in self.isemnames + self.lhnames:
+ self.bookEfficiencies( monAlg, trigger, "HLT", pid )
+ self.bookEfficiencies( monAlg, trigger, "HLT", pid+"Iso" )
+
+
-
+
+
def bookEvent(self, monAlg, analysis):
- #cutLabels = ["Events","LAr","RetrieveElectrons","TwoElectrons","PassTrigger","EventWise","Success"]
- #probeLabels=["Electrons","NotTag","OS","SS","ZMass","HasTrack","HasCluster","Eta","Et","IsGoodOQ","GoodPid","NearbyJet","Isolated"]
+ cutLabels = ["Events","LAr","RetrieveElectrons","TwoElectrons","PassTrigger","EventWise","Success"]
+ probeLabels=["Electrons","NotTag","OS","SS","ZMass","HasTrack","HasCluster","Eta","Et","IsGoodOQ","GoodPid","NearbyJet","Isolated"]
+ tagLabels=["Electrons","HasTrack","HasCluster","GoodPid","Et","Eta","IsGoodOQ","PassTrigger","MatchTrigger"]
+
# Create mon group. The group name should be the path name for map
monGroup = self.addGroup( monAlg, 'Event', self.basePath+'/Expert/Event' )
- monGroup.defineHistogram(analysis+"_CutCounter", type='TH1I', path='/', title="Event Selection; Cut ; Count",xbins=6, xmin=0, xmax=6)
- monGroup.defineHistogram(analysis+"_TagCutCounter", type='TH1F', path='', title="Number of Probes; Cut ; Count",xbins=12, xmin=0, xmax=12)
- monGroup.defineHistogram(analysis+"_ProbeCutCounter", type='TH1F', path='', title="Number of Probes; Cut ; Count",xbins=12, xmin=0, xmax=12)
+ monGroup.defineHistogram(analysis+"_CutCounter", type='TH1I', path='/', title="Event Selection; Cut ; Count",
+ xbins=len(cutLabels), xmin=0, xmax=len(cutLabels), xlabels=cutLabels)
+ monGroup.defineHistogram(analysis+"_TagCutCounter", type='TH1F', path='', title="Number of Probes; Cut ; Count",
+ xbins=len(tagLabels), xmin=0, xmax=len(tagLabels), xlabels=tagLabels)
+ monGroup.defineHistogram(analysis+"_ProbeCutCounter", type='TH1F', path='', title="Number of Probes; Cut ; Count",
+ xbins=len(probeLabels), xmin=0, xmax=len(probeLabels), xlabels=probeLabels)
monGroup.defineHistogram(analysis+"_Mee", type='TH1F', path='/', title="Offline M(ee); m_ee [GeV] ; Count",xbins=50, xmin=monAlg.ZeeLowerMass, xmax=monAlg.ZeeUpperMass)
@@ -459,7 +502,7 @@ class TrigEgammaMonAlgBuilder:
#
# Book Shower shapes
#
- def bookShowerShapesAndTrackingDistributions( self, monAlg, trigger, online=True ):
+ def bookShowerShapesDistributions( self, monAlg, trigger, online=True ):
from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
monGroup = self.addGroup( monAlg, trigger+'_Distributions_' + ("HLT" if online else "Offline"),
@@ -486,6 +529,16 @@ class TrigEgammaMonAlgBuilder:
self.addHistogram(monGroup, TH1F("topoetcone40_shift_rel", "(topoetcone40-2.45 GeV)/pt; (topoetcone40-2.45 GeV)/pt ; Count", 100, -0.5, 0.5))
+ #
+ # Book Tracking
+ #
+ def bookTrackingDistributions( self, monAlg, trigger, online=True ):
+
+ from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F
+ monGroup = self.addGroup( monAlg, trigger+'_Distributions_' + ("HLT" if online else "Offline"),
+ self.basePath+'/'+trigger+'/Distributions/' + ("HLT" if online else "Offline") )
+
+
# Tracking quantities
self.addHistogram(monGroup, TH1F("deta1", "deta1; deta1 ; Count", 40, -0.01, 0.01))
self.addHistogram(monGroup, TH1F("deta1_EMECA", "deta1 EMEC-A; deta1 ; Count", 40, -0.01, 0.01))
@@ -518,8 +571,6 @@ class TrigEgammaMonAlgBuilder:
monGroup = self.addGroup( monAlg, trigger+'_Efficiency_'+level+'_'+subgroup, self.basePath+'/'+trigger+'/Efficiency/'+level+'/'+subgroup )
else:
monGroup = self.addGroup( monAlg, trigger+'_Efficiency_'+level, self.basePath+'/'+trigger+'/Efficiency/'+level )
-
-
# Numerator
self.addHistogram(monGroup, TH1F("match_pt", "Trigger Matched Offline p_{T}; p_{T} [GeV] ; Count", self._nEtbins, self._etbins))
@@ -550,11 +601,276 @@ class TrigEgammaMonAlgBuilder:
+ def bookL1CaloResolutions(self, monAlg, trigger):
+
+ from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
+ monGroup = self.addGroup( monAlg, trigger+'_Resolutions_L1Calo', self.basePath+'/'+trigger+'/Resolutions/L1Calo' )
+ self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("eta", "eta; eta ; Count", 50, -2.47, 2.47))
+
+ if self.detailedHistograms:
+ self.addHistogram(monGroup, TH2F("eta,res_et", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",50, -2.47, 2.47,50, -0.1, 0.1))
+
+
+
+ def bookL1CaloAbsResolutions(self, monAlg, trigger):
+
+ from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
+ monGroup = self.addGroup( monAlg, trigger+'_AbsResolutions_L1Calo', self.basePath+'/'+trigger+'/AbsResolutions/L1Calo' )
+ self.addHistogram(monGroup, TH1F("eta", "#eta; #eta ; Count", 50, -2.47, 2.47))
+ self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
+ if self.detailedHistograms:
+ self.addHistogram(monGroup, TH2F("eta,res_et", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",50, -2.47, 2.47,50, -0.1, 0.1))
+ def bookL2CaloResolutions(self, monAlg, trigger):
- #
+ from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
+ monGroup = self.addGroup( monAlg, trigger+'_Resolutions_L2Calo', self.basePath+'/'+trigger+'/Resolutions/L2Calo' )
+
+ # online values used to fill all 2d histograms
+ self.addHistogram(monGroup, TH1F("et", "E_{T}; E_{T}[GeV] ; Count", 50, 0.0, 100.))
+ self.addHistogram(monGroup, TH1F("eta", "#eta; #eta ; Count", 50, -2.47, 2.47))
+
+
+ self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off))/#eta(off) ; Count", 40, -0.001, 0.001))
+ self.addHistogram(monGroup, TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off))/#phi(off) ; Count", 40, -0.001, 0.001))
+ self.addHistogram(monGroup, TH1F("res_ethad", "ethad resolution; (ethad(on)-ethad(off))/ethad(off) ; Count", 20, -5, 5))
+ self.addHistogram(monGroup, TH1F("res_ethad1", "ethad1 resolution; (ethad1(on)-ethad1(off))/ethad1(off) ; Count", 20, -5, 5))
+ self.addHistogram(monGroup, TH1F("res_Rhad", "Rhad resolution; (Rhad(on)-Rhad(off))/Rhad(off) ; Count", 20, -10., 10.))
+ self.addHistogram(monGroup, TH1F("res_Rhad1", "Rhad1; Rhad1 resolution; (Rhad1(on)-Rhad1(off))/Rhad1(off)", 20, -10., 10.))
+ self.addHistogram(monGroup, TH1F("res_Reta", "Reta resolution; (Reta(on)-Reta(off))/Reta(off) ; Count", 20, -0.01, 0.01))
+ self.addHistogram(monGroup, TH1F("res_Rphi", "Rphi resolution; (Rphi(on)-Rphi(off))/Rphi(off) ; Count", 20, -0.01, 0.01))
+ self.addHistogram(monGroup, TH1F("res_weta2", "weta2 resolution; (weta2(on)-weta2(off))/weta2(off) ; Count", 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH1F("res_f1", "f1 resolution; (f1(on)-f1(off))/f1(off) ; Count", 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH1F("res_f3", "f3 resolution; (f3(on)-f3(off))/f3(off) ; Count", 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH1F("res_eratio", "eratio resolution; (eratio(on)-eratio(off))/eratio(off) ; Count", 20, -0.001, 0.001))
+
+ if self.detailedHistograms:
+ # Book all 2D histograms
+ self.addHistogram(monGroup, TH2F("et,res_etVsEt", "E_{T} resolution as function of E_{T}; E_{T} [GeV]; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
+ 50, 0., 100.,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("eta,res_et", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
+ 50, -2.47, 2.47,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("eta,res_f3", "L2Calo f3 resolution as function of #eta; #eta; (f3(on)-f3(off))/f3(off); Count",
+ 50, -2.47, 2.47,
+ 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH2F("et,res_f3", "L2Calo f3 resolution as function of E_{T}; E_{T} [GeV]; (f3(on)-f3(off))/f3(off); Count",
+ 50, 0., 100.,
+ 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH2F("eta,res_f1", "L2Calo f1 resolution as function of #eta; #eta; (f1(on)-f1(off))/f1(off); Count",
+ 50, -2.47, 2.47,
+ 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH2F("et,res_f1", "L2Calo f1 resolution as function of E_{T}; E_{T} [GeV]; (f1(on)-f1(off))/f1(off); Count",
+ 50, 0., 100.,
+ 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH2F("eta,res_weta2", "L2Calo weta2 resolution as function of #eta; #eta; (weta2(on)-weta2(off))/weta2(off); Count",
+ 50, -2.47, 2.47,
+ 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH2F("et,res_weta2", "L2Calo weta2 resolution as function of E_{T}; E_{T} [GeV]; (weta2(on)-weta2(off))/weta2(off); Count",
+ 50, 0., 100.,
+ 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH2F("eta,res_Reta", "L2Calo Reta resolution as function of #eta; #eta; (Reta(on)-Reta(off))/Reta(off); Count",
+ 50, -2.47, 2.47,
+ 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH2F("et,res_Reta", "L2Calo Reta resolution as function of E_{T}; E_{T} [GeV]; (Reta(on)-Reta(off))/Reta(off); Count",
+ 50, 0., 100.,
+ 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH2F("eta,res_Rhad1", "L2Calo E_{T} Rhad1 resolution as function of #eta; #eta; (Rhad1(on)-Rhad1(off))/Rhad1(off); Count",
+ 50, -2.47, 2.47,
+ 20, -10, 10))
+ self.addHistogram(monGroup, TH2F("et,res_Rhad1", "L2Calo E_{T} RHad1 resolution as function of E_{T}; E_{T} [GeV]; (Rhad1(on)-Rhad1(off))/Rhad1(off); Count",
+ 50, 0., 100.,
+ 20, -10, 10))
+ self.addHistogram(monGroup, TH2F("eta,res_Rhad", "L2Calo E_{T} Rhad resolution as function of #eta; #eta; (Rhad(on)-Rhad(off))/Rhad(off); Count",
+ 50, -2.47, 2.47,
+ 20, -10, 10))
+ self.addHistogram(monGroup, TH2F("et,res_Rhad", "L2Calo E_{T} RHad resolution as function of E_{T}; E_{T} [GeV]; (Rhad(on)-Rhad(off))/Rhad(off); Count",
+ 50, 0., 100.,
+ 20, -10, 10))
+ self.addHistogram(monGroup, TH2F("eta,res_ethad1", "L2Calo E_{T} Had1 resolution as function of #eta; #eta; (ethad1(on)-ethad1(off))/ethad1(off); Count",
+ 50, -2.47, 2.47,
+ 20, -0.5, 0.5))
+ self.addHistogram(monGroup, TH2F("et,res_ethad1", "L2Calo E_{T} Had1 resolution as function of E_{T}; E_{T} [GeV]; (ethad1(on)-ethad1(off))/ethad1(off); Count",
+ 50, 0., 100.,
+ 20, -0.5, 0.5))
+ self.addHistogram(monGroup, TH2F("eta,res_ethad", "L2Calo E_{T} Had resolution as function of #eta; #eta; (ethad(on)-ethad(off))/ethad(off); Count",
+ 50, -2.47, 2.47,
+ 20, -0.5, 0.5))
+ self.addHistogram(monGroup, TH2F("et,res_ethad", "L2Calo E_{T} Had resolution as function of E_{T}; E_{T} [GeV]; (ethad(on)-ethad(off))/ethad(off); Count",
+ 50, 0., 100.,
+ 20, -0.5, 0.5))
+ self.addHistogram(monGroup, TH2F("eta,res_eratio", "L2Calo eratio resolution as function of #eta; #eta; (eratio(on)-eratio(off))/eratio(off); Count",
+ 50, -2.47, 2.47,
+ 20, -0.001, 0.001))
+ self.addHistogram(monGroup, TH2F("et,res_eratio", "L2Calo eratio resolution as function of E_{T}; E_{T} [GeV]; (eratio(on)-eratio(off))/eratio(off); Count",
+ 50, 0., 100.,
+ 50, -0.001, 0.001))
+
+
+
+
+ def bookHLTResolutions(self, monAlg, trigger):
+
+ from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
+ monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/'+trigger+'/Resolutions/HLT' )
+
+ # online values used to fill all 2d histograms
+ self.addHistogram(monGroup, TH1F("et", "E_{T}; E_{T}[GeV] ; Count", 50, 0.0, 100.))
+ self.addHistogram(monGroup, TH1F("eta", "#eta; #eta ; Count", 50, -2.47, 2.47))
+ self.addHistogram(monGroup, TH1F("mu", "#mu; #mu ; Count", 50, 0, 100))
+
+
+ self.addHistogram(monGroup, TH1F("res_et", "E_{T} resolution; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_eta", "#eta resolution; (#eta(on)-#eta(off))/#eta(off) ; Count", 40, -0.001, 0.001))
+ self.addHistogram(monGroup, TH1F("res_phi", "#phi resolution; (#phi(on)-#phi(off))/#phi(off) ; Count", 40, -0.001, 0.001))
+ self.addHistogram(monGroup, TH1F("res_ethad", "ethad resolution; (ethad(on)-ethad(off))/ethad(off) ; Count", 20, -5, 5))
+ self.addHistogram(monGroup, TH1F("res_ethad1", "ethad1 resolution; (ethad1(on)-ethad1(off))/ethad1(off) ; Count", 20, -5, 5))
+ self.addHistogram(monGroup, TH1F("res_Rhad", "Rhad resolution; (Rhad(on)-Rhad(off))/Rhad(off) ; Count", 20, -10., 10.))
+ self.addHistogram(monGroup, TH1F("res_Rhad1", "Rhad1; Rhad1 resolution; (Rhad1(on)-Rhad1(off))/Rhad1(off)", 20, -10., 10.))
+ self.addHistogram(monGroup, TH1F("res_Reta", "Reta resolution; (Reta(on)-Reta(off))/Reta(off) ; Count", 20, -0.01, 0.01))
+ self.addHistogram(monGroup, TH1F("res_Rphi", "Rphi resolution; (Rphi(on)-Rphi(off))/Rphi(off) ; Count", 20, -0.01, 0.01))
+ self.addHistogram(monGroup, TH1F("res_weta1", "weta1 resolution; (weta1(on)-weta1(off))/weta1(off) ; Count", 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH1F("res_weta2", "weta2 resolution; (weta2(on)-weta2(off))/weta2(off) ; Count", 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH1F("res_f1", "f1 resolution; (f1(on)-f1(off))/f1(off) ; Count", 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH1F("res_f3", "f3 resolution; (f3(on)-f3(off))/f3(off) ; Count", 20, -0.05, 0.05))
+ self.addHistogram(monGroup, TH1F("res_eratio", "eratio resolution; (eratio(on)-eratio(off))/eratio(off) ; Count", 20, -0.001, 0.001))
+
+
+ self.addHistogram(monGroup, TH1F("res_etInEta0", "HLT E_{T} resolution in #eta = [0#div1.37]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_etInEta1", "HLT E_{T} resolution in #eta = [1.37#div1.52]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_etInEta2", "HLT E_{T} resolution in #eta = [1.55#div1.8]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_etInEta3", "HLT E_{T} resolution in #eta = [1.8#div2.45]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+
+ if self.detailedHistograms:
+ self.addHistogram(monGroup, TH2F("eta,res_et", "E_{T} resolution as function of #eta; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",50, -2.47, 2.47,100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("et,res_et", "E_{T} resolution as function of E_{T}; E_{T} [GeV]; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",50, 0., 100.,100, -0.1, 0.1))
+
+
+
+ def bookHLTElectronResolutions(self, monAlg, trigger, isolated=False):
+
+
+ from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
+ monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/'+trigger+'/Resolutions/HLT' )
+
+ self.addHistogram(monGroup, TH1F("res_pt", "p_{T} resolution; (p_{T}(on)-p_{T}(off))/p_{T}(off) ; Count", 120, -1.5, 1.5))
+ self.addHistogram(monGroup, TH1F("res_deta1", "deta1; deta1 ; (deta1(on)-deta1(off))/deta1(off)", 100, -1., 1.))
+ self.addHistogram(monGroup, TH1F("res_deta2", "deta2; deta2 ; (deta2(on)-deta2(off))/deta2(off)", 100, -1., 1.))
+ self.addHistogram(monGroup, TH1F("res_dphi2", "dphi2; dphi2 ; (dphi2(on)-dphi2(off))/dphi2(off)", 100, -1., 1.))
+ self.addHistogram(monGroup, TH1F("res_dphiresc", "dphiresc; (dphires(on)-dphires(off))/dphires(off) ; Count", 100, -1., 1.))
+ self.addHistogram(monGroup, TH1F("res_d0", "resolution d0; (d0(on)-d0(off)) ; Count", 100, -0.5, 0.5))
+ self.addHistogram(monGroup, TH1F("res_d0sig", "resolution d0sig; (d0sig(on)-d0sig(off)) ; Count", 50, -10, 10))
+ self.addHistogram(monGroup, TH1F("res_eprobht","resolution eProbHT; (eProbHT(on)-eProbHT(off)); Count",50, -1, 1))
+ self.addHistogram(monGroup, TH1F("res_nscthits","resolution nSCTHit; (nSCTHits(on)-nSCTHits(off); Count",20, -10, 10))
+ self.addHistogram(monGroup, TH1F("res_npixhits","resolution nPixHit; (nPixHits(on)-nPixHits(off)); Count",10, -5, 5))
+
+ self.addHistogram(monGroup, TH1F("pt", "online p_{T}; p_{T}; Count", 50, 0., 100.))
+
+ if self.detailedHistograms:
+ self.addHistogram(monGroup, TH2F("pt,res_eprobht", "eProbHT resolution as function of p_{T}; p_{T} [GeV]; (eprobHT(on)-eprobHT(off)); Count",
+ 50, 0., 100.,
+ 50, -1., 1.))
+
+
+
+ if isolated:
+ self.addHistogram(monGroup, TH1F("res_ptcone20", "resolution ptcone20; ptcone20 (on-off)/off; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_ptcone20_rel", "resolution ptcone20/pt; ptcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("eta,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
+ 50, -2.47, 2.47,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("et,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
+ 50, 0., 100.,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("mu,res_ptcone20", "HLT ptcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
+ 50, 0, 100,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("mu,res_ptcone20_rel", "HLT ptcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
+ 50, 0, 100,
+ 100, -0.1, 0.1))
+
+ self.addHistogram(monGroup, TH1F("res_ptvarcone20", "resolution ptvarcone20; ptvarcone20 (on-off)/off; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_ptvarcone20_rel", "resolution ptvarcone20/pt; ptvarcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("eta,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
+ 50, -2.47, 2.47,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("et,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
+ 50, 0., 100.,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("mu,res_ptvarcone20", "HLT ptvarcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
+ 50, 0, 100,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("mu,res_ptvarcone20_rel", "HLT ptvarcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
+ 50, 0, 100,
+ 100, -0.1, 0.1))
+
+
+ def bookHLTPhotonResolutions(self, monAlg, trigger, isolated=False):
+
+
+ from TrigEgammaMonitoring.TrigEgammaMonitorHelper import TH1F, TH2F
+ monGroup = self.addGroup( monAlg, trigger+'_Resolutions_HLT', self.basePath+'/'+trigger+'/Resolutions/HLT' )
+
+ self.addHistogram(monGroup, TH1F("res_et_cnv", "HLT E_{T} resolution for converted Photons; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_et_uncnv", "HLT E_{T} resolution for unconverted Photons; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_cnv_etInEta0", "HLT E_{T} resolution in #eta = [0#div1.37]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_cnv_etInEta1", "HLT E_{T} resolution in #eta = [1.37#div1.52]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_cnv_etInEta2", "HLT E_{T} resolution in #eta = [1.55#div1.8]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_cnv_etInEta3", "HLT E_{T} resolution in #eta = [1.8#div2.45]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_uncnv_etInEta0", "HLT E_{T} resolution in #eta = [0#div1.37]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_uncnv_etInEta1", "HLT E_{T} resolution in #eta = [1.37#div1.52]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_uncnv_etInEta2", "HLT E_{T} resolution in #eta = [1.55#div1.8]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_uncnv_etInEta3", "HLT E_{T} resolution in #eta = [1.8#div2.45]; (E_{T}(on)-E_{T}(off))/E_{T}(off) ; Count", 200, -0.1, 0.1))
+
+ if self.detailedHistograms:
+ self.addHistogram(monGroup, TH2F("eta,res_cnv_et",
+ "HLT E_{T} resolution as function of #eta for converted Photons; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
+ 50, -2.47, 2.47,
+ 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("et,res_cnv_et",
+ "HLT E_{T} resolution as function of E_{T} for converted Photons; E_{T} [GeV]; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
+ 50, 0., 100.,
+ 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("eta,res_uncnv_et",
+ "HLT E_{T} resolution as function of #eta for unconverted Photons; #eta; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
+ 50, -2.47, 2.47,
+ 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("et,res_uncnv_et",
+ "HLT E_{T} resolution as function of E_{T} for unconverted Photons; E_{T} [GeV]; (E_{T}(on)-E_{T}(off))/E_{T}(off); Count",
+ 50, 0., 100.,
+ 200, -0.1, 0.1))
+
+ if isolated:
+
+ self.addHistogram(monGroup, TH1F("res_topoetcone20", "resolution topoetcone20; ptcone20 (on-off)/off; Count", 200, -0.1, 0.1))
+ self.addHistogram(monGroup, TH1F("res_topoetcone20_rel", "resolution topoetcone20/pt; ptcone20/pt (on-off)/off; Count", 100, -0.1, 0.1))
+
+ if self.detailedHistograms:
+ self.addHistogram(monGroup, TH2F("eta,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of #eta; #eta; (on-off)/off; Count",
+ 50, -2.47, 2.47,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("et,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of E_{T}; E_{T} [GeV]; (on-off)/off; Count",
+ 50, 0., 100.,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("mu,res_topoetcone20", "HLT topoetcone20 resolution as function of avg #mu; #mu; (on-off)/off; Count",
+ 50, 0, 100,
+ 100, -0.1, 0.1))
+ self.addHistogram(monGroup, TH2F("mu,res_topoetcone20_rel", "HLT topoetcone20/pt resolution as function of avg #mu; #mu; (on-off)/off; Count",
+ 50, 0, 100,
+ 100, -0.1, 0.1))
+
+
+
+
+
+
+
+ #
# Set binning
#
def setBinning(self, doJpsiee=False):
@@ -632,5 +948,13 @@ class TrigEgammaMonAlgBuilder:
def pidname(self):
return self.chain().split('_')[2]
+ def isIsolated(self):
+ for part_name in ['iloose', 'ivarloose', 'icaloloose', 'icalovloose', 'icalotight']:
+ if part_name in self.chain():
+ return True
+ return False
+
+
+
return TrigEgammaInfo(trigger)
diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorAnalysisAlgorithm.cxx b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorAnalysisAlgorithm.cxx
index 6cf0aed54ff4e4904d53773377da72809864a4c8..19b477ba66ae40f91bd7329282d2f63c4e3fa2eb 100644
--- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorAnalysisAlgorithm.cxx
+++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorAnalysisAlgorithm.cxx
@@ -53,11 +53,11 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillEfficiencies( std::vector< std::pai
if(pairObj.first->type()==xAOD::Type::Electron){
const xAOD::Electron* el = static_cast<const xAOD::Electron *> (pairObj.first);
- float et = getEt(el)/1e3;
+ float et = getEt(el)/Gaudi::Units::GeV;
if(et < info.trigThrHLT-5.0) continue;
}else if(pairObj.first->type()==xAOD::Type::Photon){
- float et = getCluster_et(pairObj.first)/1e3;
+ float et = getCluster_et(pairObj.first)/Gaudi::Units::GeV;
if(et < info.trigThrHLT-5.0) continue;
if(boost::contains(info.trigName,"icalovloose")) {
@@ -162,13 +162,13 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillEfficiency( const std::string &subg
const xAOD::Electron* el =static_cast<const xAOD::Electron*> (eg);
pid=el->auxdecor<bool>(pidword);
ATH_MSG_DEBUG("Electron pid " << pid);
- et = getEt(el)/1e3;
+ et = getEt(el)/Gaudi::Units::GeV;
}
- else et=eg->caloCluster()->et()/1e3;
+ else et=eg->caloCluster()->et()/Gaudi::Units::GeV;
float eta = eg->caloCluster()->etaBE(2);
float phi = eg->phi();
- float pt = eg->pt()/1e3;
+ float pt = eg->pt()/Gaudi::Units::GeV;
float avgmu=lbAverageInteractionsPerCrossing( Gaudi::Hive::currentContext() );
float npvtx=0.0;
@@ -428,10 +428,10 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillL1Calo( const std::string &trigger,
if(!l1) continue;
eta_vec.push_back( l1->eta() );
phi_vec.push_back( l1->phi() );
- energy_vec.push_back( l1->emClus()/1.e3 );
- roi_et_vec.push_back( l1->eT()/1.e3 );
- emIso_vec.push_back( l1->emIsol()/1.e3 );
- hadCore_vec.push_back( l1->hadCore()/1.e3 );
+ energy_vec.push_back( l1->emClus()/Gaudi::Units::GeV );
+ roi_et_vec.push_back( l1->eT()/Gaudi::Units::GeV );
+ emIso_vec.push_back( l1->emIsol()/Gaudi::Units::GeV );
+ hadCore_vec.push_back( l1->hadCore()/Gaudi::Units::GeV );
}
fill( monGroup, eta_col, phi_col, energy_col, roi_et_col, emIso_col, hadCore_col );
@@ -455,7 +455,7 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillL2Calo(const std::string &trigger,
for ( auto emCluster : emCluster_vec )
{
if(!emCluster) continue;
- et_vec.push_back( emCluster->et()/1.e3 );
+ et_vec.push_back( emCluster->et()/Gaudi::Units::GeV );
eta_vec.push_back( emCluster->eta() );
phi_vec.push_back( emCluster->phi() );
}
@@ -481,7 +481,7 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillL2Electron(const std::string &trigg
for ( auto el : el_vec )
{
if(!el) continue;
- et_vec.push_back( el->pt()/1.e3 );
+ et_vec.push_back( el->pt()/Gaudi::Units::GeV );
eta_vec.push_back( el->eta() );
phi_vec.push_back( el->phi() );
}
@@ -520,12 +520,12 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillEFCalo(const std::string &trigger,
if(!clus->retrieveMoment(xAOD::CaloCluster::PHICALOFRAME,tmpphi))
tmpphi=-999.;
- energyBE0_vec.push_back( clus->energyBE(0)/1.e3 );
- energyBE1_vec.push_back( clus->energyBE(1)/1.e3 );
- energyBE2_vec.push_back( clus->energyBE(2)/1.e3 );
- energyBE3_vec.push_back( clus->energyBE(3)/1.e3 );
- energy_vec.push_back( clus->e()/1.e3 );
- et_vec.push_back( clus->et()/1.e3 );
+ energyBE0_vec.push_back( clus->energyBE(0)/Gaudi::Units::GeV );
+ energyBE1_vec.push_back( clus->energyBE(1)/Gaudi::Units::GeV );
+ energyBE2_vec.push_back( clus->energyBE(2)/Gaudi::Units::GeV );
+ energyBE3_vec.push_back( clus->energyBE(3)/Gaudi::Units::GeV );
+ energy_vec.push_back( clus->e()/Gaudi::Units::GeV );
+ et_vec.push_back( clus->et()/Gaudi::Units::GeV );
eta_vec.push_back( clus->eta() );
phi_vec.push_back( clus->phi() );
eta_calo_vec.push_back( tmpeta );
@@ -577,8 +577,8 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillShowerShapes(const std::string &tri
if(!eg) continue;
- ethad_vec.push_back( getShowerShape_ethad(eg)/1e3);
- ethad1_vec.push_back( getShowerShape_ethad1(eg)/1e3);
+ ethad_vec.push_back( getShowerShape_ethad(eg)/Gaudi::Units::GeV);
+ ethad1_vec.push_back( getShowerShape_ethad1(eg)/Gaudi::Units::GeV);
Rhad_vec.push_back( getShowerShape_Rhad(eg));
Rhad1_vec.push_back( getShowerShape_Rhad(eg));
Reta_vec.push_back( getShowerShape_Reta(eg));
@@ -588,12 +588,12 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillShowerShapes(const std::string &tri
f1_vec.push_back( getShowerShape_f1(eg));
f3_vec.push_back( getShowerShape_f3(eg));
eratio_vec.push_back( getShowerShape_Eratio(eg));
- et_vec.push_back( eg->pt()/1e3);
- highet_vec.push_back( eg->pt()/1e3);
+ et_vec.push_back( eg->pt()/Gaudi::Units::GeV);
+ highet_vec.push_back( eg->pt()/Gaudi::Units::GeV);
eta_vec.push_back( eg->eta());
phi_vec.push_back( eg->phi());
- topoetcone20_vec.push_back( getIsolation_topoetcone20(eg)/1e3);
- topoetcone40_shift_vec.push_back( (getIsolation_topoetcone40(eg)-2450)/1e3 );
+ topoetcone20_vec.push_back( getIsolation_topoetcone20(eg)/Gaudi::Units::GeV);
+ topoetcone40_shift_vec.push_back( (getIsolation_topoetcone40(eg)-2450)/Gaudi::Units::GeV );
if (eg->pt() > 0) {
topoetcone20_rel_vec.push_back( getIsolation_topoetcone20(eg)/eg->pt());
@@ -667,14 +667,14 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillTracking(const std::string &trigger
npixhits_vec.push_back( getTrackSummary_numberOfPixelHits(eg));
nscthits_vec.push_back( getTrackSummary_numberOfSCTHits(eg));
charge_vec.push_back( eg->charge());
- ptcone20_vec.push_back( getIsolation_ptcone20(eg)/1e3);
- ptvarcone20_vec.push_back( getIsolation_ptvarcone20(eg)/1e3);
+ ptcone20_vec.push_back( getIsolation_ptcone20(eg)/Gaudi::Units::GeV);
+ ptvarcone20_vec.push_back( getIsolation_ptvarcone20(eg)/Gaudi::Units::GeV);
// Quantities directly from tracks
ATH_MSG_DEBUG("Get track Quantities");
d0_vec.push_back( getTrack_d0(eg));
d0sig_vec.push_back(getD0sig(eg));
- pt_vec.push_back( getTrack_pt(eg)/1e3);
+ pt_vec.push_back( getTrack_pt(eg)/Gaudi::Units::GeV);
if (eg->pt() > 0) {
ptcone20_rel_vec.push_back( getIsolation_ptcone20(eg)/eg->pt());
@@ -687,9 +687,1000 @@ void TrigEgammaMonitorAnalysisAlgorithm::fillTracking(const std::string &trigger
fill( monGroup, deta1_col, deta1_EMECA_col, deta1_EMECC_col, deta1_EMEBA_col, deta1_EMEBC_col, deta2_col, dphi2_col,
dphiresc_col, eprobht_col, npixhits_col, nscthits_col, charge_col, ptcone20_col, ptvarcone20_col, d0_col, d0sig_col,
pt_col, ptcone20_rel_col, ptvarcone20_rel_col);
+}
+
+
+
+//!***********************************************************************************************************************8
+//
+//
+
+
+void TrigEgammaMonitorAnalysisAlgorithm::fillResolutions( std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pairObjs,
+ const TrigInfo info ) const
+{
+
+ std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pair_l1_vec;
+ std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pair_eg_vec;
+ const std::string trigger = info.trigName;
+ bool filliso=false;
+ if(boost::contains(info.trigName,"iloose") || boost::contains(info.trigName,"ivarloose")) filliso=true;
+ if(boost::contains(info.trigName,"icaloloose") || boost::contains(info.trigName,"icalovloose") || boost::contains(info.trigName,"icalotight")) filliso=true;
+
+
+ for( auto pairObj : pairObjs ){
+
+ const xAOD::Egamma* eg = pairObj.first;
+ const auto *feat = pairObj.second;
+
+ if (feat){
+ if (info.trigL1){
+ // Get l1 for all level one objects found for each off object
+ auto l1 = match()->getL1Feature( feat );
+ if(l1){
+ pair_l1_vec.push_back( std::make_pair(eg,l1) );
+ }
+ }else{
+ //
+ // Get only off and l1 where the offline object passed by the offline pid selector
+ //
+ auto l1 = match()->getL1Feature( feat );
+ if(eg->type()==xAOD::Type::Electron){
+ const xAOD::Electron* el = static_cast<const xAOD::Electron*>(eg);
+ float et = getEt(el)/Gaudi::Units::GeV;
+ if( et < info.trigThrHLT-5.0) continue;
+ if(!eg->auxdecor<bool>(info.trigPidDecorator)) continue;
+ pair_eg_vec.push_back(std::make_pair(el,feat));
+ if(l1) pair_l1_vec.push_back( std::make_pair(eg,l1) );
+ }
+ else if(eg->type()==xAOD::Type::Photon){
+ float et = getCluster_et(eg)/Gaudi::Units::GeV;
+ if( et < info.trigThrHLT-5.0) continue;
+ pair_eg_vec.push_back(std::make_pair(eg,feat));
+ if(l1) pair_l1_vec.push_back( std::make_pair(eg,l1) );
+ }
+ }
+
+ }
+ }
+
+
+ if (info.trigL1){
+ fillL1CaloResolution( trigger, pair_l1_vec );
+ fillL1CaloAbsResolution( trigger, pair_l1_vec );
+ }else{
+
+ // Fill L1Calo for all level 1 objects found
+ fillL1CaloResolution( trigger, pair_l1_vec );
+ fillL1CaloAbsResolution( trigger, pair_l1_vec );
+ fillL2CaloResolution( trigger, pair_eg_vec );
+
+ // Fill HLT electron for all onl objects found
+ if ( info.trigType=="electron"){
+ fillHLTElectronResolution( trigger, pair_eg_vec, filliso );
+ }
+
+ else if ( info.trigType=="photon"){
+ fillHLTPhotonResolution( trigger, pair_eg_vec, filliso );
+ }
+
+
+ }
+
+}
+
+
+
+
+void TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloResolution(const std::string &trigger,
+ std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pairObjs ) const
+{
+ auto monGroup = getGroup( trigger + "_Resolutions_L1Calo" );
+
+ std::vector<float> eta_vec, res_et_vec;
+
+ auto eta_col = Monitored::Collection( "eta" , eta_vec );
+ auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
+
+
+ for (auto& pairObj : pairObjs){
+ auto off = pairObj.first;
+ auto l1 = pairObj.second;
+ ATH_MSG_DEBUG("Fill L1CaloResolution");
+ if(off->type()==xAOD::Type::Electron){
+ const xAOD::Electron* eloff =static_cast<const xAOD::Electron*> (off);
+ eta_vec.push_back( l1->eta() );
+ res_et_vec.push_back( (l1->emClus()-getEt(eloff))/getEt(eloff) ) ;
+
+ }
+ }
+
+ fill( monGroup, eta_col, res_et_col );
+}
+
+
+
+
+
+void TrigEgammaMonitorAnalysisAlgorithm::fillL1CaloAbsResolution(const std::string &trigger,
+ std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pairObjs ) const
+{
+ auto monGroup = getGroup( trigger + "_AbsResolutions_L1Calo" );
+
+ std::vector<float> eta_vec, res_et_vec;
+
+ auto eta_col = Monitored::Collection( "eta" , eta_vec );
+ auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
+
+
+ for (auto& pairObj : pairObjs){
+ auto off = pairObj.first;
+ auto l1 = pairObj.second;
+ ATH_MSG_DEBUG("Fill L1CaloAbsResolution");
+ if(off->type()==xAOD::Type::Electron){
+ const xAOD::Electron* eloff =static_cast<const xAOD::Electron*> (off);
+ eta_vec.push_back( l1->eta() );
+ res_et_vec.push_back( (l1->emClus()-getEt(eloff))/Gaudi::Units::GeV ) ;
+ }
+ }
+
+ fill( monGroup, eta_col, res_et_col );
+}
+
+
+
+
+void TrigEgammaMonitorAnalysisAlgorithm::fillHLTElectronResolution(const std::string &trigger,
+ std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pairObjs,
+ bool filliso) const
+{
+
+ auto monGroup = getGroup( trigger + "_Resolutions_HLT" );
+
+ 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,
+ res_d0_vec, res_d0sig_vec, res_eprobht_vec, res_npixhits_vec, res_nscthits_vec, res_Rhad_vec, res_Rhad1_vec, res_Reta_vec,
+ 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,
+ et_vec, eta_vec, mu_vec;
+ std::vector<float> res_ptcone20_vec, res_ptcone20_rel_vec, res_ptvarcone20_vec, res_ptvarcone20_rel_vec;
+ std::vector<float> res_etInEta0_vec, res_etInEta1_vec, res_etInEta2_vec, res_etInEta3_vec;
+
+
+ auto et_col = Monitored::Collection( "et" , et_vec );
+ auto eta_col = Monitored::Collection( "eta" , eta_vec );
+ auto mu_col = Monitored::Collection( "mu" , mu_vec );
+
+ // For calo
+ auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
+ auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
+ auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
+ auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
+ auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
+ auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
+ auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
+ auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
+ auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
+ auto res_weta1_col = Monitored::Collection( "res_weta1" , res_weta1_vec );
+ auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
+ auto res_wtots1_col = Monitored::Collection( "res_wtots1" , res_wtots1_vec );
+ auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
+ auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
+ auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
+
+ auto res_etInEta0_col = Monitored::Collection( "res_etInEta0" , res_etInEta0_vec );
+ auto res_etInEta1_col = Monitored::Collection( "res_etInEta1" , res_etInEta1_vec );
+ auto res_etInEta2_col = Monitored::Collection( "res_etInEta2" , res_etInEta2_vec );
+ auto res_etInEta3_col = Monitored::Collection( "res_etInEta3" , res_etInEta3_vec );
+
+ // For electron
+ auto res_pt_col = Monitored::Collection( "res_pt" , res_pt_vec );
+ auto res_deta1_col = Monitored::Collection( "res_deta1" , res_deta1_vec );
+ auto res_deta2_col = Monitored::Collection( "res_deta2" , res_deta2_vec );
+ auto res_dphi2_col = Monitored::Collection( "res_dphi2" , res_dphi2_vec );
+ auto res_dphiresc_col = Monitored::Collection( "res_dphiresc" , res_dphiresc_vec );
+ auto res_d0_col = Monitored::Collection( "res_d0" , res_d0_vec );
+ auto res_d0sig_col = Monitored::Collection( "res_d0sig" , res_d0sig_vec );
+ auto res_eprobht_col = Monitored::Collection( "res_eprobht" , res_eprobht_vec );
+ auto res_npixhits_col = Monitored::Collection( "res_npixhits" , res_npixhits_vec );
+ auto res_nscthits_col = Monitored::Collection( "res_nscthits" , res_nscthits_vec );
+ auto res_ptcone20_col = Monitored::Collection( "res_ptcone20" , res_ptcone20_vec );
+ auto res_ptcone20_rel_col = Monitored::Collection( "res_ptcone20_rel" , res_ptcone20_rel_vec );
+ auto res_ptvarcone20_col = Monitored::Collection( "res_ptvarcone20" , res_ptvarcone20_vec );
+ auto res_ptvarcone20_rel_col = Monitored::Collection( "res_ptvarcone20_rel" , res_ptvarcone20_rel_vec );
+
+
+
+
+ // Check for zero before filling
+ ATH_MSG_DEBUG("Fill Resolution");
+
+
+
+ for ( auto& pairObj : pairObjs ){
+
+ const xAOD::Electron *off = static_cast<const xAOD::Electron*>(pairObj.first);
+ const xAOD::Electron *onl=nullptr;
+
+
+ { // Get the closest electron object from the trigger starting with deltaR = 0.15
+ float maxDeltaR=0.05;
+ auto vec = tdt()->features<xAOD::ElectronContainer>(trigger,TrigDefs::Physics ,match()->key("Electron") );
+ for(auto &featLinkInfo : vec ){
+ if(! featLinkInfo.isValid() ) continue;
+ const auto *feat = *(featLinkInfo.link);
+ if(!feat) continue;
+ float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
+ if( deltaR < maxDeltaR){
+ maxDeltaR=deltaR;
+ onl=feat;
+ }
+ }
+ }
+
+ if(!onl) continue;
+
+ float val_off=0.;
+ const float onl_eta=onl->eta();
+ const float feta = abs(onl_eta);
+ const float onl_et = getEt(onl)/Gaudi::Units::GeV;
+ const float avgmu=lbAverageInteractionsPerCrossing( Gaudi::Hive::currentContext() );
+ const float dummy=dummy;
+
+ eta_vec.push_back( onl_eta );
+ et_vec.push_back( onl_et );
+ mu_vec.push_back( avgmu );
+
+ val_off=getTrack_pt(off);
+ if(val_off!=0.){
+ res_pt_vec.push_back( (getTrack_pt(off)-val_off)/val_off );
+ }else{
+ }
+
+
+ val_off=getEt(off);
+ if(val_off!=0.){
+ res_et_vec.push_back( (getEt(onl)-val_off)/val_off );
+ if( feta < 1.37 )
+ res_etInEta0_vec.push_back((getEt(onl)-val_off)/val_off);
+ else if( feta >=1.37 && feta <= 1.52 )
+ res_etInEta1_vec.push_back((getEt(onl)-val_off)/val_off);
+ else if( feta >= 1.55 && feta < 1.8 )
+ res_etInEta2_vec.push_back((getEt(onl)-val_off)/val_off);
+ else if( feta >= 1.8 && feta < 2.45 )
+ res_etInEta3_vec.push_back((getEt(onl)-val_off)/val_off);
+ }
+
+ val_off=off->eta();
+ if(val_off!=0.){
+ res_eta_vec.push_back( (onl_eta-val_off)/val_off );
+ }else{
+ res_eta_vec.push_back( dummy );
+ }
+
+ val_off=off->phi();
+ if(val_off!=0.){
+ res_phi_vec.push_back( (onl->phi()-val_off)/val_off );
+ }else{
+ res_phi_vec.push_back(dummy );
+ }
+
+ val_off=getShowerShape_ethad(off);
+ if(val_off!=0.) {
+ res_ethad_vec.push_back((getShowerShape_ethad(onl)-val_off)/val_off);
+ }else{
+ res_ethad_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_ethad1(off);
+ if(val_off!=0){
+ res_ethad1_vec.push_back((getShowerShape_ethad1(onl)-val_off)/val_off);
+ }else{
+ res_ethad1_vec.push_back( dummy);
+ }
+
+ val_off=getShowerShape_Rhad(off);
+ if(val_off!=0.){
+ res_Rhad_vec.push_back( (getShowerShape_Rhad(onl)-val_off)/val_off );
+ }else{
+ res_Rhad_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_Rhad1(off);
+ if(val_off!=0.){
+ res_Rhad1_vec.push_back( (getShowerShape_Rhad1(onl)-val_off)/val_off );
+ }else{
+ res_Rhad1_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_Reta(off);
+ if(val_off!=0.){
+ res_Reta_vec.push_back( (getShowerShape_Reta(onl)-val_off)/val_off );
+ }else{
+ res_Reta_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_Rphi(off);
+ if(val_off!=0.){
+ res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
+ }else{
+ res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
+ }
+
+ val_off=getShowerShape_weta1(off);
+ if(val_off!=0.){
+ res_weta1_vec.push_back( (getShowerShape_weta1(onl)-val_off)/val_off );
+ }else{
+ res_weta1_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_weta2(off);
+ if(val_off!=0.){
+ res_weta2_vec.push_back( (getShowerShape_weta2(onl)-val_off)/val_off );
+ }else{
+ res_weta2_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_wtots1(off);
+ if(val_off!=0.){
+ res_wtots1_vec.push_back( (getShowerShape_wtots1(onl)-val_off)/val_off );
+ }else{
+ res_wtots1_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_f1(off);
+ if(val_off!=0.){
+ res_f1_vec.push_back( (getShowerShape_f1(onl)-val_off)/val_off );
+ }else{
+ res_f1_vec.push_back(dummy );
+ }
+
+ val_off=getShowerShape_f3(off);
+ if(val_off!=0.){
+ res_f3_vec.push_back( (getShowerShape_f3(onl)-val_off)/val_off );
+ }else{
+ res_f3_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_Eratio(off);
+ if(val_off!=0.){
+ res_eratio_vec.push_back( (getShowerShape_Eratio(onl)-val_off)/val_off );
+ }else{
+ res_eratio_vec.push_back( dummy );
+ }
+
+
+ //
+ // Track variables
+ //
+
+ val_off=getTrack_pt(off);
+ if(val_off!=0.){
+ res_pt_vec.push_back( (getTrack_pt(onl)-val_off)/val_off );
+ }else{
+ res_pt_vec.push_back( dummy );
+ }
+
+ val_off=getEt(off);
+ if(val_off!=0.) {
+ res_et_vec.push_back( (getEt(onl)-val_off)/val_off );
+ }else{
+ res_et_vec.push_back( dummy );
+ }
+
+ val_off=getCaloTrackMatch_deltaEta1(off);
+ if(val_off!=0.) {
+ res_deta1_vec.push_back( (getCaloTrackMatch_deltaEta1(onl)-val_off)/val_off );
+ }else{
+ res_deta1_vec.push_back( dummy );
+ }
+
+ val_off=getCaloTrackMatch_deltaEta2(off);
+ res_deta2_vec.push_back( (getCaloTrackMatch_deltaEta2(onl)-val_off)/val_off );
+ val_off=getCaloTrackMatch_deltaPhi2(off);
+ if(val_off!=0.) {
+ res_dphi2_vec.push_back( (getCaloTrackMatch_deltaPhi2(onl)-val_off)/val_off );
+ }else{
+ res_dphi2_vec.push_back(dummy );
+ }
+
+ val_off=getCaloTrackMatch_deltaPhiRescaled2(off);
+ res_dphiresc_vec.push_back( (getCaloTrackMatch_deltaPhiRescaled2(onl)-val_off)/val_off );
+ // Absolute resolution for impact parameter
+ val_off=getTrack_d0(off);
+ if(val_off!=0.) {
+ res_d0_vec.push_back( getTrack_d0(onl)-val_off );
+ }else{
+ res_d0_vec.push_back( dummy );
+ }
+
+ val_off=getD0sig(off);
+ if(val_off!=0.) {
+ res_d0sig_vec.push_back( getD0sig(onl)-val_off );
+ }else{
+ res_d0sig_vec.push_back( dummy );
+ }
+
+ // Absolute resolution on track summary ints/floats
+ val_off=getTrackSummaryFloat_eProbabilityHT(off);
+ res_eprobht_vec.push_back( (getTrackSummaryFloat_eProbabilityHT(onl)-val_off) );
+ res_npixhits_vec.push_back( getTrackSummary_numberOfPixelHits(onl)-getTrackSummary_numberOfPixelHits(onl) );
+ res_nscthits_vec.push_back( getTrackSummary_numberOfSCTHits(onl)-getTrackSummary_numberOfSCTHits(onl) );
+
+
+
+
+ if(filliso){
+
+ float val_off=getIsolation_ptcone20(off);
+ if (val_off > 0.) {
+ res_ptcone20_vec.push_back((getIsolation_ptcone20(onl)-val_off)/val_off);
+ if (getEt(onl) > 0. && getEt(off) > 0.) {
+ const float reliso_onl=getIsolation_ptcone20(onl)/getEt(onl);
+ const float reliso_off=getIsolation_ptcone20(off)/getEt(off);
+ res_ptcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
+ }else{
+ res_ptcone20_rel_vec.push_back(dummy);
+ }
+ }else{
+ res_ptcone20_vec.push_back(dummy);
+ res_ptcone20_rel_vec.push_back(dummy);
+ }
+
+ // ptvarcone20 isolation
+ val_off=getIsolation_ptvarcone20(off);
+ if (val_off > 0.) {
+ if (getEt(onl) > 0. && getEt(off) > 0.) {
+ res_ptvarcone20_vec.push_back((getIsolation_ptvarcone20(onl)-val_off)/val_off);
+ const float reliso_onl=getIsolation_ptvarcone20(onl)/getEt(onl);
+ const float reliso_off=getIsolation_ptvarcone20(off)/getEt(off);
+ res_ptvarcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
+ }else{
+ res_ptvarcone20_rel_vec.push_back(dummy);
+ }
+ }else{
+ res_ptvarcone20_vec.push_back(dummy);
+ res_ptvarcone20_rel_vec.push_back(dummy);
+ }
+
+ }
+
+
+
+
+
+ } // Loop over all offline objects
+
+ // Fill everything
+ fill( monGroup ,
+ et_col ,
+ eta_col ,
+ mu_col ,
+ res_pt_col ,
+ res_et_col ,
+ res_eta_col ,
+ res_phi_col ,
+ res_deta1_col ,
+ res_deta2_col ,
+ res_dphi2_col ,
+ res_dphiresc_col,
+ res_d0_col ,
+ res_d0sig_col ,
+ res_eprobht_col ,
+ res_npixhits_col,
+ res_nscthits_col,
+ res_ethad_col ,
+ res_ethad1_col ,
+ res_Rhad_col ,
+ res_Rhad1_col ,
+ res_Reta_col ,
+ res_Rphi_col ,
+ res_weta1_col ,
+ res_weta2_col ,
+ res_wtots1_col ,
+ res_f1_col ,
+ res_f3_col ,
+ res_eratio_col ,
+ res_ptcone20_col ,
+ res_ptcone20_rel_col ,
+ res_ptvarcone20_col ,
+ res_ptvarcone20_rel_col ,
+ res_etInEta0_col,
+ res_etInEta1_col,
+ res_etInEta2_col,
+ res_etInEta3_col );
+
+
+
+}
+
+
+
+
+
+void TrigEgammaMonitorAnalysisAlgorithm::fillHLTPhotonResolution(const std::string &trigger,
+ std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pairObjs,
+ bool filliso) const
+{
+
+ auto monGroup = getGroup( trigger + "_Resolutions_HLT" );
+
+ std::vector<float> res_phi_vec, res_eta_vec, res_Rhad_vec, res_Rhad1_vec, res_Reta_vec, res_ethad_vec, res_ethad1_vec,
+ 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;
+
+ std::vector<float> res_et_vec, res_et_cnv_vec, res_et_uncnv_vec;
+ std::vector<float> res_etInEta0_vec, res_etInEta1_vec, res_etInEta2_vec, res_etInEta3_vec;
+ std::vector<float> res_cnv_etInEta0_vec, res_cnv_etInEta1_vec, res_cnv_etInEta2_vec, res_cnv_etInEta3_vec;
+ std::vector<float> res_uncnv_etInEta0_vec, res_uncnv_etInEta1_vec, res_uncnv_etInEta2_vec, res_uncnv_etInEta3_vec;
+
+
+
+ std::vector<float> res_topoetcone20_vec, res_topoetcone20_rel_vec;
+
+ auto et_col = Monitored::Collection( "et" , et_vec );
+ auto eta_col = Monitored::Collection( "eta" , eta_vec );
+ auto mu_col = Monitored::Collection( "mu" , mu_vec );
+
+ // For calo
+ auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
+ auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
+ auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
+ auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
+ auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
+ auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
+ auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
+ auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
+ auto res_weta1_col = Monitored::Collection( "res_weta1" , res_weta1_vec );
+ auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
+ auto res_wtots1_col = Monitored::Collection( "res_wtots1" , res_wtots1_vec );
+ auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
+ auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
+ auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
+
+
+ auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
+ auto res_et_cnv_col = Monitored::Collection( "res_et_cnv" , res_et_cnv_vec );
+ auto res_et_uncnv_col = Monitored::Collection( "res_et_uncnv" , res_et_uncnv_vec );
+ auto res_etInEta0_col = Monitored::Collection( "res_etInEta0" , res_etInEta0_vec );
+ auto res_etInEta1_col = Monitored::Collection( "res_etInEta1" , res_etInEta1_vec );
+ auto res_etInEta2_col = Monitored::Collection( "res_etInEta2" , res_etInEta2_vec );
+ auto res_etInEta3_col = Monitored::Collection( "res_etInEta3" , res_etInEta3_vec );
+ auto res_cnv_etInEta0_col = Monitored::Collection( "res_cnv_etInEta0" , res_cnv_etInEta0_vec );
+ auto res_cnv_etInEta1_col = Monitored::Collection( "res_cnv_etInEta1" , res_cnv_etInEta1_vec );
+ auto res_cnv_etInEta2_col = Monitored::Collection( "res_cnv_etInEta2" , res_cnv_etInEta2_vec );
+ auto res_cnv_etInEta3_col = Monitored::Collection( "res_cnv_etInEta3" , res_cnv_etInEta3_vec );
+ auto res_uncnv_etInEta0_col = Monitored::Collection( "res_uncnv_etInEta0" , res_uncnv_etInEta0_vec);
+ auto res_uncnv_etInEta1_col = Monitored::Collection( "res_uncnv_etInEta1" , res_uncnv_etInEta1_vec);
+ auto res_uncnv_etInEta2_col = Monitored::Collection( "res_uncnv_etInEta2" , res_uncnv_etInEta2_vec);
+ auto res_uncnv_etInEta3_col = Monitored::Collection( "res_uncnv_etInEta3" , res_uncnv_etInEta3_vec);
+
+ // For photon
+ auto res_topoetcone20_col = Monitored::Collection( "res_topoetcone20" , res_topoetcone20_vec );
+ auto res_topoetcone20_rel_col = Monitored::Collection( "res_topoetcone20_rel" , res_topoetcone20_rel_vec );
+
+
+
+
+ // Check for zero before filling
+ ATH_MSG_DEBUG("Fill Resolution");
+
+
+
+ for ( auto& pairObj : pairObjs ){
+
+ const xAOD::Photon *off = static_cast<const xAOD::Photon*>(pairObj.first);
+ const xAOD::Photon *onl=nullptr;
+
+
+ { // Get the closest electron object from the trigger starting with deltaR = 0.15
+ float maxDeltaR=0.05;
+ auto vec = tdt()->features<xAOD::PhotonContainer>(trigger,TrigDefs::Physics ,match()->key("Photon") );
+ for(auto &featLinkInfo : vec ){
+ if(! featLinkInfo.isValid() ) continue;
+ const auto *feat = *(featLinkInfo.link);
+ if(!feat) continue;
+ float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
+ if( deltaR < maxDeltaR){
+ maxDeltaR=deltaR;
+ onl=feat;
+ }
+ }
+ }
+
+ // If not found, skip this off object!
+ if(!onl) continue;
+
+ float val_off=0.;
+ const float onl_eta=onl->eta();
+ const float feta = abs(onl_eta);
+ const float onl_et = getCluster_et(onl)/Gaudi::Units::GeV;
+ const float dummy=dummy;
+
+ const float avgmu=lbAverageInteractionsPerCrossing( Gaudi::Hive::currentContext() );
+ et_vec.push_back( onl_et );
+ eta_vec.push_back( onl_eta );
+ mu_vec.push_back( avgmu );
+
+
+ val_off=getCluster_et(off);
+ if(val_off!=0.){
+ res_et_vec.push_back( (getCluster_et(onl)-val_off)/val_off );
+ if( feta < 1.37 )
+ res_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >=1.37 && feta <= 1.52 )
+ res_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >= 1.55 && feta < 1.8 )
+ res_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >= 1.8 && feta < 2.45 )
+ res_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+
+ if(xAOD::EgammaHelpers::isConvertedPhoton(off)){
+ res_et_cnv_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ if( feta < 1.37 )
+ res_cnv_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >=1.37 && feta <= 1.52 )
+ res_cnv_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >= 1.55 && feta < 1.8 )
+ res_cnv_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >= 1.8 && feta < 2.45 )
+ res_cnv_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ }else{
+ res_et_uncnv_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ if( feta < 1.37 )
+ res_uncnv_etInEta0_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >=1.37 && feta <= 1.52 )
+ res_uncnv_etInEta1_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >= 1.55 && feta < 1.8 )
+ res_uncnv_etInEta2_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ else if( feta >= 1.8 && feta < 2.45 )
+ res_uncnv_etInEta3_vec.push_back((getCluster_et(onl)-val_off)/val_off);
+ }
+ }
+
+ val_off=off->eta();
+ if(val_off!=0.){
+ res_eta_vec.push_back( (onl_eta-val_off)/val_off ) ;
+ }else{
+ res_eta_vec.push_back( dummy ) ;
+ }
+
+ val_off=off->phi();
+ if(val_off!=0.){
+ res_phi_vec.push_back( (onl->phi()-val_off)/val_off );
+ }else{
+ res_phi_vec.push_back(dummy );
+ }
+
+ val_off=getShowerShape_ethad(off);
+ if(val_off!=0.) {
+ res_ethad_vec.push_back((getShowerShape_ethad(onl)-val_off)/val_off);
+ }else{
+ res_ethad_vec.push_back(dummy);
+ }
+
+ val_off=getShowerShape_ethad1(off);
+ if(val_off!=0){
+ res_ethad1_vec.push_back((getShowerShape_ethad1(onl)-val_off)/val_off);
+ }else{
+ res_ethad1_vec.push_back(dummy);
+ }
+
+ val_off=getShowerShape_Rhad(off);
+ if(val_off!=0.){
+ res_Rhad_vec.push_back( (getShowerShape_Rhad(onl)-val_off)/val_off );
+ }else{
+ res_Rhad_vec.push_back(dummy );
+ }
+
+ val_off=getShowerShape_Rhad1(off);
+ if(val_off!=0.){
+ res_Rhad1_vec.push_back( (getShowerShape_Rhad1(onl)-val_off)/val_off );
+ }else{
+ res_Rhad1_vec.push_back(dummy );
+ }
+
+ val_off=getShowerShape_Reta(off);
+ if(val_off!=0.){
+ res_Reta_vec.push_back( (getShowerShape_Reta(onl)-val_off)/val_off );
+ }else{
+ res_Reta_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_Rphi(off);
+ if(val_off!=0.){
+ res_Rphi_vec.push_back( (getShowerShape_Rphi(onl)-val_off)/val_off );
+ }else{
+ res_Rphi_vec.push_back(dummy );
+ }
+
+ val_off=getShowerShape_weta1(off);
+ if(val_off!=0.){
+ res_weta1_vec.push_back( (getShowerShape_weta1(onl)-val_off)/val_off );
+ }else{
+ res_weta1_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_weta2(off);
+ if(val_off!=0.){
+ res_weta2_vec.push_back( (getShowerShape_weta2(onl)-val_off)/val_off );
+ }else{
+ res_weta2_vec.push_back(dummy);
+ }
+
+ val_off=getShowerShape_wtots1(off);
+ if(val_off!=0.){
+ res_wtots1_vec.push_back( (getShowerShape_wtots1(onl)-val_off)/val_off );
+ }else{
+ res_wtots1_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_f1(off);
+ if(val_off!=0.){
+ res_f1_vec.push_back( (getShowerShape_f1(onl)-val_off)/val_off );
+ }else{
+ res_f1_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_f3(off);
+ if(val_off!=0.){
+ res_f3_vec.push_back( (getShowerShape_f3(onl)-val_off)/val_off );
+ }else{
+ res_f3_vec.push_back( dummy );
+ }
+
+ val_off=getShowerShape_Eratio(off);
+ if(val_off!=0.){
+ res_eratio_vec.push_back( (getShowerShape_Eratio(onl)-val_off)/val_off);
+ }else{
+ res_eratio_vec.push_back( dummy);
+ }
+
+ if( filliso ){
+ // topoetcone20 isolation
+ float val_off=getIsolation_topoetcone20(off);
+ float etonl=onl->pt();
+ float etoff=off->pt();
+ if (val_off > 0.) {
+ res_topoetcone20_vec.push_back((getIsolation_topoetcone20(onl)-val_off)/val_off);
+ if (etonl > 0. && etoff > 0.) {
+ const float reliso_onl=getIsolation_topoetcone20(onl)/etonl;
+ const float reliso_off=getIsolation_topoetcone20(off)/etoff;
+ res_topoetcone20_rel_vec.push_back((reliso_onl-reliso_off)/reliso_off);
+ }else{
+ res_topoetcone20_rel_vec.push_back(dummy);
+ }
+ }else{
+ res_topoetcone20_vec.push_back(dummy);
+ res_topoetcone20_rel_vec.push_back(dummy);
+ }
+ }
+
+
+
+ } // Loop over all offline objects
+
+ // Fill everything
+ fill( monGroup ,
+ et_col ,
+ eta_col ,
+ mu_col ,
+ res_et_col ,
+ res_eta_col ,
+ res_phi_col ,
+ res_ethad_col ,
+ res_ethad1_col ,
+ res_Rhad_col ,
+ res_Rhad1_col ,
+ res_Reta_col ,
+ res_Rphi_col ,
+ res_weta1_col ,
+ res_weta2_col ,
+ res_wtots1_col ,
+ res_f1_col ,
+ res_f3_col ,
+ res_eratio_col ,
+ res_topoetcone20_col ,
+ res_topoetcone20_rel_col ,
+ res_etInEta0_col,
+ res_etInEta1_col,
+ res_etInEta2_col,
+ res_etInEta3_col,
+ res_et_uncnv_col,
+ res_cnv_etInEta0_col,
+ res_cnv_etInEta1_col,
+ res_cnv_etInEta2_col,
+ res_cnv_etInEta3_col,
+ res_et_cnv_col,
+ res_uncnv_etInEta0_col,
+ res_uncnv_etInEta1_col,
+ res_uncnv_etInEta2_col,
+ res_uncnv_etInEta3_col
+ );
+
}
+void TrigEgammaMonitorAnalysisAlgorithm::fillL2CaloResolution(const std::string &trigger,
+ std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pairObjs ) const
+
+{
+ ATH_MSG_DEBUG("Fill L2Calo Resolution");
+
+ auto monGroup = getGroup( trigger + "_Resolutions_L2Calo" );
+
+ 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,
+ res_Rphi_vec, res_weta2_vec, res_f1_vec, res_f3_vec, res_eratio_vec, et_vec, eta_vec;
+
+
+ auto et_col = Monitored::Collection( "et" , et_vec );
+ auto eta_col = Monitored::Collection( "eta" , eta_vec );
+ auto res_et_col = Monitored::Collection( "res_et" , res_et_vec );
+ auto res_eta_col = Monitored::Collection( "res_eta" , res_eta_vec );
+ auto res_phi_col = Monitored::Collection( "res_phi" , res_phi_vec );
+ auto res_ethad_col = Monitored::Collection( "res_ethad" , res_ethad_vec );
+ auto res_ethad1_col = Monitored::Collection( "res_ethad1" , res_ethad1_vec );
+ auto res_Rhad_col = Monitored::Collection( "res_Rhad" , res_Rhad_vec );
+ auto res_Rhad1_col = Monitored::Collection( "res_Rhad1" , res_Rhad1_vec );
+ auto res_Reta_col = Monitored::Collection( "res_Reta" , res_Reta_vec );
+ auto res_Rphi_col = Monitored::Collection( "res_Rphi" , res_Rphi_vec );
+ auto res_weta2_col = Monitored::Collection( "res_weta2" , res_weta2_vec );
+ auto res_f1_col = Monitored::Collection( "res_f1" , res_f1_vec );
+ auto res_f3_col = Monitored::Collection( "res_f3" , res_f3_vec );
+ auto res_eratio_col = Monitored::Collection( "res_eratio" , res_eratio_vec );
+
+
+ for ( auto& pairObj : pairObjs ){
+
+
+ const xAOD::Egamma *off = pairObj.first;
+ const xAOD::TrigEMCluster *onl=nullptr;
+
+ { // Get the closest electron object from the trigger starting with deltaR = 0.15
+ float maxDeltaR=0.05;
+ auto vec = tdt()->features<xAOD::TrigEMClusterContainer>(trigger,TrigDefs::Physics ,match()->key("L2Calo") );
+ for(auto &featLinkInfo : vec ){
+ if(! featLinkInfo.isValid() ) continue;
+ const auto *feat = *(featLinkInfo.link);
+ if(!feat) continue;
+ float deltaR = dR( off->eta(), off->phi(), feat->eta(), feat->phi() );
+ if( deltaR < maxDeltaR){
+ maxDeltaR=deltaR;
+ onl=feat;
+ }
+ }
+ }
+
+ if(!onl) continue;
+
+ et_vec.push_back(onl->et()*1e-3);
+ eta_vec.push_back(onl->eta());
+ const float dummy=-999;
+
+ float val_off=0.;
+
+ val_off=off->caloCluster()->et();
+ if(val_off!=0.){
+ res_et_vec.push_back(((onl->et())-val_off)/val_off);
+ }else{
+ res_et_vec.push_back(dummy);
+ }
+
+ val_off=off->caloCluster()->eta();
+ if(val_off!=0.){
+ res_eta_vec.push_back((onl->eta()-val_off)/val_off);
+ }else{
+ res_eta_vec.push_back(dummy);
+ }
+
+ val_off=off->caloCluster()->phi();
+ if(val_off!=0.){
+ res_phi_vec.push_back((onl->phi()-val_off)/val_off);
+ }else{
+ res_phi_vec.push_back((onl->phi()-val_off)/val_off);
+ }
+
+ float elonl_ethad = onl->energy( CaloSampling::HEC0 ); elonl_ethad += onl->energy( CaloSampling::HEC1 );
+ elonl_ethad += onl->energy( CaloSampling::HEC2 ); elonl_ethad += onl->energy( CaloSampling::HEC3 );
+ elonl_ethad += onl->energy( CaloSampling::TileBar0 ); elonl_ethad += onl->energy( CaloSampling::TileExt0 );
+ elonl_ethad += onl->energy( CaloSampling::TileBar1 ); elonl_ethad += onl->energy( CaloSampling::TileExt1 );
+ elonl_ethad += onl->energy( CaloSampling::TileBar2 ); elonl_ethad += onl->energy( CaloSampling::TileExt2 );
+ elonl_ethad /= TMath::CosH(onl->eta() );
+ val_off=getShowerShape_ethad(off);
+ if(val_off!=0.){
+ res_ethad_vec.push_back((elonl_ethad-val_off)/val_off);
+ }else{
+ res_ethad_vec.push_back(dummy);
+ }
+
+ val_off=getShowerShape_ethad1(off);
+ if(val_off!=0.){
+ res_ethad1_vec.push_back(( (onl->ehad1()/TMath::Abs(onl->eta()) )-val_off)/val_off);
+ }else{
+ res_ethad1_vec.push_back(dummy);
+ }
+
+ float elonl_Rhad = elonl_ethad / onl->energy() ;
+ val_off=getShowerShape_Rhad(off);
+ if(val_off!=0.){
+ res_Rhad_vec.push_back(( elonl_Rhad-val_off)/val_off);
+ }else{
+ res_Rhad_vec.push_back(dummy);
+ }
+
+ float elonl_Rhad1 = onl->ehad1() / onl->energy() ;
+ val_off=getShowerShape_Rhad1(off);
+ if(val_off!=0.){
+ res_Rhad1_vec.push_back(( elonl_Rhad1-val_off)/val_off);
+ }else{
+ res_Rhad1_vec.push_back(dummy);
+ }
+
+ float onl_reta= 999.0;
+ if ( fabsf ( onl->e277() ) > 0.01 ) onl_reta = onl->e237() / onl->e277();
+ val_off=getShowerShape_Reta(off);
+ if(val_off!=0.){
+ res_Reta_vec.push_back( (onl_reta -val_off)/val_off);
+ }else{
+ res_Reta_vec.push_back(dummy);
+ }
+
+ val_off=getShowerShape_weta2(off);
+ if(val_off!=0.){
+ res_weta2_vec.push_back(( (onl->weta2())-val_off)/val_off);
+ }else{
+ res_weta2_vec.push_back(dummy);
+ }
+
+ float onl_f1 = onl->energy(CaloSampling::EMB1)+onl->energy(CaloSampling::EME1);
+ onl_f1 /= onl->energy();
+ val_off=getShowerShape_f1(off);
+ if(val_off!=0.){
+ res_f1_vec.push_back(( (onl_f1)-val_off)/val_off);
+ }else{
+ res_f1_vec.push_back(dummy);
+ }
+
+ float onl_f3 = onl->energy(CaloSampling::EMB3)+onl->energy(CaloSampling::EME3);
+ onl_f3 /= onl->energy();
+ val_off=getShowerShape_f3(off);
+ if(val_off!=0.){
+ res_f3_vec.push_back(( (onl_f3)-val_off)/val_off);
+ }else{
+ res_f3_vec.push_back(dummy);
+ }
+
+ float onl_eratio = 999.0;
+ if ( fabsf(onl->emaxs1() + onl->e2tsts1()) > 0.01 )
+ onl_eratio = (onl->emaxs1() - onl->e2tsts1()) / (onl->emaxs1() + onl->e2tsts1());
+ val_off=getShowerShape_Eratio(off);
+ if(val_off!=0.){
+ res_eratio_vec.push_back(( (onl_eratio)-val_off)/val_off);
+ }else{
+ res_eratio_vec.push_back(dummy);
+ }
+
+ }// Loop over all pair objects
+
+
+ // Fill everything
+ fill( monGroup ,
+ et_col ,
+ eta_col ,
+ res_et_col ,
+ res_eta_col ,
+ res_phi_col ,
+ res_ethad_col ,
+ res_ethad1_col ,
+ res_Rhad_col ,
+ res_Rhad1_col ,
+ res_Reta_col ,
+ res_Rphi_col ,
+ res_weta2_col ,
+ res_f1_col ,
+ res_f3_col ,
+ res_eratio_col
+ );
+
+}
+
diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorAnalysisAlgorithm.h b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorAnalysisAlgorithm.h
index 20e465d1187471ed3fab68fb93c7fb060fe414fe..67b3711d3076f722191ee7548a1ba91b770d9342 100644
--- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorAnalysisAlgorithm.h
+++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorAnalysisAlgorithm.h
@@ -21,15 +21,19 @@ class TrigEgammaMonitorAnalysisAlgorithm: public TrigEgammaMonitorBaseAlgorithm
protected:
void fillLabel( const ToolHandle<GenericMonitoringTool>& groupHandle, const std::string &histname, const std::string &label ) const;
+ void fillEfficiencies( std::vector< std::pair<const xAOD::Egamma*, const TrigCompositeUtils::Decision*> > , TrigInfo ) const;
+ void fillDistributions( std::vector< std::pair<const xAOD::Egamma*, const TrigCompositeUtils::Decision*> > , TrigInfo ) const;
+ void fillResolutions( std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pairObjs, const TrigInfo info ) const;
+
+ private:
// Efficiency monitoring
- void fillEfficiencies( std::vector< std::pair<const xAOD::Egamma*, const TrigCompositeUtils::Decision*> > , TrigInfo ) const;
void fillEfficiency( const std::string &subgroup, const std::string &level, const std::string &pidword, const TrigInfo info,
std::vector< std::pair< const xAOD::Egamma *, const TrigCompositeUtils::Decision* >> pairObjs) const;
- void fillDistributions( std::vector< std::pair<const xAOD::Egamma*, const TrigCompositeUtils::Decision*> > , TrigInfo ) const;
+ // Disribution monitoring
void fillL1Calo( const std::string &trigger, std::vector< const xAOD::EmTauRoI* > l1_vec ) const;
void fillL2Calo(const std::string &trigger, std::vector< const xAOD::TrigEMCluster*> emCluster_vec ) const;
void fillL2Electron(const std::string &trigger, std::vector<const xAOD::TrigElectron*> el_vec) const;
@@ -38,6 +42,13 @@ class TrigEgammaMonitorAnalysisAlgorithm: public TrigEgammaMonitorBaseAlgorithm
void fillTracking(const std::string &trigger, std::vector<const xAOD::Electron *> eg_vec, bool online ) const;
+ // Resolution monitoring
+ void fillL1CaloResolution(const std::string &trigger, std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pairObjs ) const;
+ void fillL1CaloAbsResolution(const std::string &trigger, std::vector< std::pair< const xAOD::Egamma*, const xAOD::EmTauRoI * >> pairObjs ) const;
+ void fillL2CaloResolution(const std::string &trigger, std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pairObjs ) const;
+ void fillHLTElectronResolution(const std::string &trigger, std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pairObjs , bool) const;
+ void fillHLTPhotonResolution(const std::string &trigger, std::vector< std::pair< const xAOD::Egamma*, const TrigCompositeUtils::Decision * >> pairObjs , bool) const;
+
};
#endif
diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorBaseAlgorithm.cxx b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorBaseAlgorithm.cxx
index 3e4b5b5e088bc8763daf9081d68f2f98ee8b4cfa..a3b0cffeca07b72352ec71f21abbde3153655dca 100644
--- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorBaseAlgorithm.cxx
+++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorBaseAlgorithm.cxx
@@ -143,7 +143,7 @@ asg::AcceptData TrigEgammaMonitorBaseAlgorithm::setAccept( const TrigCompositeUt
for(const auto cut:m_trigLevel) accept.addCut(cut,cut);
asg::AcceptData acceptData (&accept);
-
+
bool passedL1Calo=false;
bool passedL2Calo=false;
bool passedEFCalo=false;
@@ -151,6 +151,8 @@ asg::AcceptData TrigEgammaMonitorBaseAlgorithm::setAccept( const TrigCompositeUt
bool passedEFTrk=false;
bool passedEF=false;
+
+
auto trigger = info.trigName;
passedL1Calo = match()->ancestorPassed<TrigRoiDescriptorCollection>( dec , trigger , "initialRois");
diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorElectronAlgorithm.cxx b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorElectronAlgorithm.cxx
index 52b9dae1a9cabf735ed75dcd25561fbe8402a86b..914408c551b37eaa315a37f5b7e4d20704e3508b 100644
--- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorElectronAlgorithm.cxx
+++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorElectronAlgorithm.cxx
@@ -4,7 +4,6 @@
#include "TrigEgammaMonitorElectronAlgorithm.h"
-
using namespace Trig;
@@ -61,7 +60,6 @@ StatusCode TrigEgammaMonitorElectronAlgorithm::fillHistograms( const EventContex
std::vector< std::pair<const xAOD::Egamma*, const TrigCompositeUtils::Decision*>> pairObjs;
-
if ( executeNavigation( ctx, info.trigName,info.trigThrHLT,info.trigPidType, pairObjs).isFailure() )
{
ATH_MSG_WARNING("executeNavigation Fails");
@@ -70,15 +68,14 @@ StatusCode TrigEgammaMonitorElectronAlgorithm::fillHistograms( const EventContex
-
fillDistributions( pairObjs, info );
fillEfficiencies( pairObjs, info );
+ fillResolutions( pairObjs, info );
ATH_MSG_DEBUG("End Chain Analysis ============================= " << trigger);
} // End loop over trigger list
-
return StatusCode::SUCCESS;
}
diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorPhotonAlgorithm.cxx b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorPhotonAlgorithm.cxx
index cee8d2319df122c632b21dd772bf11ca4dfb916c..78f5a2655640cc1b796af7781352dd60590e1fd5 100644
--- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorPhotonAlgorithm.cxx
+++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorPhotonAlgorithm.cxx
@@ -69,6 +69,7 @@ StatusCode TrigEgammaMonitorPhotonAlgorithm::fillHistograms( const EventContext&
fillDistributions( pairObjs, info );
fillEfficiencies( pairObjs, info );
+ fillResolutions( pairObjs, info );
ATH_MSG_DEBUG("End Chain Analysis ============================= " << trigger);
diff --git a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorTagAndProbeAlgorithm.cxx b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorTagAndProbeAlgorithm.cxx
index 165c25862711f6f28ce435e3d11ddf4f4912b5d7..732925f052bfd5d65afa0ac6ed769957608f05a8 100644
--- a/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorTagAndProbeAlgorithm.cxx
+++ b/Trigger/TrigMonitoring/TrigEgammaMonitoring/src/TrigEgammaMonitorTagAndProbeAlgorithm.cxx
@@ -114,6 +114,7 @@ StatusCode TrigEgammaMonitorTagAndProbeAlgorithm::fillHistograms( const EventCon
fillDistributions( pairObjs, info );
fillEfficiencies( pairObjs, info );
+ fillResolutions( pairObjs, info );
@@ -265,7 +266,7 @@ bool TrigEgammaMonitorTagAndProbeAlgorithm::executeTandP( const EventContext& ct
probeElectrons.push_back(selProbe);
- auto mon_count_probe= Monitored::Scalar<std::string>(m_anatype+"_PorbeCutCounter","GoodProbe");
+ auto mon_count_probe= Monitored::Scalar<std::string>(m_anatype+"_ProbeCutCounter","GoodProbe");
auto mon_mee = Monitored::Scalar<float>(m_anatype+"_Mee" , tpPairMass/1.e3 );
fill( monGroup , mon_count_probe, mon_mee );
}