diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/CMakeLists.txt b/Trigger/TrigHypothesis/TrigEgammaHypo/CMakeLists.txt
index 32ff89c5af045076ceaae0ccd3cfba7535556814..c857d044f3dca80f8dec9497f8092bc77029f723 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/CMakeLists.txt
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/CMakeLists.txt
@@ -19,12 +19,12 @@ atlas_add_component( TrigEgammaHypo
atlas_install_python_modules( python/*.py POST_BUILD_CMD ${ATLAS_FLAKE8} --extend-extensions=ATL900,ATL901 )
# Unit tests:
-atlas_add_test( TrigL2CaloHypoToolConfig
- SCRIPT python -m TrigEgammaHypo.TrigL2CaloHypoTool
+atlas_add_test( TrigEgammaFastCaloHypoToolConfig
+ SCRIPT python -m TrigEgammaHypo.TrigEgammaFastCaloHypoTool
POST_EXEC_SCRIPT nopost.sh )
-atlas_add_test( TrigL2ElectronHypoToolConfig
- SCRIPT python -m TrigEgammaHypo.TrigL2ElectronHypoTool
+atlas_add_test( TrigEgammaFastElectronHypoToolConfig
+ SCRIPT python -m TrigEgammaHypo.TrigEgammaFastElectronHypoTool
POST_EXEC_SCRIPT nopost.sh )
atlas_add_test( TrigL2PhotonHypoToolConfig
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2CaloHypoTool.py b/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastCaloHypoTool.py
similarity index 92%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2CaloHypoTool.py
rename to Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastCaloHypoTool.py
index 5db4c76063479d63301224334a444fda400b2bd1..00ad67a5637381118c757d708b2f187fc5c19cf7 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2CaloHypoTool.py
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastCaloHypoTool.py
@@ -13,7 +13,7 @@ _possibleSel = { 'tight':'Tight', 'medium':'Medium', 'loose':'Loose', 'vloose':
from AthenaCommon.Logging import logging
-log = logging.getLogger('TrigL2CaloHypoTool')
+log = logging.getLogger('TrigEgammaFastCaloHypoTool')
def _GetPath( cand, sel, basepath = 'RingerSelectorTools/TrigL2_20180903_v9' ):
@@ -39,7 +39,7 @@ def _IncTool(name, cand, threshold, sel):
possibleSel = L2CaloCutMaps( threshold ).MapsHADETthr.keys()
from AthenaConfiguration.ComponentFactory import CompFactory
- tool = CompFactory.TrigL2CaloHypoToolInc( name )
+ tool = CompFactory.TrigEgammaFastCaloHypoToolInc( name )
tool.AcceptAll = False
tool.UseRinger = False
@@ -164,11 +164,11 @@ def _IncTool(name, cand, threshold, sel):
def _MultTool(name):
from AthenaConfiguration.ComponentFactory import CompFactory
- return CompFactory.TrigL2CaloHypoToolMult( name )
+ return CompFactory.TrigEgammaFastCaloHypoToolMult( name )
-def TrigL2CaloHypoToolFromDict( d ):
+def TrigEgammaFastCaloHypoToolFromDict( d ):
""" Use menu decoded chain dictionary to configure the tool """
cparts = [i for i in d['chainParts'] if ((i['signature']=='Electron') or (i['signature']=='Photon'))]
@@ -202,38 +202,38 @@ def TrigL2CaloHypoToolFromDict( d ):
return _IncTool( name, __cand( cparts[0]), __th( cparts[0]), __sel( cparts[0]))
-def TrigL2CaloHypoToolFromName( name, conf ):
+def TrigEgammaFastCaloHypoToolFromName( name, conf ):
""" To be phased out """
""" set the name of the HypoTool (name=chain) and figure out the threshold and selection from conf """
from TriggerMenuMT.HLTMenuConfig.Menu.DictFromChainName import dictFromChainName
decodedDict = dictFromChainName(conf)
- return TrigL2CaloHypoToolFromDict( decodedDict )
+ return TrigEgammaFastCaloHypoToolFromDict( decodedDict )
if __name__ == "__main__":
TriggerFlags.enableMonitoring=['Validation']
- t = TrigL2CaloHypoToolFromName( "HLT_e10_etcut_L1EM3","HLT_e10_etcut_L1EM3" )
+ t = TrigEgammaFastCaloHypoToolFromName( "HLT_e10_etcut_L1EM3","HLT_e10_etcut_L1EM3" )
assert t, "cant configure EtCut"
- t = TrigL2CaloHypoToolFromName( "HLT_2e5_etcut_L12EM3", "HLT_2e5_etcut_L12EM3" )
+ t = TrigEgammaFastCaloHypoToolFromName( "HLT_2e5_etcut_L12EM3", "HLT_2e5_etcut_L12EM3" )
assert t, "cant configure symmetric selection"
assert len(t.SubTools) == 2, "Sub-tools not configured"
- t = TrigL2CaloHypoToolFromName( "HLT_3e5_etcut_L13EM3", "HLT_3e5_etcut_L13EM3" )
+ t = TrigEgammaFastCaloHypoToolFromName( "HLT_3e5_etcut_L13EM3", "HLT_3e5_etcut_L13EM3" )
assert t, "cant configure symmetric selection"
assert len(t.SubTools) == 3, "Sub-tools not configured"
# Asymmetric chais not working with this. Commenting out for now
- # t = TrigL2CaloHypoToolFromName( "HLT_e3_etcut_e5_etcut_L12EM3", "HLT_e3_etcut_e5_etcut_L12EM3" )
+ # t = TrigEgammaFastCaloHypoToolFromName( "HLT_e3_etcut_e5_etcut_L12EM3", "HLT_e3_etcut_e5_etcut_L12EM3" )
# assert t, "cant configure asymmetric selection"
# assert len(t.SubTools) == 2, "Sub-tools not configured"
- t = TrigL2CaloHypoToolFromName( "HLT_e3_etcut_e5_etcut_mu6_L1EM3_MU3", "HLT_e3_etcut_e5_etcut_L1EM3_MU3" )
+ t = TrigEgammaFastCaloHypoToolFromName( "HLT_e3_etcut_e5_etcut_mu6_L1EM3_MU3", "HLT_e3_etcut_e5_etcut_L1EM3_MU3" )
assert t, "cant configure asymmetric selection for combined chains"
assert len(t.SubTools) == 2, "Sub-tools not configured"
- log.info("TrigL2CaloHypoToolFromName ALL OK" )
+ log.info("TrigEgammaFastCaloHypoToolFromName ALL OK" )
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2ElectronFexMTConfig.py b/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastElectronFexMTConfig.py
similarity index 54%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2ElectronFexMTConfig.py
rename to Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastElectronFexMTConfig.py
index 5bf6d921356a4019f821af5e70edc6051cb1d5c9..07891a3f43df48c0c9ec4f88055915e985131db8 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2ElectronFexMTConfig.py
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastElectronFexMTConfig.py
@@ -1,6 +1,6 @@
# Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-from TrigEgammaHypo.TrigEgammaHypoConf import TrigL2ElectronFexMT
+from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastElectronFexMT
from AthenaCommon.SystemOfUnits import GeV, mm
from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
@@ -11,10 +11,10 @@ ParticleCaloExtensionTool= Trk__ParticleCaloExtensionTool(Extrapolator = AtlasEx
# ---------------------------------------------------------------
# class for common setups (like monitoring)
-class L2ElectronFexBase(TrigL2ElectronFexMT):
+class EgammaFastElectronFexBase(TrigEgammaFastElectronFexMT):
__slots__ = []
def __init__(self, name):
- super(L2ElectronFexBase,self).__init__(name)
+ super(EgammaFastElectronFexBase,self).__init__(name)
# Tracking cuts
self.TrackPt = 1.0 * GeV
@@ -33,26 +33,26 @@ class L2ElectronFexBase(TrigL2ElectronFexMT):
from TriggerJobOpts.TriggerFlags import TriggerFlags
if 'Validation' in TriggerFlags.enableMonitoring() or 'Online' in TriggerFlags.enableMonitoring():
monTool = GenericMonitoringTool('MonTool')
- monTool.defineHistogram('CaloTrackdEta', path='EXPERT', type='TH1F', title="L2Electron Hypo #Delta #eta between cluster and track;#Delta #eta;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
- monTool.defineHistogram('CaloTrackdPhi', path='EXPERT', type='TH1F', title="L2Electron Hypo #Delta #phi between cluster and track;#Delta #phi;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
- monTool.defineHistogram('CaloTrackEoverP', path='EXPERT', type='TH1F', title="L2Electron Hypo E/p;E/p;Nevents", xbins=120, xmin=0, xmax=12)
- monTool.defineHistogram('PtTrack', path='EXPERT', type='TH1F', title="L2Electron Hypo p_{T}^{track} [MeV];p_{T}^{track} [MeV];Nevents", xbins=50, xmin=0, xmax=100000)
- monTool.defineHistogram('PtCalo', path='EXPERT', type='TH1F', title="L2Electron Hypo p_{T}^{calo} [MeV];p_{T}^{calo} [MeV];Nevents", xbins=50, xmin=0, xmax=100000)
- monTool.defineHistogram('CaloEta',path='EXPERT', type='TH1F', title="L2Electron Hypo #eta^{calo} ; #eta^{calo};Nevents", xbins=200, xmin=-2.5, xmax=2.5)
- monTool.defineHistogram('CaloPhi', path='EXPERT', type='TH1F', title="L2Electron Hypo #phi^{calo} ; #phi^{calo};Nevents", xbins=320, xmin=-3.2, xmax=3.2)
- monTool.defineHistogram('CaloTrackdEtaNoExtrapMon', path='EXPERT',type='TH1F', title="L2Electron Fex #Delta #eta between cluster and track;#Delta #eta;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
+ monTool.defineHistogram('CaloTrackdEta', path='EXPERT', type='TH1F', title="FastElectron Hypo #Delta #eta between cluster and track;#Delta #eta;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
+ monTool.defineHistogram('CaloTrackdPhi', path='EXPERT', type='TH1F', title="FastElectron Hypo #Delta #phi between cluster and track;#Delta #phi;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
+ monTool.defineHistogram('CaloTrackEoverP', path='EXPERT', type='TH1F', title="FastElectron Hypo E/p;E/p;Nevents", xbins=120, xmin=0, xmax=12)
+ monTool.defineHistogram('PtTrack', path='EXPERT', type='TH1F', title="FastElectron Hypo p_{T}^{track} [MeV];p_{T}^{track} [MeV];Nevents", xbins=50, xmin=0, xmax=100000)
+ monTool.defineHistogram('PtCalo', path='EXPERT', type='TH1F', title="FastElectron Hypo p_{T}^{calo} [MeV];p_{T}^{calo} [MeV];Nevents", xbins=50, xmin=0, xmax=100000)
+ monTool.defineHistogram('CaloEta',path='EXPERT', type='TH1F', title="FastElectron Hypo #eta^{calo} ; #eta^{calo};Nevents", xbins=200, xmin=-2.5, xmax=2.5)
+ monTool.defineHistogram('CaloPhi', path='EXPERT', type='TH1F', title="FastElectron Hypo #phi^{calo} ; #phi^{calo};Nevents", xbins=320, xmin=-3.2, xmax=3.2)
+ monTool.defineHistogram('CaloTrackdEtaNoExtrapMon', path='EXPERT',type='TH1F', title="FastElectron Fex #Delta #eta between cluster and track;#Delta #eta;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
self.MonTool = monTool
# ---------------------------------------------------------------
-# TrigL2ElectronFex configurations
+# TrigEgammaFastElectronFex configurations
# ---------------------------------------------------------------
-class L2ElectronFex_all(L2ElectronFexBase):
+class EgammaFastElectronFex_all(EgammaFastElectronFexBase):
__slots__ = []
- def __init__(self,name="L2ElectronFex_all"):
- super(L2ElectronFex_all, self).__init__(name)
+ def __init__(self,name="EgammaFastElectronFex_all"):
+ super(EgammaFastElectronFex_all, self).__init__(name)
# AcceptAll flag: if true take events regardless of cuts
self.AcceptAll = False
@@ -61,30 +61,30 @@ class L2ElectronFex_all(L2ElectronFexBase):
self.RCalBarrelFace = 1470.0*mm
self.ZCalEndcapFace = 3800.0*mm
-class L2ElectronFex_1(L2ElectronFex_all):
+class EgammaFastElectronFex_1(EgammaFastElectronFex_all):
__slots__ = []
- def __init__(self,name="L2ElectronFex_1"):
- super(L2ElectronFex_1, self).__init__(name)
+ def __init__(self,name="EgammaFastElectronFex_1"):
+ super(EgammaFastElectronFex_1, self).__init__(name)
self.AcceptAll = True
-class L2ElectronFex_Clean(L2ElectronFex_all):
+class EgammaFastElectronFex_Clean(EgammaFastElectronFex_all):
__slots__ = []
- def __init__(self,name="L2ElectronFex_Clean"):
- super(L2ElectronFex_Clean, self).__init__(name)
+ def __init__(self,name="EgammaFastElectronFex_Clean"):
+ super(EgammaFastElectronFex_Clean, self).__init__(name)
self.AcceptAll = False
self.CaloTrackdETA = 0.2
self.CaloTrackdPHI = 0.3
-class L2ElectronFex_LowPt(L2ElectronFex_all):
+class EgammaFastElectronFex_LowPt(EgammaFastElectronFex_all):
__slots__ = []
- def __init__(self,name="L2ElectronFex_LowPt"):
- super(L2ElectronFex_1, self).__init__(name)
+ def __init__(self,name="EgammaFastElectronFex_LowPt"):
+ super(EgammaFastElectronFex_1, self).__init__(name)
self.AcceptAll = False
-class L2ElectronFex_HighPt(L2ElectronFex_all):
+class EgammaFastElectronFex_HighPt(EgammaFastElectronFex_all):
__slots__ = []
- def __init__(self,name="L2ElectronFex_HighPt"):
- super(L2ElectronFex_1, self).__init__(name)
+ def __init__(self,name="EgammaFastElectronFex_HighPt"):
+ super(EgammaFastElectronFex_1, self).__init__(name)
self.AcceptAll = False
self.TrackPt = 2.0 * GeV
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2ElectronHypoTool.py b/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastElectronHypoTool.py
similarity index 68%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2ElectronHypoTool.py
rename to Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastElectronHypoTool.py
index c2eb94a1b687776c26ceabf946a46fa437bd0e1d..abbc46d60ad1938286433b9dcb9c92ae31307542 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigL2ElectronHypoTool.py
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEgammaFastElectronHypoTool.py
@@ -8,9 +8,9 @@ from AthenaMonitoringKernel.GenericMonitoringTool import GenericMonitoringTool
-log = logging.getLogger('TrigL2ElectronHypoTool')
+log = logging.getLogger('TrigEgammaFastElectronHypoTool')
-def TrigL2ElectronHypoToolFromDict( chainDict ):
+def TrigEgammaFastElectronHypoToolFromDict( chainDict ):
""" Use menu decoded chain dictionary to configure the tool """
cparts = [i for i in chainDict['chainParts'] if i['signature']=='Electron']
@@ -18,19 +18,19 @@ def TrigL2ElectronHypoToolFromDict( chainDict ):
name = chainDict['chainName']
from AthenaConfiguration.ComponentFactory import CompFactory
- tool = CompFactory.TrigL2ElectronHypoTool(name)
+ tool = CompFactory.TrigEgammaFastElectronHypoTool(name)
monTool = GenericMonitoringTool("MonTool"+name)
- monTool.defineHistogram('CutCounter', type='TH1I', path='EXPERT', title="L2Electron Hypo Cut Counter;Cut Counter", xbins=8, xmin=-1.5, xmax=7.5, opt="kCumulative")
- monTool.defineHistogram('CaloTrackdEta', type='TH1F', path='EXPERT', title="L2Electron Hypo #Delta #eta between cluster and track;#Delta #eta;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
- monTool.defineHistogram('CaloTrackdPhi', type='TH1F', path='EXPERT', title="L2Electron Hypo #Delta #phi between cluster and track;#Delta #phi;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
- monTool.defineHistogram('CaloTrackEoverP', type='TH1F', path='EXPERT', title="L2Electron Hypo E/p;E/p;Nevents", xbins=120, xmin=0, xmax=12)
- monTool.defineHistogram('PtTrack', type='TH1F', path='EXPERT', title="L2Electron Hypo p_{T}^{track} [MeV];p_{T}^{track} [MeV];Nevents", xbins=50, xmin=0, xmax=100000)
- monTool.defineHistogram('PtCalo', type='TH1F', path='EXPERT', title="L2Electron Hypo p_{T}^{calo} [MeV];p_{T}^{calo} [MeV];Nevents", xbins=50, xmin=0, xmax=100000)
- monTool.defineHistogram('CaloEta', type='TH1F', path='EXPERT', title="L2Electron Hypo #eta^{calo} ; #eta^{calo};Nevents", xbins=200, xmin=-2.5, xmax=2.5)
- monTool.defineHistogram('CaloPhi', type='TH1F', path='EXPERT', title="L2Electron Hypo #phi^{calo} ; #phi^{calo};Nevents", xbins=320, xmin=-3.2, xmax=3.2)
-
- monTool.HistPath = 'L2ElectronHypo/'+tool.getName()
+ monTool.defineHistogram('CutCounter', type='TH1I', path='EXPERT', title="FastElectron Hypo Cut Counter;Cut Counter", xbins=8, xmin=-1.5, xmax=7.5, opt="kCumulative")
+ monTool.defineHistogram('CaloTrackdEta', type='TH1F', path='EXPERT', title="FastElectron Hypo #Delta #eta between cluster and track;#Delta #eta;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
+ monTool.defineHistogram('CaloTrackdPhi', type='TH1F', path='EXPERT', title="FastElectron Hypo #Delta #phi between cluster and track;#Delta #phi;Nevents", xbins=80, xmin=-0.4, xmax=0.4)
+ monTool.defineHistogram('CaloTrackEoverP', type='TH1F', path='EXPERT', title="FastElectron Hypo E/p;E/p;Nevents", xbins=120, xmin=0, xmax=12)
+ monTool.defineHistogram('PtTrack', type='TH1F', path='EXPERT', title="FastElectron Hypo p_{T}^{track} [MeV];p_{T}^{track} [MeV];Nevents", xbins=50, xmin=0, xmax=100000)
+ monTool.defineHistogram('PtCalo', type='TH1F', path='EXPERT', title="FastElectron Hypo p_{T}^{calo} [MeV];p_{T}^{calo} [MeV];Nevents", xbins=50, xmin=0, xmax=100000)
+ monTool.defineHistogram('CaloEta', type='TH1F', path='EXPERT', title="FastElectron Hypo #eta^{calo} ; #eta^{calo};Nevents", xbins=200, xmin=-2.5, xmax=2.5)
+ monTool.defineHistogram('CaloPhi', type='TH1F', path='EXPERT', title="FastElectron Hypo #phi^{calo} ; #phi^{calo};Nevents", xbins=320, xmin=-3.2, xmax=3.2)
+
+ monTool.HistPath = 'FastElectronHypo/'+tool.getName()
tool.MonTool = monTool
nt = len( thresholds )
@@ -58,7 +58,7 @@ def TrigL2ElectronHypoToolFromDict( chainDict ):
return tool
-def TrigL2ElectronHypoToolFromName( name, conf ):
+def TrigEgammaFastElectronHypoToolFromName( name, conf ):
""" provides configuration of the hypo tool giben the chain name
The argument will be replaced by "parsed" chain dict. For now it only serves simplest chain HLT_eXYZ.
"""
@@ -66,15 +66,15 @@ def TrigL2ElectronHypoToolFromName( name, conf ):
decodedDict = dictFromChainName(conf)
- return TrigL2ElectronHypoToolFromDict( decodedDict )
+ return TrigEgammaFastElectronHypoToolFromDict( decodedDict )
if __name__ == "__main__":
- tool = TrigL2ElectronHypoToolFromName("HLT_e3_etcut_L1EM3", "HLT_e3_etcut_L1EM3")
+ tool = TrigEgammaFastElectronHypoToolFromName("HLT_e3_etcut_L1EM3", "HLT_e3_etcut_L1EM3")
assert tool, "Not configured simple tool"
- tool = TrigL2ElectronHypoToolFromName("HLT_2e3_etcut_L1E2M3", "HLT_2e3_etcut_L12EM3")
+ tool = TrigEgammaFastElectronHypoToolFromName("HLT_2e3_etcut_L1E2M3", "HLT_2e3_etcut_L12EM3")
assert tool, "Not configured simple tool"
assert len(tool.TrackPt) == 2, "Multiplicity missonfigured, set "+ str( len( tool.TrackPt ) )
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/ITrigL2CaloHypoTool.h b/Trigger/TrigHypothesis/TrigEgammaHypo/src/ITrigEgammaFastCaloHypoTool.h
similarity index 73%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/ITrigL2CaloHypoTool.h
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/ITrigEgammaFastCaloHypoTool.h
index 2ca149136a12e2b69671cdc72048ceb99f838b1b..4aa30e5ee9a95142bf6a21401acfe5b96f2db6a2 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/ITrigL2CaloHypoTool.h
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/ITrigEgammaFastCaloHypoTool.h
@@ -1,8 +1,8 @@
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
-#ifndef TRIGEGAMMAHYPO_ITRIGL2CALOHYPOTOOL_H
-#define TRIGEGAMMAHYPO_ITRIGL2CALOHYPOTOOL_H 1
+#ifndef TRIGEGAMMAHYPO_ITRIGEGAMMAFASTCALOHYPOTOOL_H
+#define TRIGEGAMMAHYPO_ITRIGEGAMMAFASTCALOHYPOTOOL_H 1
#include "GaudiKernel/IAlgTool.h"
#include "AthenaBaseComps/AthAlgTool.h"
@@ -16,20 +16,20 @@
/**
- * @class Base for tools dooing L2 Calo Hypo selection
+ * @class Base for tools dooing Egamma Fast Calo Hypo selection
* @brief
**/
-class ITrigL2CaloHypoTool
+class ITrigEgammaFastCaloHypoTool
: virtual public ::IAlgTool
{
public:
- DeclareInterfaceID(ITrigL2CaloHypoTool, 1, 0);
- virtual ~ITrigL2CaloHypoTool(){}
+ DeclareInterfaceID(ITrigEgammaFastCaloHypoTool, 1, 0);
+ virtual ~ITrigEgammaFastCaloHypoTool(){}
- struct ClusterInfo {
- ClusterInfo( TrigCompositeUtils::Decision* d,
+ struct FastClusterInfo {
+ FastClusterInfo( TrigCompositeUtils::Decision* d,
const TrigRoiDescriptor* r,
const xAOD::TrigEMCluster* c,
const xAOD::TrigRingerRings* ring,
@@ -56,13 +56,13 @@ class ITrigL2CaloHypoTool
* There will be many tools called often to perform this quick operation and we do not want to pay for polymorphism which we do not need to use.
* Will actually see when N obj hypos will enter the scene
**/
- virtual StatusCode decide( std::vector<ClusterInfo>& input ) const = 0;
+ virtual StatusCode decide( std::vector<FastClusterInfo>& input ) const = 0;
/**
* @brief Makes a decision for a single object
* The decision needs to be returned
**/
- virtual bool decide( const ClusterInfo& i ) const = 0;
+ virtual bool decide( const FastClusterInfo& i ) const = 0;
protected:
@@ -70,4 +70,4 @@ class ITrigL2CaloHypoTool
};
-#endif //> !TRIGEGAMMAHYPO_ITRIGL2CALOHYPOTOOL_H
+#endif //> !TRIGEGAMMAHYPO_ITRIGEGAMMAFASTCALOHYPOTOOL_H
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoAlgMT.cxx b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoAlgMT.cxx
similarity index 90%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoAlgMT.cxx
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoAlgMT.cxx
index 64f2f24875319fd66cd1ae6c8f5e5e26c6f2e0d5..e8358950217edbb0aae7fd81ef974dda67e68a06 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoAlgMT.cxx
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoAlgMT.cxx
@@ -3,19 +3,19 @@
*/
#include "GaudiKernel/Property.h"
-#include "TrigL2CaloHypoAlgMT.h"
+#include "TrigEgammaFastCaloHypoAlgMT.h"
#include "TrigCompositeUtils/HLTIdentifier.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
#include "AthViews/ViewHelper.h"
using namespace TrigCompositeUtils;
-TrigL2CaloHypoAlgMT::TrigL2CaloHypoAlgMT( const std::string& name,
+TrigEgammaFastCaloHypoAlgMT::TrigEgammaFastCaloHypoAlgMT( const std::string& name,
ISvcLocator* pSvcLocator ) :
::HypoBase( name, pSvcLocator ) {}
-StatusCode TrigL2CaloHypoAlgMT::initialize() {
+StatusCode TrigEgammaFastCaloHypoAlgMT::initialize() {
ATH_CHECK( m_hypoTools.retrieve() );
@@ -29,7 +29,7 @@ StatusCode TrigL2CaloHypoAlgMT::initialize() {
}
-StatusCode TrigL2CaloHypoAlgMT::execute( const EventContext& context ) const {
+StatusCode TrigEgammaFastCaloHypoAlgMT::execute( const EventContext& context ) const {
ATH_MSG_DEBUG ( "Executing " << name() << "..." );
auto previousDecisionsHandle = SG::makeHandle( decisionInput(), context );
ATH_CHECK( previousDecisionsHandle.isValid() );
@@ -43,7 +43,7 @@ StatusCode TrigL2CaloHypoAlgMT::execute( const EventContext& context ) const {
auto decisions = outputHandle.ptr();
// input for decision
- std::vector<ITrigL2CaloHypoTool::ClusterInfo> toolInput;
+ std::vector<ITrigEgammaFastCaloHypoTool::FastClusterInfo> toolInput;
// loop over previous decisions
size_t counter=0;
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoAlgMT.h b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoAlgMT.h
similarity index 66%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoAlgMT.h
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoAlgMT.h
index e9a531eee86357387cfd1e7fbb047919f8ab0454..abdb96f47518f2ec73bb5eb15f561450848cd000 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoAlgMT.h
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoAlgMT.h
@@ -1,8 +1,8 @@
/*
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#ifndef TRIGEGAMMAHYPO_TRIGL2CALOHYPOALGMT_H
-#define TRIGEGAMMAHYPO_TRIGL2CALOHYPOALGMT_H 1
+#ifndef TRIGEGAMMAHYPO_TRIGEGAMMAFASTCALOHYPOALGMT_H
+#define TRIGEGAMMAHYPO_TRIGEGAMMAFASTCALOHYPOALGMT_H 1
#include <string>
@@ -16,25 +16,25 @@
#include "xAODTrigRinger/TrigRingerRingsContainer.h"
-#include "ITrigL2CaloHypoTool.h"
+#include "ITrigEgammaFastCaloHypoTool.h"
/**
- * @class TrigL2CaloHypoAlgMT
+ * @class TrigEgammaFastCaloHypoAlgMT
* @brief Implements egamma calo selection for the new HLT framework
**/
-class TrigL2CaloHypoAlgMT : public ::HypoBase {
+class TrigEgammaFastCaloHypoAlgMT : public ::HypoBase {
public:
- TrigL2CaloHypoAlgMT( const std::string& name, ISvcLocator* pSvcLocator );
+ TrigEgammaFastCaloHypoAlgMT( const std::string& name, ISvcLocator* pSvcLocator );
virtual StatusCode initialize() override;
virtual StatusCode execute( const EventContext& context ) const override;
private:
- ToolHandleArray< ITrigL2CaloHypoTool > m_hypoTools { this, "HypoTools", {}, "Hypo tools" };
+ ToolHandleArray< ITrigEgammaFastCaloHypoTool > m_hypoTools { this, "HypoTools", {}, "Hypo tools" };
SG::ReadHandleKey< xAOD::TrigEMClusterContainer > m_clustersKey { this, "CaloClusters", "CaloClusters", "CaloClusters in view" };
SG::ReadHandleKey<xAOD::TrigRingerRingsContainer> m_ringsKey { this, "RingerKey","HLT_FastCaloRinger","Point to RingerKey"};
};
-#endif //> !TRIGEGAMMAHYPO_TESTTRIGL2CALOHYPOALG_H
+#endif //> !TRIGEGAMMAHYPO_TESTTRIGEGAMMAFASTCALOHYPOALG_H
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolInc.cxx b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolInc.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..2b541103c942e83229c1f1c1efe13be031f7ca50
--- /dev/null
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolInc.cxx
@@ -0,0 +1,403 @@
+/*
+ Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include <algorithm>
+#include "TrigCompositeUtils/HLTIdentifier.h"
+#include "TrigCompositeUtils/Combinators.h"
+#include "AthenaMonitoringKernel/Monitored.h"
+#include "GaudiKernel/SystemOfUnits.h"
+
+#include "TrigEgammaFastCaloHypoToolInc.h"
+
+
+using namespace TrigCompositeUtils;
+
+TrigEgammaFastCaloHypoToolInc::TrigEgammaFastCaloHypoToolInc( const std::string& type,
+ const std::string& name,
+ const IInterface* parent )
+ : base_class( type, name, parent ),
+ m_selectorTool(),
+ m_lumiBlockMuTool("LumiBlockMuTool/LumiBlockMuTool"),
+ m_decisionId( HLT::Identifier::fromToolName( name ) )
+{
+declareProperty("LumiBlockMuTool", m_lumiBlockMuTool, "Luminosity Tool" );
+}
+
+StatusCode TrigEgammaFastCaloHypoToolInc::initialize() {
+
+ATH_MSG_DEBUG("Name: "<<name()<<" UseRinger: "<<m_useRinger);
+
+if (m_useRinger){
+ m_selectorTool.setConstantsCalibPath( m_constantsCalibPath );
+ m_selectorTool.setThresholdsCalibPath( m_thresholdsCalibPath );
+
+ if(m_selectorTool.initialize().isFailure())
+ return StatusCode::FAILURE;
+
+ if (m_lumiBlockMuTool.retrieve().isFailure())
+ return StatusCode::FAILURE;
+
+ ATH_MSG_INFO("TrigEgammaFastCaloRingerHypo initialization completed successfully.");
+
+}
+ ATH_MSG_DEBUG( "Initialization completed successfully" );
+ ATH_MSG_DEBUG( "AcceptAll = " << ( m_acceptAll==true ? "True" : "False" ) );
+ ATH_MSG_DEBUG( "EtaBins = " << m_etabin );
+ ATH_MSG_DEBUG( "ETthr = " << m_eTthr << "( lo )/" << m_eT2thr << "( hi )" );
+ ATH_MSG_DEBUG( "HADETthr = " << m_hadeTthr << "( lo )/" << m_hadeT2thr << "( hi )" );
+ ATH_MSG_DEBUG( "CARCOREthr = " << m_carcorethr );
+ ATH_MSG_DEBUG( "CAERATIOthr = " << m_caeratiothr );
+ ATH_MSG_DEBUG( "dPHICLUSTERthr = " << m_dphicluster );
+ ATH_MSG_DEBUG( "dETACLUSTERthr = " << m_detacluster );
+ ATH_MSG_DEBUG( "WETA2thr = " << m_WETA2thr );
+ ATH_MSG_DEBUG( "WSTOTthr = " << m_WSTOTthr );
+ ATH_MSG_DEBUG( "F3thr = " << m_F3thr );
+
+ if ( m_etabin.size() == 0 ) {
+ ATH_MSG_ERROR( " There are no cuts set (EtaBins property is an empty list)" );
+ return StatusCode::FAILURE;
+ }
+
+ unsigned int nEtaBin = m_etabin.size();
+#define CHECK_SIZE( __n) if ( m_##__n.size() != (nEtaBin - 1) ) \
+ { ATH_MSG_DEBUG(" __n size is " << m_##__n.size() << " but needs to be " << (nEtaBin - 1) ); return StatusCode::FAILURE; }
+
+ CHECK_SIZE( eTthr );
+ CHECK_SIZE( eT2thr );
+ CHECK_SIZE( hadeTthr );
+ CHECK_SIZE( hadeT2thr );
+ CHECK_SIZE( carcorethr );
+ CHECK_SIZE( caeratiothr );
+ CHECK_SIZE( WETA2thr );
+ CHECK_SIZE( WSTOTthr );
+ CHECK_SIZE( F3thr );
+#undef CHECK_SIZE
+
+ ATH_MSG_DEBUG( "Tool configured for chain/id: " << m_decisionId );
+
+ if ( not m_monTool.name().empty() )
+ CHECK( m_monTool.retrieve() );
+
+ return StatusCode::SUCCESS;
+}
+
+
+
+TrigEgammaFastCaloHypoToolInc::~TrigEgammaFastCaloHypoToolInc(){}
+
+int TrigEgammaFastCaloHypoToolInc::findCutIndex( float eta ) const {
+ const float absEta = std::abs(eta);
+
+ auto binIterator = std::adjacent_find( m_etabin.begin(), m_etabin.end(), [=](float left, float right){ return left < absEta and absEta < right; } );
+ if ( binIterator == m_etabin.end() ) {
+ return -1;
+ }
+ return binIterator - m_etabin.begin();
+}
+
+StatusCode TrigEgammaFastCaloHypoToolInc::decide( std::vector<FastClusterInfo>& input ) const {
+ for ( auto& i: input ) {
+ if ( passed ( m_decisionId.numeric(), i.previousDecisionIDs ) ) {
+ if ( decide( i ) ) {
+ addDecisionID( m_decisionId, i.decision );
+ }
+ }
+ }
+ return StatusCode::SUCCESS;
+}
+
+bool TrigEgammaFastCaloHypoToolInc::decide( const ITrigEgammaFastCaloHypoTool::FastClusterInfo& input ) const {
+ // ringer selection
+ if (m_useRinger){
+ return decide_ringer( input );
+ }
+ // cutbased selection
+ else{
+ return decide_cutbased( input );
+ }
+}
+
+bool TrigEgammaFastCaloHypoToolInc::decide_cutbased( const ITrigEgammaFastCaloHypoTool::FastClusterInfo& input ) const {
+
+ bool pass = false;
+
+ auto dEta = Monitored::Scalar( "dEta", -1. );
+ auto dPhi = Monitored::Scalar( "dPhi", -1. );
+ auto eT_T2Calo = Monitored::Scalar( "Et_em" , -1.0 );
+ auto hadET_T2Calo = Monitored::Scalar( "Et_had", -1.0 );
+ auto rCore = Monitored::Scalar( "RCore" , -1.0 );
+ auto energyRatio = Monitored::Scalar( "ERatio" , -1.0 );
+ auto etaBin = Monitored::Scalar( "EtaBin", -1. );
+ auto monEta = Monitored::Scalar( "Eta", -99. );
+ auto monPhi = Monitored::Scalar( "Phi", -99. );
+ auto F1 = Monitored::Scalar( "F1" , -1.0 );
+ auto Weta2 = Monitored::Scalar( "Weta2" , -1.0 );
+ auto Wstot = Monitored::Scalar( "Wstot" , -1.0 );
+ auto F3 = Monitored::Scalar( "F3" , -1.0 );
+ auto PassedCuts = Monitored::Scalar<int>( "CutCounter", -1 );
+ auto monitorIt = Monitored::Group( m_monTool,
+ dEta, dPhi, eT_T2Calo, hadET_T2Calo,
+ rCore, energyRatio, etaBin, monEta,
+ monPhi, F1, Weta2, Wstot, F3, PassedCuts );
+ // when leaving scope it will ship data to monTool
+ PassedCuts = PassedCuts + 1; //got called (data in place)
+
+ if ( m_acceptAll ) {
+ pass = true;
+ ATH_MSG_DEBUG( "AcceptAll property is set: taking all events" );
+ } else {
+ pass = false;
+ ATH_MSG_DEBUG( "AcceptAll property not set: applying selection" );
+ }
+
+ auto roiDescriptor = input.roi;
+
+ if ( fabs( roiDescriptor->eta() ) > 2.6 ) {
+ ATH_MSG_DEBUG( "REJECT The cluster had eta coordinates beyond the EM fiducial volume : " << roiDescriptor->eta() << "; stop the chain now" );
+ pass=false; // special case
+ return pass;
+ }
+
+ ATH_MSG_DEBUG( "; RoI ID = " << roiDescriptor->roiId()
+ << ": Eta = " << roiDescriptor->eta()
+ << ", Phi = " << roiDescriptor->phi() );
+
+ // fill local variables for RoI reference position
+ double etaRef = roiDescriptor->eta();
+ double phiRef = roiDescriptor->phi();
+ // correct phi the to right range ( probably not needed anymore )
+ if ( fabs( phiRef ) > M_PI ) phiRef -= 2*M_PI; // correct phi if outside range
+
+ auto pClus = input.cluster;
+ float absEta = fabs( pClus->eta() );
+ etaBin = -1;
+ monEta = pClus->eta();
+ monPhi = pClus->phi();
+ const int cutIndex = findCutIndex( absEta );
+
+ // find if electron is in calorimeter crack
+ bool inCrack = ( absEta > 2.37 || ( absEta > 1.37 && absEta < 1.52 ) );
+ dEta = pClus->eta() - etaRef;
+
+ // Deal with angle diferences greater than Pi
+ dPhi = fabs( pClus->phi() - phiRef );
+ dPhi = ( dPhi < M_PI ? dPhi : 2*M_PI - dPhi ); // TB why only <
+
+ // calculate cluster quantities // definition taken from TrigElectron constructor
+ if ( pClus->emaxs1() + pClus->e2tsts1() > 0 )
+ energyRatio = ( pClus->emaxs1() - pClus->e2tsts1() ) / ( pClus->emaxs1() + pClus->e2tsts1() );
+
+ // ( VD ) here the definition is a bit different to account for the cut of e277 @ EF
+ if ( pClus->e277()!= 0. ) rCore = pClus->e237() / pClus->e277();
+
+ //fraction of energy deposited in 1st sampling
+ if ( fabs( pClus->energy() ) > 0.00001 ) F1 = ( pClus->energy( CaloSampling::EMB1 )+pClus->energy( CaloSampling::EME1 ) )/pClus->energy();
+ eT_T2Calo = pClus->et();
+ if ( eT_T2Calo!=0 && pClus->eta()!=0 ) hadET_T2Calo = pClus->ehad1()/cosh( fabs( pClus->eta() ) )/eT_T2Calo;
+
+ //extract Weta2 varable
+ Weta2 = pClus->weta2();
+
+ //extract Wstot varable
+ Wstot = pClus->wstot();
+
+ //extract F3 ( backenergy i EM calorimeter
+ float e0 = pClus->energy( CaloSampling::PreSamplerB ) + pClus->energy( CaloSampling::PreSamplerE );
+ float e1 = pClus->energy( CaloSampling::EMB1 ) + pClus->energy( CaloSampling::EME1 );
+ float e2 = pClus->energy( CaloSampling::EMB2 ) + pClus->energy( CaloSampling::EME2 );
+ float e3 = pClus->energy( CaloSampling::EMB3 ) + pClus->energy( CaloSampling::EME3 );
+ float eallsamples = e0+e1+e2+e3;
+ F3 = fabs( eallsamples )>0. ? e3/eallsamples : 0.;
+
+ // apply cuts: DeltaEta( clus-ROI )
+ ATH_MSG_DEBUG( "TrigEMCluster: eta=" << pClus->eta()
+ << " roi eta=" << etaRef << " DeltaEta=" << dEta
+ << " cut: <" << m_detacluster );
+
+ if ( fabs( pClus->eta() - etaRef ) > m_detacluster ) {
+ ATH_MSG_DEBUG("REJECT Cluster dEta cut failed");
+ return pass;
+ }
+ PassedCuts = PassedCuts + 1; //Deta
+
+ // DeltaPhi( clus-ROI )
+ ATH_MSG_DEBUG( ": phi=" << pClus->phi()
+ << " roi phi="<< phiRef << " DeltaPhi="<< dPhi
+ << " cut: <" << m_dphicluster );
+
+ if( dPhi > m_dphicluster ) {
+ ATH_MSG_DEBUG("REJECT Clsuter dPhi cut failed");
+ return pass;
+ }
+ PassedCuts = PassedCuts + 1; //DPhi
+
+ // eta range
+ if ( cutIndex == -1 ) { // VD
+ ATH_MSG_DEBUG( "Cluster eta: " << absEta << " outside eta range " << m_etabin[m_etabin.size()-1] );
+ return pass;
+ }
+ else {
+ ATH_MSG_DEBUG( "eta bin used for cuts " << cutIndex );
+ }
+ PassedCuts = PassedCuts + 1; // passed eta cut
+
+ // Rcore
+ ATH_MSG_DEBUG ( "TrigEMCluster: Rcore=" << rCore
+ << " cut: >" << m_carcorethr[cutIndex] );
+ if ( rCore < m_carcorethr[cutIndex] ) {
+ ATH_MSG_DEBUG("REJECT rCore cut failed");
+ return pass;
+ }
+ PassedCuts = PassedCuts + 1; //Rcore
+
+ // Eratio
+ ATH_MSG_DEBUG( " cut: >" << m_caeratiothr[cutIndex] );
+ if ( inCrack || F1 < m_F1thr[0] ) {
+ ATH_MSG_DEBUG ( "TrigEMCluster: InCrack= " << inCrack << " F1=" << F1 );
+ }
+ else {
+ if ( energyRatio < m_caeratiothr[cutIndex] ) {
+ ATH_MSG_DEBUG("REJECT e ratio cut failed");
+ return pass;
+ }
+ }
+ PassedCuts = PassedCuts + 1; //Eratio
+ if( inCrack ) energyRatio = -1; //Set default value in crack for monitoring.
+
+ // ET_em
+ ATH_MSG_DEBUG( "TrigEMCluster: ET_em=" << eT_T2Calo << " cut: >" << m_eTthr[cutIndex] );
+ if ( eT_T2Calo < m_eTthr[cutIndex] ) {
+ ATH_MSG_DEBUG("REJECT et cut failed");
+ return pass;
+ }
+ PassedCuts = PassedCuts + 1; // ET_em
+
+ float hadET_cut = 0.0;
+ // find which ET_had to apply : this depends on the ET_em and the eta bin
+ if ( eT_T2Calo > m_eT2thr[cutIndex] ) {
+ hadET_cut = m_hadeT2thr[cutIndex] ;
+ ATH_MSG_DEBUG ( "ET_em>" << m_eT2thr[cutIndex] << ": use high ET_had cut: <" << hadET_cut );
+ }
+ else {
+ hadET_cut = m_hadeTthr[cutIndex];
+ ATH_MSG_DEBUG ( "ET_em<" << m_eT2thr[cutIndex] << ": use low ET_had cut: <" << hadET_cut );
+ }
+
+ // ET_had
+ ATH_MSG_DEBUG ( "TrigEMCluster: ET_had=" << hadET_T2Calo << " cut: <" << hadET_cut );
+ if ( hadET_T2Calo > hadET_cut ) {
+ ATH_MSG_DEBUG("REJECT et had cut failed");
+ return pass;
+ }
+ PassedCuts = PassedCuts + 1; //ET_had
+
+ // F1
+ ATH_MSG_DEBUG ( "TrigEMCluster: F1=" << F1 << " cut: >" << m_F1thr[0] );
+ PassedCuts = PassedCuts + 1; //F1
+
+ //Weta2
+ ATH_MSG_DEBUG ( "TrigEMCluster: Weta2=" << Weta2 << " cut: <" << m_WETA2thr[cutIndex] );
+ if ( Weta2 > m_WETA2thr[cutIndex] ) {
+ ATH_MSG_DEBUG("REJECT weta 2 cut failed");
+ return pass;
+ }
+ PassedCuts = PassedCuts + 1; //Weta2
+
+ //Wstot
+ ATH_MSG_DEBUG ( "TrigEMCluster: Wstot=" <<Wstot << " cut: <" << m_WSTOTthr[cutIndex] );
+ if ( Wstot >= m_WSTOTthr[cutIndex] ) {
+ ATH_MSG_DEBUG("REJECT wstot cut failed");
+ return pass;
+ }
+ PassedCuts = PassedCuts + 1; //Wstot
+
+ //F3
+ ATH_MSG_DEBUG( "TrigEMCluster: F3=" << F3 << " cut: <" << m_F3thr[cutIndex] );
+ if ( F3 > m_F3thr[cutIndex] ) {
+ ATH_MSG_DEBUG("REJECT F3 cut failed");
+ return pass;
+ }
+ PassedCuts = PassedCuts + 1; //F3
+
+ // got this far => passed!
+ pass = true;
+
+ // Reach this point successfully
+ ATH_MSG_DEBUG( "pass = " << pass );
+
+ return pass;
+
+}
+
+bool TrigEgammaFastCaloHypoToolInc::decide_ringer ( const ITrigEgammaFastCaloHypoTool::FastClusterInfo& input) const{
+
+ auto etMon = Monitored::Scalar("Et",-100);
+ auto monEta = Monitored::Scalar("Eta",-100);
+ auto monPhi = Monitored::Scalar("Phi",-100);
+ auto rnnOutMon = Monitored::Scalar("RnnOut",-100);
+ auto total_time = Monitored::Timer("TIME_total");
+ auto propagate_time = Monitored::Timer("TIME_propagate");
+ auto preproc_time = Monitored::Timer("TIME_preproc");
+ auto decide_time = Monitored::Timer("TIME_decide");
+ auto mon = Monitored::Group(m_monTool,etMon,monEta,monPhi,rnnOutMon,
+ total_time,propagate_time,preproc_time,decide_time);
+
+
+ if ( m_acceptAll ) {
+ ATH_MSG_DEBUG( "AcceptAll property is set: taking all events" );
+ return true;
+ } else {
+ ATH_MSG_DEBUG( "AcceptAll property not set: applying selection" );
+ }
+
+ total_time.start();
+ auto ringerShape = input.ringerShape;
+ const xAOD::TrigEMCluster *emCluster = 0;
+ if(ringerShape){
+ emCluster = ringerShape->emCluster();
+ //emCluster= input.cluster;
+ if(!emCluster){
+ ATH_MSG_WARNING( "There is no link to xAOD::TrigEMCluster into the Ringer object.");
+ return false;
+ }
+ }
+ else{
+ ATH_MSG_WARNING( "There is no xAOD::TrigRingerRings link into the rnnOutput object.");
+ return false;
+ }
+
+ float eta = std::fabs(emCluster->eta());
+ float et = emCluster->et() / Gaudi::Units::GeV;
+ float avgmu = m_lumiBlockMuTool->averageInteractionsPerCrossing();
+
+ if(eta>2.50) eta=2.50;///fix for events out of the ranger
+
+ // make sure that monitoring histogram will plotting only the events of chain.
+ ///Et threshold
+ if(et < m_emEtCut/Gaudi::Units::GeV){
+ ATH_MSG_DEBUG( "Event reproved by Et threshold. Et = " << et << ", EtCut = " << m_emEtCut/Gaudi::Units::GeV);
+ return false;
+ }
+
+ monEta = emCluster->eta();
+ etMon = emCluster->et();
+ monPhi = emCluster->phi();
+
+ const std::vector<float> rings = ringerShape->rings();
+ std::vector<float> refRings(rings.size());
+ refRings.assign(rings.begin(), rings.end());
+
+ ATH_MSG_DEBUG("Et = "<< et << " Eta = "<<eta << " mu = " << avgmu << "rsize = "<< refRings.size());
+
+ auto output = m_selectorTool.calculate( refRings, et, eta, avgmu, propagate_time, preproc_time );
+ rnnOutMon = output;
+ ATH_MSG_DEBUG(name()<< " generate as NN output " << output );
+
+ decide_time.start();
+ bool accept = m_selectorTool.accept(output, et,eta,avgmu);
+ decide_time.stop();
+
+ total_time.stop();
+ return accept;
+}
\ No newline at end of file
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolInc.h b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolInc.h
similarity index 76%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolInc.h
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolInc.h
index a8b2aacc89e76c284cae402dbe52d24a62dc12d9..700726b977b70f6f745d86b4e7fdb4d73e6bf3d9 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolInc.h
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolInc.h
@@ -1,8 +1,8 @@
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
-#ifndef TRIGEGAMMAHYPO_TRIGL2CALOHYPOTOOLINC_H
-#define TRIGEGAMMAHYPO_TRIGL2CALOHYPOTOOLINC_H 1
+#ifndef TRIGEGAMMAHYPO_TRIGEGAMMAFASTCALOHYPOTOOLINC_H
+#define TRIGEGAMMAHYPO_TRIGEGAMMAFASTCALOHYPOTOOLINC_H 1
//#include "GaudiKernel/IAlgTool.h"
#include "CLHEP/Units/SystemOfUnits.h"
@@ -17,25 +17,29 @@
#include "AthenaMonitoringKernel/GenericMonitoringTool.h"
#include "TrigCompositeUtils/HLTIdentifier.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
-#include "ITrigL2CaloHypoTool.h"
+#include "ITrigEgammaFastCaloHypoTool.h"
/**
* @class Implementation of the Egamma selection for CaloClusters
* @brief
**/
-class TrigL2CaloHypoToolInc : public extends<AthAlgTool, ITrigL2CaloHypoTool> {
+class TrigEgammaFastCaloHypoToolInc : public extends<AthAlgTool, ITrigEgammaFastCaloHypoTool> {
public:
- TrigL2CaloHypoToolInc( const std::string& type,
+ TrigEgammaFastCaloHypoToolInc( const std::string& type,
const std::string& name,
const IInterface* parent );
- virtual ~TrigL2CaloHypoToolInc();
+ virtual ~TrigEgammaFastCaloHypoToolInc();
virtual StatusCode initialize() override;
- virtual StatusCode decide( std::vector<ITrigL2CaloHypoTool::ClusterInfo>& input ) const override;
+ virtual StatusCode decide( std::vector<ITrigEgammaFastCaloHypoTool::FastClusterInfo>& input ) const override;
- virtual bool decide( const ITrigL2CaloHypoTool::ClusterInfo& i ) const override;
+ virtual bool decide( const ITrigEgammaFastCaloHypoTool::FastClusterInfo& i ) const override;
+
+ // ringer and cutbased selectors
+ virtual bool decide_cutbased( const ITrigEgammaFastCaloHypoTool::FastClusterInfo& i ) const;
+ virtual bool decide_ringer( const ITrigEgammaFastCaloHypoTool::FastClusterInfo& i ) const;
private:
Ringer::RingerSelectorTool m_selectorTool;
@@ -67,4 +71,4 @@ class TrigL2CaloHypoToolInc : public extends<AthAlgTool, ITrigL2CaloHypoTool> {
int findCutIndex( float eta ) const;
};
-#endif //> !TRIGEGAMMAHYPO_TRIGL2CALOHYPOTOOL_H
+#endif //> !TRIGEGAMMAHYPO_TRIGEGAMMAFASTCALOHYPOTOOLINC_H
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolMult.cxx b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolMult.cxx
similarity index 80%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolMult.cxx
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolMult.cxx
index 591827f69aa1d91d9d3eeca373fe0e89f642049f..014f74cc6c1d39149296c37c8b727277a8c41c47 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolMult.cxx
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolMult.cxx
@@ -3,18 +3,18 @@
*/
#include "TrigCompositeUtils/Combinators.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
-#include "TrigL2CaloHypoToolMult.h"
+#include "TrigEgammaFastCaloHypoToolMult.h"
using namespace TrigCompositeUtils;
-TrigL2CaloHypoToolMult::TrigL2CaloHypoToolMult( const std::string& type,
+TrigEgammaFastCaloHypoToolMult::TrigEgammaFastCaloHypoToolMult( const std::string& type,
const std::string& name,
const IInterface* parent )
: base_class( type, name, parent ),
m_decisionId( HLT::Identifier::fromToolName( name ) ) {}
-TrigL2CaloHypoToolMult::~TrigL2CaloHypoToolMult() {}
+TrigEgammaFastCaloHypoToolMult::~TrigEgammaFastCaloHypoToolMult() {}
-StatusCode TrigL2CaloHypoToolMult::initialize() {
+StatusCode TrigEgammaFastCaloHypoToolMult::initialize() {
if( m_subTools.size() <= 1 ) {
ATH_MSG_ERROR( "Number of sub tools " << m_subTools.size() << ", while it has to be > 1, otherwise this is not a multiplicity selection" );
return StatusCode::FAILURE;
@@ -23,7 +23,7 @@ StatusCode TrigL2CaloHypoToolMult::initialize() {
return StatusCode::SUCCESS;
}
-StatusCode TrigL2CaloHypoToolMult::decide( std::vector<ITrigL2CaloHypoTool::ClusterInfo>& input ) const {
+StatusCode TrigEgammaFastCaloHypoToolMult::decide( std::vector<ITrigEgammaFastCaloHypoTool::FastClusterInfo>& input ) const {
HLT::Index2DVec passingSelection( m_subTools.size() );
ATH_MSG_DEBUG( "Applying selection of multiplicity " << m_subTools.size() );
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolMult.h b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolMult.h
similarity index 52%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolMult.h
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolMult.h
index c3e3ea7e17511d5a3a082ab5b10e5be52774ebb5..1cfbb0d1c0570b1cab89de5dbaed367291cb9963 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolMult.h
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastCaloHypoToolMult.h
@@ -1,8 +1,8 @@
/*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
-#ifndef TRIGEGAMMAHYPO_TRIGL2CALOHYPOTOOLMULT_H
-#define TRIGEGAMMAHYPO_TRIGL2CALOHYPOTOOLMULT_H 1
+#ifndef TRIGEGAMMAHYPO_TRIGEGAMMFASTCALOHYPOTOOLMULT_H
+#define TRIGEGAMMAHYPO_TRIGEGAMMAFASTCALOHYPOTOOLMULT_H 1
//#include "GaudiKernel/IAlgTool.h"
#include "CLHEP/Units/SystemOfUnits.h"
@@ -12,7 +12,7 @@
#include "AthenaMonitoringKernel/GenericMonitoringTool.h"
#include "TrigCompositeUtils/HLTIdentifier.h"
#include "TrigCompositeUtils/TrigCompositeUtils.h"
-#include "ITrigL2CaloHypoTool.h"
+#include "ITrigEgammaFastCaloHypoTool.h"
@@ -21,18 +21,18 @@
* @brief
**/
-class TrigL2CaloHypoToolMult : public extends<AthAlgTool, ITrigL2CaloHypoTool> {
+class TrigEgammaFastCaloHypoToolMult : public extends<AthAlgTool, ITrigEgammaFastCaloHypoTool> {
public:
- TrigL2CaloHypoToolMult( const std::string& type,
+ TrigEgammaFastCaloHypoToolMult( const std::string& type,
const std::string& name,
const IInterface* parent );
- virtual ~TrigL2CaloHypoToolMult();
+ virtual ~TrigEgammaFastCaloHypoToolMult();
virtual StatusCode initialize() override;
- virtual StatusCode decide( std::vector<ITrigL2CaloHypoTool::ClusterInfo>& input ) const override;
+ virtual StatusCode decide( std::vector<ITrigEgammaFastCaloHypoTool::FastClusterInfo>& input ) const override;
- virtual bool decide( const ITrigL2CaloHypoTool::ClusterInfo& ) const override {
+ virtual bool decide( const ITrigEgammaFastCaloHypoTool::FastClusterInfo& ) const override {
REPORT_MESSAGE(MSG::ERROR) << "this method should never be called";
return false;
}
@@ -40,8 +40,8 @@ class TrigL2CaloHypoToolMult : public extends<AthAlgTool, ITrigL2CaloHypoTool> {
private:
HLT::Identifier m_decisionId;
- ToolHandleArray<ITrigL2CaloHypoTool> m_subTools { this, "SubTools", {}, "Sub tools performing cuts" };
+ ToolHandleArray<ITrigEgammaFastCaloHypoTool> m_subTools { this, "SubTools", {}, "Sub tools performing cuts" };
};
-#endif //> !TRIGEGAMMAHYPO_TRIGL2CALOHYPOTOOLMULT_H
+#endif //> !TRIGEGAMMAHYPO_TRIGEgammaFastCALOHYPOTOOLMULT_H
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronFexMT.cxx b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronFexMT.cxx
similarity index 96%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronFexMT.cxx
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronFexMT.cxx
index d1f204304658def3134ffc3903a350b96bd9f838..92d9fea388cb9a4bc8c770d6487ada55e652ebbe 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronFexMT.cxx
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronFexMT.cxx
@@ -20,7 +20,7 @@
**************************************************************************/
#include "TrkCaloExtension/CaloExtensionHelpers.h"
-#include "TrigL2ElectronFexMT.h"
+#include "TrigEgammaFastElectronFexMT.h"
#include "xAODTrigCalo/TrigEMClusterContainer.h"
#include "xAODTrigCalo/TrigEMClusterAuxContainer.h"
#include "AthenaMonitoringKernel/Monitored.h"
@@ -32,7 +32,7 @@ inline const DataVector<xAOD::TrigElectron>** dvec_cast(SRC** ptr) {
}
-TrigL2ElectronFexMT::TrigL2ElectronFexMT(const std::string & name, ISvcLocator* pSvcLocator)
+TrigEgammaFastElectronFexMT::TrigEgammaFastElectronFexMT(const std::string & name, ISvcLocator* pSvcLocator)
: AthAlgorithm(name, pSvcLocator)
{
@@ -40,11 +40,11 @@ TrigL2ElectronFexMT::TrigL2ElectronFexMT(const std::string & name, ISvcLocator*
}
-TrigL2ElectronFexMT::~TrigL2ElectronFexMT()
+TrigEgammaFastElectronFexMT::~TrigEgammaFastElectronFexMT()
{}
-StatusCode TrigL2ElectronFexMT::initialize()
+StatusCode TrigEgammaFastElectronFexMT::initialize()
{
ATH_MSG_DEBUG("Initialization:");
@@ -85,7 +85,7 @@ ATH_CHECK( m_outputElectronsKey.initialize() );
}
-StatusCode TrigL2ElectronFexMT::finalize()
+StatusCode TrigEgammaFastElectronFexMT::finalize()
{
if (m_extrapolator_failed)
ATH_MSG_INFO("track extrapolation failed " << m_extrapolator_failed << " times");
@@ -94,7 +94,7 @@ StatusCode TrigL2ElectronFexMT::finalize()
}
-StatusCode TrigL2ElectronFexMT::execute() {
+StatusCode TrigEgammaFastElectronFexMT::execute() {
using namespace xAOD;
ATH_MSG_DEBUG( "Executing " <<name());
@@ -301,7 +301,7 @@ StatusCode TrigL2ElectronFexMT::execute() {
return StatusCode::SUCCESS;
}
-bool TrigL2ElectronFexMT::extrapolate(const xAOD::TrigEMCluster *clus, const xAOD::TrackParticle *trk, double &etaAtCalo, double &phiAtCalo){
+bool TrigEgammaFastElectronFexMT::extrapolate(const xAOD::TrigEMCluster *clus, const xAOD::TrackParticle *trk, double &etaAtCalo, double &phiAtCalo){
CaloExtensionHelpers::LayersToSelect layersToSelect;
layersToSelect.insert(CaloSampling::CaloSample::EMB2);
layersToSelect.insert(CaloSampling::CaloSample::EME2);
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronFexMT.h b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronFexMT.h
similarity index 92%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronFexMT.h
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronFexMT.h
index 51f8352966e12c62cd582410a3c85912d74cda48..a074822965cd3559b861de98e4480c3905881795 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronFexMT.h
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronFexMT.h
@@ -18,8 +18,8 @@
** Created: 27 Jul 2017
**************************************************************************/
-#ifndef TRIG_TrigL2ElectronFexMT_H
-#define TRIG_TrigL2ElectronFexMT_H
+#ifndef TRIG_TrigEgammaFastElectronFexMT_H
+#define TRIG_TrigEgammaFastElectronFexMT_H
// standard stuff
#include <vector>
@@ -52,23 +52,23 @@
//{ class IParticleCaloExtensionTool; }
/**
- * \class TrigL2ElectronFexMT
- * \brief TrigL2ElectronFexMT is a Trigger Fex Algorithm that retrieves the L2 TrigEMCluster
+ * \class TrigEgammaFastElectronFexMT
+ * \brief TrigEgammaFastElectronFexMT is a Trigger Fex Algorithm that retrieves the L2 TrigEMCluster
* container and the L2 TrackCollection containers and then creates a TrigElectron Container
* with a subset of calorimeter-ID selection variables that are calculated (eg. E/p)
* TrigL2ElectronFexMT will apply some very loose selection cuts to the TrigElectronContainer created
* which is of TrigParticle type TrigElectron
- * The TrigElectron conatiner will then be retrieved by the hypothesis algorithm TrigL2ElectronHypo
+ * The TrigElectron conatiner will then be retrieved by the hypothesis algorithm TrigEgammaFastElectronHypo
* that will perform the corresponding L2 electron selection
*
*/
-class TrigL2ElectronFexMT : public AthAlgorithm {
+class TrigEgammaFastElectronFexMT : public AthAlgorithm {
public:
- TrigL2ElectronFexMT(const std::string & name, ISvcLocator* pSvcLocator);
- ~TrigL2ElectronFexMT();
+ TrigEgammaFastElectronFexMT(const std::string & name, ISvcLocator* pSvcLocator);
+ ~TrigEgammaFastElectronFexMT();
virtual StatusCode initialize() override;
virtual StatusCode finalize() override;
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoAlgMT.cxx b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoAlgMT.cxx
similarity index 89%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoAlgMT.cxx
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoAlgMT.cxx
index 7b49b7f03b6dcd09e34a90c98101d4436e3d0310..44a064fd9ee6066e073224e803d267dee89162b4 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoAlgMT.cxx
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoAlgMT.cxx
@@ -3,7 +3,7 @@
*/
#include <map>
#include "GaudiKernel/Property.h"
-#include "TrigL2ElectronHypoAlgMT.h"
+#include "TrigEgammaFastElectronHypoAlgMT.h"
#include "AthViews/ViewHelper.h"
@@ -19,12 +19,12 @@ using TrigCompositeUtils::featureString;
using TrigCompositeUtils::findLink;
using TrigCompositeUtils::LinkInfo;
-TrigL2ElectronHypoAlgMT::TrigL2ElectronHypoAlgMT( const std::string& name,
+TrigEgammaFastElectronHypoAlgMT::TrigEgammaFastElectronHypoAlgMT( const std::string& name,
ISvcLocator* pSvcLocator ) :
::HypoBase( name, pSvcLocator ) {}
-StatusCode TrigL2ElectronHypoAlgMT::initialize() {
+StatusCode TrigEgammaFastElectronHypoAlgMT::initialize() {
CHECK( m_hypoTools.retrieve() );
CHECK( m_electronsKey.initialize() );
@@ -33,7 +33,7 @@ StatusCode TrigL2ElectronHypoAlgMT::initialize() {
return StatusCode::SUCCESS;
}
-StatusCode TrigL2ElectronHypoAlgMT::execute( const EventContext& context ) const {
+StatusCode TrigEgammaFastElectronHypoAlgMT::execute( const EventContext& context ) const {
ATH_MSG_DEBUG ( "Executing " << name() << "..." );
auto previousDecisionsHandle = SG::makeHandle( decisionInput(), context );
ATH_CHECK( previousDecisionsHandle.isValid() );
@@ -60,7 +60,7 @@ StatusCode TrigL2ElectronHypoAlgMT::execute( const EventContext& context ) const
ATH_MSG_DEBUG( "Cluster ptr to decision map has size " << clusterToIndexMap.size() );
// prepare imput for tools
- std::vector<TrigL2ElectronHypoTool::ElectronInfo> hypoToolInput;
+ std::vector<TrigEgammaFastElectronHypoTool::ElectronInfo> hypoToolInput;
for ( auto previousDecision: *previousDecisionsHandle ) {
// get View
@@ -93,7 +93,7 @@ StatusCode TrigL2ElectronHypoAlgMT::execute( const EventContext& context ) const
DecisionIDContainer clusterDecisionIDs;
decisionIDs( previousDecisionsHandle->at( origCluster->second ), clusterDecisionIDs );
- hypoToolInput.emplace_back( TrigL2ElectronHypoTool::ElectronInfo{ d, *electronIter, origCluster->first, clusterDecisionIDs } );
+ hypoToolInput.emplace_back( TrigEgammaFastElectronHypoTool::ElectronInfo{ d, *electronIter, origCluster->first, clusterDecisionIDs } );
}
}
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoAlgMT.h b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoAlgMT.h
similarity index 61%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoAlgMT.h
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoAlgMT.h
index e2bdab66c170ab5264bf7f28c4cc9b86b56c6789..50e6206c871bfb653dba0aa62fcb7cc27f0cde56 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoAlgMT.h
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoAlgMT.h
@@ -1,8 +1,8 @@
/*
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#ifndef TRIGEGAMMAHYPO_TRIGL2ELECTRONHYPOALGMT_H
-#define TRIGEGAMMAHYPO_TRIGL2ELECTRONHYPOALGMT_H 1
+#ifndef TRIGEGAMMAHYPO_TRIGEGAMMAFASTELECTRONHYPOALGMT_H
+#define TRIGEGAMMAHYPO_TRIGEGAMMAFASTELECTRONHYPOALGMT_H 1
#include <string>
@@ -11,30 +11,30 @@
#include "TrigCompositeUtils/TrigCompositeUtils.h"
#include "AthViews/View.h"
-#include "TrigL2ElectronHypoTool.h"
+#include "TrigEgammaFastElectronHypoTool.h"
#include "xAODTrigCalo/TrigEMClusterContainer.h"
#include "DecisionHandling/HypoBase.h"
/**
- * @class TrigL2ElectronHypoAlgMT
+ * @class TrigEgammaFastElectronHypoAlgMT
* @brief Implements Hypo selection on L2 electrons
**/
-class TrigL2ElectronHypoAlgMT : public ::HypoBase
+class TrigEgammaFastElectronHypoAlgMT : public ::HypoBase
{
public:
- TrigL2ElectronHypoAlgMT( const std::string& name, ISvcLocator* pSvcLocator );
+ TrigEgammaFastElectronHypoAlgMT( const std::string& name, ISvcLocator* pSvcLocator );
virtual StatusCode initialize() override;
virtual StatusCode execute(const EventContext& context) const override;
private:
- ToolHandleArray< TrigL2ElectronHypoTool > m_hypoTools {this, "HypoTools", {}, "Tools to perfrom selection"};
+ ToolHandleArray< TrigEgammaFastElectronHypoTool > m_hypoTools {this, "HypoTools", {}, "Tools to perfrom selection"};
Gaudi::Property< bool > m_runInView { this, "RunInView", false , "Set input DH for running in views" };
// internally used to getch from views
SG::ReadHandleKey< xAOD::TrigElectronContainer > m_electronsKey {this, "Electrons", "L2ElectronContainer", "Input"};
};
-#endif //> !TRIGEGAMMAHYPO_TRIGL2ELECTRONHYPOALGMT_H
+#endif //> !TRIGEGAMMAHYPO_TRIGEGAMMAFASTELECTRONHYPOALGMT_H
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoTool.cxx b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoTool.cxx
similarity index 89%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoTool.cxx
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoTool.cxx
index eb65eabc6df7cba8dc24c3e632ef2e9eeb48844f..b9f4af0006df3f2ad3a4c6da2a7a714070ff25b7 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoTool.cxx
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoTool.cxx
@@ -7,17 +7,17 @@
#include "TrigCompositeUtils/Combinators.h"
#include "AthenaMonitoringKernel/Monitored.h"
-#include "TrigL2ElectronHypoTool.h"
+#include "TrigEgammaFastElectronHypoTool.h"
using namespace TrigCompositeUtils;
-TrigL2ElectronHypoTool::TrigL2ElectronHypoTool( const std::string& type,
+TrigEgammaFastElectronHypoTool::TrigEgammaFastElectronHypoTool( const std::string& type,
const std::string& name,
const IInterface* parent )
: AthAlgTool( type, name, parent ),
m_decisionId( HLT::Identifier::fromToolName( name ) ) {}
-StatusCode TrigL2ElectronHypoTool::initialize() {
+StatusCode TrigEgammaFastElectronHypoTool::initialize() {
if ( !m_monTool.empty() ) CHECK( m_monTool.retrieve() );
@@ -46,9 +46,9 @@ StatusCode TrigL2ElectronHypoTool::initialize() {
}
-TrigL2ElectronHypoTool::~TrigL2ElectronHypoTool() {}
+TrigEgammaFastElectronHypoTool::~TrigEgammaFastElectronHypoTool() {}
-bool TrigL2ElectronHypoTool::decideOnSingleObject( const xAOD::TrigElectron* electron,
+bool TrigEgammaFastElectronHypoTool::decideOnSingleObject( const xAOD::TrigElectron* electron,
size_t cutIndex ) const {
auto cutCounter = Monitored::Scalar<int>( "CutCounter", -1 );
auto cutIndexM = Monitored::Scalar<int>( "CutIndex", cutIndex ); // one can do 2D plots for each cut independently
@@ -122,7 +122,7 @@ bool TrigL2ElectronHypoTool::decideOnSingleObject( const xAOD::TrigElectron* ele
}
-StatusCode TrigL2ElectronHypoTool::inclusiveSelection( std::vector<ElectronInfo>& input ) const {
+StatusCode TrigEgammaFastElectronHypoTool::inclusiveSelection( std::vector<ElectronInfo>& input ) const {
for ( auto i: input ) {
if ( i.previousDecisionIDs.count( m_decisionId.numeric() ) == 0 ) continue; // the decision was negative or not even made in previous stage
@@ -135,7 +135,7 @@ StatusCode TrigL2ElectronHypoTool::inclusiveSelection( std::vector<ElectronInfo>
}
-StatusCode TrigL2ElectronHypoTool::markPassing( std::vector<ElectronInfo>& input, const std::set<size_t>& passing ) const {
+StatusCode TrigEgammaFastElectronHypoTool::markPassing( std::vector<ElectronInfo>& input, const std::set<size_t>& passing ) const {
for ( auto idx: passing )
addDecisionID( m_decisionId.numeric(), input[idx].decision );
@@ -143,7 +143,7 @@ StatusCode TrigL2ElectronHypoTool::markPassing( std::vector<ElectronInfo>& input
}
-StatusCode TrigL2ElectronHypoTool::multiplicitySelection( std::vector<ElectronInfo>& input ) const {
+StatusCode TrigEgammaFastElectronHypoTool::multiplicitySelection( std::vector<ElectronInfo>& input ) const {
HLT::Index2DVec passingSelection( m_multiplicity );
for ( size_t cutIndex = 0; cutIndex < m_multiplicity; ++ cutIndex ) {
@@ -186,7 +186,7 @@ StatusCode TrigL2ElectronHypoTool::multiplicitySelection( std::vector<ElectronIn
return markPassing( input, passingIndices );
}
-StatusCode TrigL2ElectronHypoTool::decide( std::vector<ElectronInfo>& input ) const {
+StatusCode TrigEgammaFastElectronHypoTool::decide( std::vector<ElectronInfo>& input ) const {
// handle the simplest and most common case ( multiplicity == 1 ) in easiest possible manner
if ( m_trackPt.size() == 1 ) {
return inclusiveSelection( input );
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoTool.h b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoTool.h
similarity index 90%
rename from Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoTool.h
rename to Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoTool.h
index 736ad8808692d73d00cefa71eed43c0a65463688..d44c13333af7634945b2d778adba35a9d919c962 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2ElectronHypoTool.h
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigEgammaFastElectronHypoTool.h
@@ -1,8 +1,8 @@
/*
Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
*/
-#ifndef TRIGEGAMMAHYPO_TRIGL2ELECTRONHYPOTOOL_H
-#define TRIGEGAMMAHYPO_TRIGL2ELECTRONHYPOTOOL_H 1
+#ifndef TRIGEGAMMAHYPO_TRIGEGAMMAFASTELECTRONHYPOTOOL_H
+#define TRIGEGAMMAHYPO_TRIGEGAMMAFASTELECTRONHYPOTOOL_H 1
#include "GaudiKernel/Property.h"
#include "CLHEP/Units/SystemOfUnits.h"
@@ -19,14 +19,14 @@
* @brief
**/
-class TrigL2ElectronHypoTool : virtual public ::AthAlgTool
+class TrigEgammaFastElectronHypoTool : virtual public ::AthAlgTool
{
public:
- TrigL2ElectronHypoTool( const std::string& type,
+ TrigEgammaFastElectronHypoTool( const std::string& type,
const std::string& name,
const IInterface* parent );
- virtual ~TrigL2ElectronHypoTool();
+ virtual ~TrigEgammaFastElectronHypoTool();
virtual StatusCode initialize() override;
@@ -85,4 +85,4 @@ class TrigL2ElectronHypoTool : virtual public ::AthAlgTool
ToolHandle<GenericMonitoringTool> m_monTool{ this, "MonTool", "", "Monitoring tool" };
};
-#endif //> !TRIGEGAMMAHYPO_TRIGL2CALOHYPOTOOL_H
+#endif //> !TRIGEGAMMAHYPO_TRIGEGAMMAFASTCALOHYPOTOOL_H
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolInc.cxx b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolInc.cxx
deleted file mode 100644
index 1d7cdc08f704cd943c0725e107735d12c45bd400..0000000000000000000000000000000000000000
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2CaloHypoToolInc.cxx
+++ /dev/null
@@ -1,399 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-#include <algorithm>
-#include "TrigCompositeUtils/HLTIdentifier.h"
-#include "TrigCompositeUtils/Combinators.h"
-#include "AthenaMonitoringKernel/Monitored.h"
-#include "GaudiKernel/SystemOfUnits.h"
-
-#include "TrigL2CaloHypoToolInc.h"
-
-
-using namespace TrigCompositeUtils;
-
-TrigL2CaloHypoToolInc::TrigL2CaloHypoToolInc( const std::string& type,
- const std::string& name,
- const IInterface* parent )
- : base_class( type, name, parent ),
- m_selectorTool(),
- m_lumiBlockMuTool("LumiBlockMuTool/LumiBlockMuTool"),
- m_decisionId( HLT::Identifier::fromToolName( name ) )
-{
-declareProperty("LumiBlockMuTool", m_lumiBlockMuTool, "Luminosity Tool" );
-}
-
-StatusCode TrigL2CaloHypoToolInc::initialize() {
-
-ATH_MSG_DEBUG("Name: "<<name()<<" UseRinger: "<<m_useRinger);
-
-if (m_useRinger){
- m_selectorTool.setConstantsCalibPath( m_constantsCalibPath );
- m_selectorTool.setThresholdsCalibPath( m_thresholdsCalibPath );
-
- if(m_selectorTool.initialize().isFailure())
- return StatusCode::FAILURE;
-
- if (m_lumiBlockMuTool.retrieve().isFailure())
- return StatusCode::FAILURE;
-
- ATH_MSG_INFO("TrigL2CaloRingerHypo initialization completed successfully.");
-
-}
- ATH_MSG_DEBUG( "Initialization completed successfully" );
- ATH_MSG_DEBUG( "AcceptAll = " << ( m_acceptAll==true ? "True" : "False" ) );
- ATH_MSG_DEBUG( "EtaBins = " << m_etabin );
- ATH_MSG_DEBUG( "ETthr = " << m_eTthr << "( lo )/" << m_eT2thr << "( hi )" );
- ATH_MSG_DEBUG( "HADETthr = " << m_hadeTthr << "( lo )/" << m_hadeT2thr << "( hi )" );
- ATH_MSG_DEBUG( "CARCOREthr = " << m_carcorethr );
- ATH_MSG_DEBUG( "CAERATIOthr = " << m_caeratiothr );
- ATH_MSG_DEBUG( "dPHICLUSTERthr = " << m_dphicluster );
- ATH_MSG_DEBUG( "dETACLUSTERthr = " << m_detacluster );
- ATH_MSG_DEBUG( "WETA2thr = " << m_WETA2thr );
- ATH_MSG_DEBUG( "WSTOTthr = " << m_WSTOTthr );
- ATH_MSG_DEBUG( "F3thr = " << m_F3thr );
-
- if ( m_etabin.size() == 0 ) {
- ATH_MSG_ERROR( " There are no cuts set (EtaBins property is an empty list)" );
- return StatusCode::FAILURE;
- }
-
- unsigned int nEtaBin = m_etabin.size();
-#define CHECK_SIZE( __n) if ( m_##__n.size() != (nEtaBin - 1) ) \
- { ATH_MSG_DEBUG(" __n size is " << m_##__n.size() << " but needs to be " << (nEtaBin - 1) ); return StatusCode::FAILURE; }
-
- CHECK_SIZE( eTthr );
- CHECK_SIZE( eT2thr );
- CHECK_SIZE( hadeTthr );
- CHECK_SIZE( hadeT2thr );
- CHECK_SIZE( carcorethr );
- CHECK_SIZE( caeratiothr );
- CHECK_SIZE( WETA2thr );
- CHECK_SIZE( WSTOTthr );
- CHECK_SIZE( F3thr );
-#undef CHECK_SIZE
-
- ATH_MSG_DEBUG( "Tool configured for chain/id: " << m_decisionId );
-
- if ( not m_monTool.name().empty() )
- CHECK( m_monTool.retrieve() );
-
- return StatusCode::SUCCESS;
-}
-
-
-
-TrigL2CaloHypoToolInc::~TrigL2CaloHypoToolInc(){}
-
-
-bool TrigL2CaloHypoToolInc::decide( const ITrigL2CaloHypoTool::ClusterInfo& input ) const {
-
- bool pass = false;
-
- if ( m_acceptAll ) {
- pass = true;
- ATH_MSG_DEBUG( "AcceptAll property is set: taking all events" );
- } else {
- pass = false;
- ATH_MSG_DEBUG( "AcceptAll property not set: applying selection" );
- }
-
- // TB Not sure if anything else than the CutCounter should monitored it in every cut tool,
- // Should quantitities be filled only after the succesful selection?
-
- auto monEta = Monitored::Scalar("Eta",-100);
- auto monPhi = Monitored::Scalar("Phi",-100);
-
- if(m_useRinger){
- auto etMon = Monitored::Scalar("Et",-100);
- auto rnnOutMon = Monitored::Scalar("RnnOut",-100);
- auto total_time = Monitored::Timer("TIME_total");
- auto propagate_time = Monitored::Timer("TIME_propagate");
- auto preproc_time = Monitored::Timer("TIME_preproc");
- auto decide_time = Monitored::Timer("TIME_decide");
- auto mon = Monitored::Group(m_monTool,etMon,monEta,monPhi,rnnOutMon,total_time,propagate_time,preproc_time,decide_time);
-
- total_time.start();
- auto ringerShape = input.ringerShape;
- const xAOD::TrigEMCluster *emCluster = 0;
- if(ringerShape){
- emCluster = ringerShape->emCluster();
- //emCluster= input.cluster;
- if(!emCluster){
- ATH_MSG_WARNING( "There is no link to xAOD::TrigEMCluster into the Ringer object.");
- return false;
- }
- }
- else{
- ATH_MSG_WARNING( "There is no xAOD::TrigRingerRings link into the rnnOutput object.");
- return false;
- }
-
- float eta = std::fabs(emCluster->eta());
- float et = emCluster->et() / Gaudi::Units::GeV;
- float avgmu = m_lumiBlockMuTool->averageInteractionsPerCrossing();
-
- if(eta>2.50) eta=2.50;///fix for events out of the ranger
-
- // make sure that monitoring histogram will plotting only the events of chain.
- ///Et threshold
- if(et < m_emEtCut/Gaudi::Units::GeV){
- ATH_MSG_DEBUG( "Event reproved by Et threshold. Et = " << et << ", EtCut = " << m_emEtCut/Gaudi::Units::GeV);
- return false;
- }
-
- monEta = emCluster->eta();
- etMon = emCluster->et();
- monPhi = emCluster->phi();
-
- const std::vector<float> rings = ringerShape->rings();
- std::vector<float> refRings(rings.size());
- refRings.assign(rings.begin(), rings.end());
-
- ATH_MSG_DEBUG("Et = "<< et << " Eta = "<<eta << " mu = " << avgmu << "rsize = "<< refRings.size());
-
- auto output = m_selectorTool.calculate( refRings, et, eta, avgmu, propagate_time, preproc_time );
- rnnOutMon = output;
- ATH_MSG_DEBUG(name()<< " generate as NN output " << output );
-
- decide_time.start();
- bool accept = m_selectorTool.accept(output, et,eta,avgmu);
- decide_time.stop();
-
- total_time.stop();
- return accept;
- }
-
- else{
- auto dEta = Monitored::Scalar( "dEta", -1. );
- auto dPhi = Monitored::Scalar( "dPhi", -1. );
- auto eT_T2Calo = Monitored::Scalar( "Et_em" , -1.0 );
- auto hadET_T2Calo = Monitored::Scalar( "Et_had", -1.0 );
- auto rCore = Monitored::Scalar( "RCore" , -1.0 );
- auto energyRatio = Monitored::Scalar( "ERatio" , -1.0 );
- auto etaBin = Monitored::Scalar( "EtaBin", -1. );
- auto monEta = Monitored::Scalar( "Eta", -99. );
- auto monPhi = Monitored::Scalar( "Phi", -99. );
- auto F1 = Monitored::Scalar( "F1" , -1.0 );
- auto Weta2 = Monitored::Scalar( "Weta2" , -1.0 );
- auto Wstot = Monitored::Scalar( "Wstot" , -1.0 );
- auto F3 = Monitored::Scalar( "F3" , -1.0 );
- auto PassedCuts = Monitored::Scalar<int>( "CutCounter", -1 );
- auto monitorIt = Monitored::Group( m_monTool,
- dEta, dPhi, eT_T2Calo, hadET_T2Calo,
- rCore, energyRatio, etaBin, monEta,
- monPhi, F1, Weta2, Wstot, F3, PassedCuts );
- // when leaving scope it will ship data to monTool
- PassedCuts = PassedCuts + 1; //got called (data in place)
-
- auto roiDescriptor = input.roi;
-
-
- if ( fabs( roiDescriptor->eta() ) > 2.6 ) {
- ATH_MSG_DEBUG( "REJECT The cluster had eta coordinates beyond the EM fiducial volume : " << roiDescriptor->eta() << "; stop the chain now" );
- pass=false; // special case
- return pass;
- }
-
- ATH_MSG_DEBUG( "; RoI ID = " << roiDescriptor->roiId()
- << ": Eta = " << roiDescriptor->eta()
- << ", Phi = " << roiDescriptor->phi() );
-
- // fill local variables for RoI reference position
- double etaRef = roiDescriptor->eta();
- double phiRef = roiDescriptor->phi();
- // correct phi the to right range ( probably not needed anymore )
- if ( fabs( phiRef ) > M_PI ) phiRef -= 2*M_PI; // correct phi if outside range
-
- auto pClus = input.cluster;
-
- float absEta = fabs( pClus->eta() );
- etaBin = -1;
- monEta = pClus->eta();
- monPhi = pClus->phi();
-
- const int cutIndex = findCutIndex( absEta );
-
- // find if electron is in calorimeter crack
- bool inCrack = ( absEta > 2.37 || ( absEta > 1.37 && absEta < 1.52 ) );
-
-
- dEta = pClus->eta() - etaRef;
- // Deal with angle diferences greater than Pi
- dPhi = fabs( pClus->phi() - phiRef );
- dPhi = ( dPhi < M_PI ? dPhi : 2*M_PI - dPhi ); // TB why only <
-
-
- // calculate cluster quantities // definition taken from TrigElectron constructor
- if ( pClus->emaxs1() + pClus->e2tsts1() > 0 )
- energyRatio = ( pClus->emaxs1() - pClus->e2tsts1() ) / ( pClus->emaxs1() + pClus->e2tsts1() );
-
- // ( VD ) here the definition is a bit different to account for the cut of e277 @ EF
- if ( pClus->e277()!= 0. ) rCore = pClus->e237() / pClus->e277();
-
- //fraction of energy deposited in 1st sampling
-
- if ( fabs( pClus->energy() ) > 0.00001 ) F1 = ( pClus->energy( CaloSampling::EMB1 )+pClus->energy( CaloSampling::EME1 ) )/pClus->energy();
-
- eT_T2Calo = pClus->et();
-
- if ( eT_T2Calo!=0 && pClus->eta()!=0 ) hadET_T2Calo = pClus->ehad1()/cosh( fabs( pClus->eta() ) )/eT_T2Calo;
-
-
- //extract Weta2 varable
- Weta2 = pClus->weta2();
-
- //extract Wstot varable
- Wstot = pClus->wstot();
-
- //extract F3 ( backenergy i EM calorimeter
- float e0 = pClus->energy( CaloSampling::PreSamplerB ) + pClus->energy( CaloSampling::PreSamplerE );
- float e1 = pClus->energy( CaloSampling::EMB1 ) + pClus->energy( CaloSampling::EME1 );
- float e2 = pClus->energy( CaloSampling::EMB2 ) + pClus->energy( CaloSampling::EME2 );
- float e3 = pClus->energy( CaloSampling::EMB3 ) + pClus->energy( CaloSampling::EME3 );
- float eallsamples = e0+e1+e2+e3;
- F3 = fabs( eallsamples )>0. ? e3/eallsamples : 0.;
-
- // apply cuts: DeltaEta( clus-ROI )
- ATH_MSG_DEBUG( "TrigEMCluster: eta=" << pClus->eta()
- << " roi eta=" << etaRef << " DeltaEta=" << dEta
- << " cut: <" << m_detacluster );
-
- if ( fabs( pClus->eta() - etaRef ) > m_detacluster ) {
- ATH_MSG_DEBUG("REJECT Cluster dEta cut failed");
- return pass;
- }
- PassedCuts = PassedCuts + 1; //Deta
-
- // DeltaPhi( clus-ROI )
- ATH_MSG_DEBUG( ": phi=" << pClus->phi()
- << " roi phi="<< phiRef << " DeltaPhi="<< dPhi
- << " cut: <" << m_dphicluster );
-
- if( dPhi > m_dphicluster ) {
- ATH_MSG_DEBUG("REJECT Clsuter dPhi cut failed");
- return pass;
- }
- PassedCuts = PassedCuts + 1; //DPhi
-
- // eta range
- if ( cutIndex == -1 ) { // VD
- ATH_MSG_DEBUG( "Cluster eta: " << absEta << " outside eta range " << m_etabin[m_etabin.size()-1] );
- return pass;
- }
- else {
- ATH_MSG_DEBUG( "eta bin used for cuts " << cutIndex );
- }
- PassedCuts = PassedCuts + 1; // passed eta cut
-
- // Rcore
- ATH_MSG_DEBUG ( "TrigEMCluster: Rcore=" << rCore
- << " cut: >" << m_carcorethr[cutIndex] );
- if ( rCore < m_carcorethr[cutIndex] ) {
- ATH_MSG_DEBUG("REJECT rCore cut failed");
- return pass;
- }
- PassedCuts = PassedCuts + 1; //Rcore
-
- // Eratio
- ATH_MSG_DEBUG( " cut: >" << m_caeratiothr[cutIndex] );
- if ( inCrack || F1 < m_F1thr[0] ) {
- ATH_MSG_DEBUG ( "TrigEMCluster: InCrack= " << inCrack << " F1=" << F1 );
- }
- else {
- if ( energyRatio < m_caeratiothr[cutIndex] ) {
- ATH_MSG_DEBUG("REJECT e ratio cut failed");
- return pass;
- }
- }
- PassedCuts = PassedCuts + 1; //Eratio
- if( inCrack ) energyRatio = -1; //Set default value in crack for monitoring.
-
- // ET_em
- ATH_MSG_DEBUG( "TrigEMCluster: ET_em=" << eT_T2Calo << " cut: >" << m_eTthr[cutIndex] );
- if ( eT_T2Calo < m_eTthr[cutIndex] ) {
- ATH_MSG_DEBUG("REJECT et cut failed");
- return pass;
- }
- PassedCuts = PassedCuts + 1; // ET_em
-
- float hadET_cut = 0.0;
- // find which ET_had to apply : this depends on the ET_em and the eta bin
- if ( eT_T2Calo > m_eT2thr[cutIndex] ) {
- hadET_cut = m_hadeT2thr[cutIndex] ;
- ATH_MSG_DEBUG ( "ET_em>" << m_eT2thr[cutIndex] << ": use high ET_had cut: <" << hadET_cut );
- }
- else {
- hadET_cut = m_hadeTthr[cutIndex];
- ATH_MSG_DEBUG ( "ET_em<" << m_eT2thr[cutIndex] << ": use low ET_had cut: <" << hadET_cut );
- }
-
- // ET_had
- ATH_MSG_DEBUG ( "TrigEMCluster: ET_had=" << hadET_T2Calo << " cut: <" << hadET_cut );
-
- if ( hadET_T2Calo > hadET_cut ) {
- ATH_MSG_DEBUG("REJECT et had cut failed");
- return pass;
- }
- PassedCuts = PassedCuts + 1; //ET_had
-
- // F1
- ATH_MSG_DEBUG ( "TrigEMCluster: F1=" << F1 << " cut: >" << m_F1thr[0] );
- PassedCuts = PassedCuts + 1; //F1
-
- //Weta2
- ATH_MSG_DEBUG ( "TrigEMCluster: Weta2=" << Weta2 << " cut: <" << m_WETA2thr[cutIndex] );
- if ( Weta2 > m_WETA2thr[cutIndex] ) {
- ATH_MSG_DEBUG("REJECT weta 2 cut failed");
- return pass;
- }
- PassedCuts = PassedCuts + 1; //Weta2
-
- //Wstot
- ATH_MSG_DEBUG ( "TrigEMCluster: Wstot=" <<Wstot << " cut: <" << m_WSTOTthr[cutIndex] );
- if ( Wstot >= m_WSTOTthr[cutIndex] ) {
- ATH_MSG_DEBUG("REJECT wstot cut failed");
- return pass;
- }
- PassedCuts = PassedCuts + 1; //Wstot
-
- //F3
- ATH_MSG_DEBUG( "TrigEMCluster: F3=" << F3 << " cut: <" << m_F3thr[cutIndex] );
- if ( F3 > m_F3thr[cutIndex] ) {
- ATH_MSG_DEBUG("REJECT F3 cut failed");
- return pass;
- }
- PassedCuts = PassedCuts + 1; //F3
-
- // got this far => passed!
- pass = true;
-
- // Reach this point successfully
- ATH_MSG_DEBUG( "pass = " << pass );
-
- return pass;
- }
-}
-
-int TrigL2CaloHypoToolInc::findCutIndex( float eta ) const {
- const float absEta = std::abs(eta);
-
- auto binIterator = std::adjacent_find( m_etabin.begin(), m_etabin.end(), [=](float left, float right){ return left < absEta and absEta < right; } );
- if ( binIterator == m_etabin.end() ) {
- return -1;
- }
- return binIterator - m_etabin.begin();
-}
-
-
-StatusCode TrigL2CaloHypoToolInc::decide( std::vector<ClusterInfo>& input ) const {
- for ( auto& i: input ) {
- if ( passed ( m_decisionId.numeric(), i.previousDecisionIDs ) ) {
- if ( decide( i ) ) {
- addDecisionID( m_decisionId, i.decision );
- }
- }
- }
- return StatusCode::SUCCESS;
-}
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2PhotonHypoAlgMT.h b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2PhotonHypoAlgMT.h
index 124f35255033a619ffe0082661e854398d7ed5bb..d70297853d4232c893e4bf99eed3c13e979427df 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2PhotonHypoAlgMT.h
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/TrigL2PhotonHypoAlgMT.h
@@ -16,7 +16,7 @@
#include "TrigL2PhotonHypoTool.h"
#include "xAODTrigCalo/TrigEMClusterContainer.h"
#include "DecisionHandling/HypoBase.h"
-#include "ITrigL2CaloHypoTool.h"
+#include "ITrigEgammaFastCaloHypoTool.h"
/**
diff --git a/Trigger/TrigHypothesis/TrigEgammaHypo/src/components/TrigEgammaHypo_entries.cxx b/Trigger/TrigHypothesis/TrigEgammaHypo/src/components/TrigEgammaHypo_entries.cxx
index 0c90140201c07b771fbc7aab1f6e8aebf644c66d..b2f6e16038e42f587093a6f9ac179054fa50fb1a 100644
--- a/Trigger/TrigHypothesis/TrigEgammaHypo/src/components/TrigEgammaHypo_entries.cxx
+++ b/Trigger/TrigHypothesis/TrigEgammaHypo/src/components/TrigEgammaHypo_entries.cxx
@@ -13,15 +13,15 @@
#include "TrigEgammaHypo/TrigEFPhotonHypo.h"
#include "TrigEgammaHypo/TrigEFTrackHypo.h"
#include "TrigEgammaHypo/TrigL2CaloLayersHypo.h"
-#include "../TrigL2CaloHypoAlgMT.h"
-#include "../TrigL2CaloHypoToolInc.h"
+#include "../TrigEgammaFastCaloHypoAlgMT.h"
+#include "../TrigEgammaFastCaloHypoToolInc.h"
#include "../TrigEgammaPrecisionCaloHypoToolInc.h"
#include "../TrigEgammaPrecisionPhotonHypoToolInc.h"
#include "../TrigEgammaPrecisionElectronHypoToolInc.h"
-#include "../TrigL2CaloHypoToolMult.h"
-#include "../TrigL2ElectronHypoTool.h"
-#include "../TrigL2ElectronFexMT.h"
-#include "../TrigL2ElectronHypoAlgMT.h"
+#include "../TrigEgammaFastCaloHypoToolMult.h"
+#include "../TrigEgammaFastElectronHypoTool.h"
+#include "../TrigEgammaFastElectronFexMT.h"
+#include "../TrigEgammaFastElectronHypoAlgMT.h"
#include "../TrigL2PhotonHypoAlgMT.h"
#include "../TrigL2PhotonHypoTool.h"
#include "../TrigEgammaPrecisionCaloHypoAlgMT.h"
@@ -46,16 +46,16 @@ DECLARE_COMPONENT( TrigEFElectronHypo )
DECLARE_COMPONENT( TrigEFPhotonHypo )
DECLARE_COMPONENT( TrigEFTrackHypo )
DECLARE_COMPONENT( TrigL2CaloLayersHypo )
-DECLARE_COMPONENT( TrigL2CaloHypoAlgMT )
-DECLARE_COMPONENT( TrigL2ElectronHypoAlgMT )
+DECLARE_COMPONENT( TrigEgammaFastCaloHypoAlgMT )
+DECLARE_COMPONENT( TrigEgammaFastElectronHypoAlgMT )
DECLARE_COMPONENT( TrigL2PhotonHypoAlgMT )
-DECLARE_COMPONENT( TrigL2CaloHypoToolInc )
+DECLARE_COMPONENT( TrigEgammaFastCaloHypoToolInc )
DECLARE_COMPONENT( TrigEgammaPrecisionCaloHypoToolInc )
DECLARE_COMPONENT( TrigEgammaPrecisionPhotonHypoToolInc )
DECLARE_COMPONENT( TrigEgammaPrecisionElectronHypoToolInc )
-DECLARE_COMPONENT( TrigL2CaloHypoToolMult )
-DECLARE_COMPONENT( TrigL2ElectronHypoTool )
-DECLARE_COMPONENT( TrigL2ElectronFexMT )
+DECLARE_COMPONENT( TrigEgammaFastCaloHypoToolMult )
+DECLARE_COMPONENT( TrigEgammaFastElectronHypoTool )
+DECLARE_COMPONENT( TrigEgammaFastElectronFexMT )
DECLARE_COMPONENT( TrigL2PhotonHypoTool )
DECLARE_COMPONENT( TrigEgammaPrecisionCaloHypoAlgMT )
DECLARE_COMPONENT( TrigEgammaPrecisionCaloHypoToolMult )
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/CommonSequences/CaloSequenceSetup.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/CommonSequences/CaloSequenceSetup.py
index 33dc07b7a24bb9d8cb85fdc51d293a8bb468f7cc..1c843c440d1d14f066211fa726b80ef305cdd7ff 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/CommonSequences/CaloSequenceSetup.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/CommonSequences/CaloSequenceSetup.py
@@ -13,7 +13,7 @@ class CaloMenuDefs(object):
def fastCaloSequence(doRinger):
- """ Creates L2 Fast Calo sequence"""
+ """ Creates Fast Calo sequence"""
# EV creator
from TrigT2CaloCommon.CaloDef import fastCaloEVCreator
(fastCaloViewsMaker, InViewRoIs) = fastCaloEVCreator()
@@ -28,20 +28,20 @@ def fastCaloSequence(doRinger):
def fastCaloMenuSequence(name, doRinger):
- """ Creates L2 Fast Calo MENU sequence
+ """ Creates Egamma Fast Calo MENU sequence
The Hypo name changes depending on name, so for different implementations (Electron, Gamma,....)
The doRinger flag is to use or not the Ringer hypo
"""
(sequence, fastCaloViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(fastCaloSequence, {'doRinger' : doRinger})
# check if use Ringer and are electron because there aren't ringer for photons yet:
# hypo
- from TrigEgammaHypo.TrigEgammaHypoConf import TrigL2CaloHypoAlgMT
- theFastCaloHypo = TrigL2CaloHypoAlgMT(name+"L2CaloHypo")
+ from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastCaloHypoAlgMT
+ theFastCaloHypo = TrigEgammaFastCaloHypoAlgMT(name+"EgammaFastCaloHypo")
theFastCaloHypo.CaloClusters = sequenceOut
CaloMenuDefs.L2CaloClusters = sequenceOut
- from TrigEgammaHypo.TrigL2CaloHypoTool import TrigL2CaloHypoToolFromDict
+ from TrigEgammaHypo.TrigEgammaFastCaloHypoTool import TrigEgammaFastCaloHypoToolFromDict
return MenuSequence( Sequence = sequence,
Maker = fastCaloViewsMaker,
Hypo = theFastCaloHypo,
- HypoToolGen = TrigL2CaloHypoToolFromDict )
+ HypoToolGen = TrigEgammaFastCaloHypoToolFromDict )
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Egamma/ElectronSequenceSetup.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Egamma/ElectronSequenceSetup.py
index 89fc2377eeb04b19b27b4c85fc4a433f5d3ca8d6..ba95dae7fbeab2cbbba94228631e3527f0451133 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Egamma/ElectronSequenceSetup.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Egamma/ElectronSequenceSetup.py
@@ -39,8 +39,8 @@ def fastElectronSequence(ConfigFlags):
if "InDetTrigTrackParticleCreatorAlg" in viewAlg.name():
TrackParticlesName = viewAlg.TrackParticlesName
- from TrigEgammaHypo.TrigL2ElectronFexMTConfig import L2ElectronFex_1
- theElectronFex= L2ElectronFex_1()
+ from TrigEgammaHypo.TrigEgammaFastElectronFexMTConfig import EgammaFastElectronFex_1
+ theElectronFex= EgammaFastElectronFex_1()
theElectronFex.TrigEMClusterName = CaloMenuDefs.L2CaloClusters
theElectronFex.TrackParticlesName = TrackParticlesName
theElectronFex.ElectronsName=recordable("HLT_L2Electrons")
@@ -71,16 +71,16 @@ def fastElectronMenuSequence():
(electronAthSequence, l2ElectronViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(fastElectronSequence, ConfigFlags)
# make the Hypo
- from TrigEgammaHypo.TrigEgammaHypoConf import TrigL2ElectronHypoAlgMT
- theElectronHypo = TrigL2ElectronHypoAlgMT()
+ from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastElectronHypoAlgMT
+ theElectronHypo = TrigEgammaFastElectronHypoAlgMT()
theElectronHypo.Electrons = sequenceOut
theElectronHypo.RunInView=True
- from TrigEgammaHypo.TrigL2ElectronHypoTool import TrigL2ElectronHypoToolFromDict
+ from TrigEgammaHypo.TrigEgammaFastElectronHypoTool import TrigEgammaFastElectronHypoToolFromDict
return MenuSequence( Maker = l2ElectronViewsMaker,
Sequence = electronAthSequence,
Hypo = theElectronHypo,
- HypoToolGen = TrigL2ElectronHypoToolFromDict )
+ HypoToolGen = TrigEgammaFastElectronHypoToolFromDict )
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Electron/ElectronRecoSequences.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Electron/ElectronRecoSequences.py
index c7e2f37c3f319a6c14c9a09981b2ce889fba8321..58f41575ca5ed854629d109ca3e7aae46f6b91bb 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Electron/ElectronRecoSequences.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Electron/ElectronRecoSequences.py
@@ -14,7 +14,7 @@ def l2CaloRecoCfg( flags ):
def l2CaloHypoCfg( flags, name="UNSPECIFIED", CaloClusters="UNSPECIFIED" ):
from AthenaConfiguration.ComponentFactory import CompFactory
- l2CaloHypo = CompFactory.TrigL2CaloHypoAlgMT( name )
+ l2CaloHypo = CompFactory.TrigEgammaFastCaloHypoAlgMT( name )
l2CaloHypo.CaloClusters = CaloClusters
return l2CaloHypo
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Electron/generateElectron.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Electron/generateElectron.py
index 2ef3bef8109971e8f0322e1ee3173338e6b07cbd..b4469d313425d51723a3419e8356dacca2dd7206 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Electron/generateElectron.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Electron/generateElectron.py
@@ -4,7 +4,7 @@ from TriggerMenuMT.HLTMenuConfig.Electron.ElectronRecoSequences import l2CaloRec
from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import CAMenuSequence, \
ChainStep, Chain, getChainStepName, createStepView
-from TrigEgammaHypo.TrigL2CaloHypoTool import TrigL2CaloHypoToolFromDict
+from TrigEgammaHypo.TrigEgammaFastCaloHypoTool import TrigEgammaFastCaloHypoToolFromDict
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from TrigEDMConfig.TriggerEDMRun3 import recordable
from AthenaConfiguration.ComponentFactory import CompFactory
@@ -35,7 +35,7 @@ def generateChains( flags, chainDict ):
fastCaloSequence = CAMenuSequence( Sequence = l2CaloReco.sequence(),
Maker = l2CaloReco.inputMaker(),
Hypo = l2CaloHypo,
- HypoToolGen = TrigL2CaloHypoToolFromDict,
+ HypoToolGen = TrigEgammaFastCaloHypoToolFromDict,
CA = accCalo)
fastCaloSequence.createHypoTools(chainDict)
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Photon/generatePhoton.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Photon/generatePhoton.py
index c75dc472186dbed007ac2394ba4945540dfc2ce3..671b70277a1fbd3aaa8ab95c2259210508f3f189 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Photon/generatePhoton.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Photon/generatePhoton.py
@@ -6,7 +6,7 @@ from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import CAMenuSequence, \
ChainStep, Chain, getChainStepName, createStepView
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
-from TrigEgammaHypo.TrigL2CaloHypoTool import TrigL2CaloHypoToolFromDict
+from TrigEgammaHypo.TrigEgammaFastCaloHypoTool import TrigEgammaFastCaloHypoToolFromDict
from TrigEgammaHypo.TrigL2PhotonHypoTool import TrigL2PhotonHypoToolFromDict
from TrigEDMConfig.TriggerEDMRun3 import recordable
@@ -34,7 +34,7 @@ def generateChains(flags, chainDict):
fastCaloSequence = CAMenuSequence( Sequence = l2CaloReco.sequence(),
Maker = l2CaloReco.inputMaker(),
Hypo = l2CaloHypo,
- HypoToolGen = TrigL2CaloHypoToolFromDict,
+ HypoToolGen = TrigEgammaFastCaloHypoToolFromDict,
CA = accCalo )
fastCaloSequence.createHypoTools(chainDict)