diff --git a/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaCleanMonitoring.py b/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaCleanMonitoring.py
index 53faf515724c4f03760d78694bcb67d95483385e..94ffe45541eea7919811e9ea4e86961a785dbdc0 100644
--- a/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaCleanMonitoring.py
+++ b/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaCleanMonitoring.py
@@ -2,89 +2,16 @@
EgammaChainsToKeepMonitoring={
-# ES triggers
-"e28_lhtight_nod0_ivarloose",
-"e24_lhvloose_nod0",
-"e28_lhtight_nod0_e15_etcut_L1EM7_Zee",
-"e5_lhtight_nod0_e4_etcut_Jpsiee",
-"e26_lhtight_idperf",
-"g60_loose_L1EM15VH",
-"g140_tight",
-"g200_loose",
-# Combined items
-"g35_medium_g25_medium_L12EM20VH",
-"g35_loose_g25_loose_L12EM20VH",
-"2g22_tight",
-"2g20_tight_icalovloose_L12EM15VHI",
-"3g20_loose",
-"e17_lhloose_nod0_2e10_lhloose_nod0_L1EM15VH_3EM8VH",
-"e17_lhloose_nod0_mu14",
-"e7_lhmedium_nod0_mu24",
-"e12_lhloose_nod0_2mu10",
-"2e12_lhloose_nod0_mu10",
-"e20_lhmedium_nod0_g35_loose",
-"e24_lhmedium_nod0_L1EM15VH_g25_medium",
-"e20_lhmedium_nod0_2g10_loose_L1EM15VH_3EM8VH",
-# Single items
-"e28_lhtight",
-"e60_lhmedium_nod0_L1EM24VHI",
-"e60_lhmedium_nod0_L1EM24VHIM",
-"e17_lhvloose_nod0",
-"e12_lhloose_nod0",
-"e60_lhmedium_nod0",
-"e140_lhloose_nod0",
+#pp 2018 chains
+"e26_lhtight",
"g22_tight",
-"g20_tight_icalovloose_L1EM15VHI",
-"g25_loose_L1EM20VH",
-"g25_medium_L1EM20VH",
-"g35_loose_L1EM24VHIM",
-"g35_medium_L1EM20VH",
-"g25_loose",
-"g25_medium",
-"g35_loose",
"g35_medium",
-"g200_loose_L1EM24VHIM",
-# Support triggers
-"e10_etcut_L1EM7",
-"e15_etcut_L1EM7",
-"e30_etcut_L1EM15",
-"e40_etcut_L1EM15",
-"e50_etcut_L1EM15",
-"e60_etcut",
-"e70_etcut",
-"e26_lhmedium_nod0_L1EM20VH",
-# HI
-"e10_etcut_ion",
-"e12_etcut_ion",
-"e15_etcut_ion",
-"g12_etcut_ion",
-"g18_etcut_ion",
-"g20_etcut_ion",
-"e15_loose_ion",
-"e15_medium_ion",
-"e15_lhloose_ion",
-"e15_lhmedium_ion",
-"e18_loose_ion",
-"e18_medium_ion",
-"e18_lhloose_ion",
-"e18_lhmedium_ion",
-"2e10_loose_ion",
-"e15_loose_ion_idperf",
-"e15_medium_ion_idperf",
-"e20_etcut",
-"e20_loose",
-"e20_lhloose",
-"e20_etcut_ion",
-"e20_loose_ion",
-"e20_lhloose_ion",
-"g15_loose",
-"g15_medium",
+"e60_lhmedium_nod0",
+"e17_lhvloose_nod0",
+"e5_lhtight_nod0_e4_etcut_Jpsiee_L1JPSI-1M5",
+#HI 2018 chains
"g20_loose",
-"g20_medium",
-"g15_loose_ion",
-"g15_medium_ion",
-"g20_loose_ion",
-"g20_medium_ion",
-"2g15_loose",
-"2g15_loose_ion"
+"e15_loose",
+"e20_medium",
+"e15_lhmedium"
}
diff --git a/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaDef.py b/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaDef.py
index edd98d22a65bfd9f7972c1ff333db4047aa7c92c..6a8a8f740eb3cd3420b43229f92d64851ad18ec7 100644
--- a/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaDef.py
+++ b/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaDef.py
@@ -62,6 +62,7 @@ from TrigT2CaloEgamma.TrigT2CaloEgammaConfig import (T2CaloEgamma_eGamma,
T2CaloEgamma_Ringer)
from TrigCaloRec.TrigCaloRecConfig import (TrigCaloCellMaker_eGamma,
+ TrigCaloCellMaker_eGamma_LargeRoI,
TrigCaloTowerMaker_eGamma)
from TrigEgammaRec.TrigEgammaToolFactories import TrigCaloClusterMaker_slw
@@ -71,11 +72,13 @@ from TrigEgammaHypo.TrigL2ElectronFexConfig import L2ElectronFex_1
from TrigEgammaHypo.TrigL2PhotonFexConfig import L2PhotonFex_1
from TrigEgammaRec.TrigEgammaRecConfig import TrigEgammaRec
+
from TrigEgammaHypo.TrigEFCaloCalibFexConfig import (TrigEFCaloCalibFex_Electron,TrigEFCaloCalibFex_Photon)
from TrigMultiVarHypo.TrigL2CaloRingerHypoConfig import (TrigL2CaloRingerFexHypo_e_ID,
TrigL2CaloRingerFexHypo_e_NoCut,
+ TrigL2CaloRingerFexHypo_g_NoCut,
TrigL2CaloRingerFexHypo_e_EtCut,
TrigL2CaloRingerFexHypo_g_EtCut)
@@ -120,6 +123,10 @@ from TrigEgammaHypo.TrigEFPhotonHypoConfig import (EFPhotonHypo_g_EtCut,
EFPhotonHypo_g_ID_CaloOnly_Iso)
from TriggerMenu.egamma.EgammaCleanMonitoring import EgammaChainsToKeepMonitoring
+
+# In order to smartly turn off monitoring, and to avoid turning off monitoring on algorithms previusly selected to keep monitoring The following list will keep track of what is turned on:
+ListOfMonitoredHypos=[]
+
from TriggerMenu.menu.CleanMonitoring import KeepMonitoring, DisableMonitoringButValAndTime
# Helper utilities
@@ -138,7 +145,6 @@ def update_map(seq):
# Class to hold all possible Fex configurables
# Can contain both sequences and single instances
-
class EgammaFexBuilder(object):
"""
Summary:
@@ -162,15 +168,22 @@ class EgammaFexBuilder(object):
self._fast_calo_egamma = T2CaloEgamma_eGamma()
self._fast_calo_ringer = T2CaloEgamma_Ringer()
-
+
self._fast_electron = L2ElectronFex_1()
self._fast_photon = L2PhotonFex_1()
self._egamma_rec = TrigEgammaRec.copy(name = "TrigEgammaRec_eGamma",doPrint=False)()
self._egamma_rec_conv = TrigEgammaRec.copy(name = "TrigEgammaRec_Conv_eGamma", doConversions = True,doPrint=False)()
self._egamma_rec_noid = TrigEgammaRec.copy(name = "TrigEgammaRec_NoIDEF_eGamma",doTrackMatching = False,doTrackIsolation = False,doPrint=False)()
- self._egamma_rec_iso = TrigEgammaRec.copy(name = "TrigEgammaRec_Iso_eGamma",PhotonContainerName="egamma_Iso_Photons",
+ self._egamma_rec_ph_caloiso = TrigEgammaRec.copy(name = "TrigEgammaRec_CaloIso_photon",PhotonContainerName="egamma_Iso_Photons",
doTrackMatching = False,doTrackIsolation = False,
doCaloTopoIsolation=True,doPrint=False)()
+ self._egamma_rec_el_caloiso = TrigEgammaRec.copy(name = "TrigEgammaRec_CaloIso_electron",
+ ElectronContainerName="egamma_Iso_Electrons",
+ PhotonContainerName="egamma_Iso_Photons",
+ doCaloTopoIsolation=True,doPrint=False)()
+
+
+
self._cell_maker = TrigCaloCellMaker_eGamma()
self._tower_maker = TrigCaloTowerMaker_eGamma()
self._tower_maker_ion = TrigCaloTowerMaker_eGamma("TrigCaloTowerMaker_eGamma_heavyIon")
@@ -268,14 +281,18 @@ class EgammaFexBuilder(object):
def _get_precisecalo(self,chainDict):
chain_part = chainDict['chainParts']
+ idinfo = chain_part['IDinfo']
calo_ion = False
seq=[]
+
if 'extra' in chain_part:
if chain_part['extra'] == 'ion':
calo_ion = True
if calo_ion:
seq = [theTrigCaloCellMaker_eGammaHI, self._tower_maker_ion, self._cluster_maker]
+ elif 'bloose' in idinfo :
+ seq = [TrigCaloCellMaker_eGamma_LargeRoI(), self._tower_maker_ion, self._cluster_maker]
else:
seq = [self._cell_maker,self._tower_maker,self._cluster_maker]
@@ -298,7 +315,7 @@ class EgammaFexBuilder(object):
chain_part = chainDict['chainParts']
seq = []
if(chain_part['trigType'] == 'e'):
- seq = [self._egamma_rec]
+ seq = [self._get_electronrec(chainDict)]
elif(chain_part['trigType'] == 'g'):
seq = [self._get_photonrec(chainDict)]
else:
@@ -306,21 +323,45 @@ class EgammaFexBuilder(object):
log.debug('preciserec %s',seq)
return seq
+ def _get_electronrec(self,chainDict):
+ chain_part = chainDict['chainParts']
+ do_caloiso = False
+
+ log.debug('Electron preciserec')
+ if 'isoInfo' in chain_part:
+ iso = [x for x in chain_part['isoInfo'] if 'icalo' in x]
+ if len(iso)>0:
+ log.debug('Electron calo isolation %s',iso[0])
+ do_caloiso = True
+ if do_caloiso:
+ log.debug('Electron calo + track isolation')
+ return self._egamma_rec_el_caloiso
+ else:
+ log.debug('Electron default rec')
+ return self._egamma_rec
+
+ log.debug('Electron default rec')
+ return self._egamma_rec
+
def _get_photonrec(self,chainDict):
chain_part = chainDict['chainParts']
do_conv = False
- do_iso = False
+ do_caloiso = False
+
log.debug('Photon preciserec')
if 'addInfo' in chain_part:
if 'conv' in chain_part['addInfo']:
do_conv = True
- if 'isoInfo' in chain_part:
- if chain_part['isoInfo']:
- do_iso = True
- if do_iso:
+ if 'isoInfo' in chain_part:
+ iso = [x for x in chain_part['isoInfo'] if 'icalo' in x]
+ if len(iso)>0:
+ log.debug('Electron calo isolation %s',iso[0])
+ do_caloiso = True
+ if do_caloiso:
log.debug('Photon isolation')
- return self._egamma_rec_iso
+ return self._egamma_rec_ph_caloiso
+
elif do_conv:
log.debug('Photon conversions')
return self._egamma_rec_conv
@@ -328,6 +369,7 @@ class EgammaFexBuilder(object):
log.debug('Photon default rec')
return self._egamma_rec_noid
+
class EgammaHypoBuilder(object):
'''
Summary:
@@ -349,11 +391,13 @@ class EgammaHypoBuilder(object):
''' Properties of chain required to configure the hypos '''
self._properties = {'threshold':0,
'IDinfo':'',
- 'isoInfo':'',
+ 'isoInfo':[],
'lhInfo':'',
'etcut':False,
'perf':False,
'ringer':False,
+ 'sc':False,
+ 'gsf':False,
'g':False,
'e':False,
'hiptrt':False,
@@ -416,7 +460,7 @@ class EgammaHypoBuilder(object):
suffix = self._base_name
parts = [self._properties['IDinfo'],
self._properties['lhInfo'],
- self._properties['isoInfo']]
+ '_'.join(self._properties['isoInfo'])]
for item in parts:
if item:
@@ -524,20 +568,24 @@ class EgammaHypoBuilder(object):
if self._properties['hiptrt']:
return [None,None]
- if 'merged' in idinfo:
+ if 'merged' in idinfo or 'bloose' in idinfo :
fex,hypo = TrigL2CaloRingerFexHypo_e_EtCut(thr)
elif self._properties['perf']:
if(tt == 'e'):
fex,hypo = TrigL2CaloRingerFexHypo_e_NoCut(thr)
if(tt == 'g'):
- fex,hypo = TrigL2CaloRingerFexHypo_e_NoCut(thr)
+ fex,hypo = TrigL2CaloRingerFexHypo_g_NoCut(thr)
elif self._properties['etcut']:
if(tt == 'e'):
fex,hypo = TrigL2CaloRingerFexHypo_e_EtCut(thr)
if(tt == 'g'):
fex,hypo = TrigL2CaloRingerFexHypo_g_EtCut(thr)
elif idinfo:
- fex, hypo = TrigL2CaloRingerFexHypo_e_ID(thr,idinfo,tt)
+ if(tt == 'e'):
+ fex, hypo = TrigL2CaloRingerFexHypo_e_ID(thr,idinfo,tt)
+ if(tt == 'g'):
+ # For now, there is no photon ringer tuning.
+ fex, hypo = TrigL2CaloRingerFexHypo_g_NoCut(thr)
else:
log.error('Cannot configure ringer')
seq = [fex,hypo]
@@ -853,8 +901,18 @@ class EgammaSequence(object):
if step not in seq:
log.debug('Hypo only step %s ', step)
seq[step]=hypo[step]
- if ( self._disable_mon ):
- self._config_monitoring(hypo)
+ if ( self._disable_mon):
+ if not hypo in ListOfMonitoredHypos:
+ #only disable monitoring of hypo if both, chain is *not* in list and if hypo NOT in the list of hypos to keep monitoring
+ self._config_monitoring(hypo)
+ log.debug('DISABLED_MON for '+str(hypo))
+ else:
+ log.debug('NOTDISABLED_MON for '+str(hypo))
+ else:
+ # if here it means this hypo IS to be configured. So store it in ListOfMonitoredHypos, unless is already there:
+ if not hypo in ListOfMonitoredHypos:
+ log.debug('ENABLED_MON for '+str(hypo))
+ ListOfMonitoredHypos.append(hypo)
self.sequences = seq
return seq
diff --git a/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaSliceFlags.py b/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaSliceFlags.py
index 0c0f6abe9c4069a4da2a594f3d5ea13b08734cf9..cc9044d87066aae30376254173f1adada18c3fbe 100755
--- a/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaSliceFlags.py
+++ b/Trigger/TriggerCommon/TriggerMenu/python/egamma/EgammaSliceFlags.py
@@ -49,7 +49,7 @@ class doFastElectronFex(JobProperty):
'''enable L2ElectronFex cuts and sequence'''
statusOn=True
allowedTypes=['bool']
- StoredValue=False
+ StoredValue=True
_flags.append(doFastElectronFex)
@@ -57,15 +57,33 @@ class doRinger(JobProperty):
'''apply ringer selection for Electron chains'''
statusOn=True
allowedTypes=['bool']
- StoredValue=False
+ StoredValue=True
_flags.append(doRinger)
+
+class doRingerBelow15GeV(JobProperty):
+ '''apply ringer selection for Electron chains below 15GeV'''
+ statusOn=True
+ allowedTypes=['bool']
+ StoredValue=False
+
+_flags.append(doRingerBelow15GeV)
+
+
+class doSuperClusters(JobProperty):
+ '''Use Superclusters to build Egamma trigger objects'''
+ statusOn=True
+ allowedTypes=['bool']
+ StoredValue=False
+
+_flags.append(doSuperClusters)
+
class ringerVersion (JobProperty):
""" Version ringer tunes """
- statusOn=False
- allowedTypes=['str','None']
- StoreValues=None
+ statusOn=True
+ allowedTypes=['str']
+ StoredValue='RingerSelectorTools/TrigL2_20180125_v8/'
_flags.append(ringerVersion)
@@ -74,7 +92,7 @@ class pidVersion (JobProperty):
"""
statusOn=True
allowedTypes=['str']
- StoredValue='ElectronPhotonSelectorTools/trigger/rel21_mc16a/'
+ StoredValue='ElectronPhotonSelectorTools/trigger/rel21_20180312/'
_flags.append(pidVersion)
@@ -85,7 +103,7 @@ class clusterCorrectionVersion (JobProperty):
statusOn=True
allowedTypes=['str','None']
allowedValues=['v12phiflip_noecorrnogap','None']
- StoredValue=None
+ StoredValue='v12phiflip_noecorrnogap'
_flags.append(clusterCorrectionVersion)
@@ -95,7 +113,7 @@ class calibMVAVersion (JobProperty):
"""
statusOn=True
allowedTypes=['str']
- StoredValue='egammaMVACalib/online/v3'
+ StoredValue='egammaMVACalib/online/v6'
_flags.append(calibMVAVersion)
@@ -116,17 +134,28 @@ del _flags
# make an alias
EgammaSliceFlags = TriggerFlags.EgammaSlice
-run2Flag = TriggerFlags.run2Config
-if run2Flag=='2016':
- log.info('EgammaSliceFlags set for %s',run2Flag)
- EgammaSliceFlags.pidVersion = 'ElectronPhotonSelectorTools/trigger/rel21_mc16a/'
- EgammaSliceFlags.clusterCorrectionVersion = None
- EgammaSliceFlags.calibMVAVersion = 'egammaMVACalib/online/v3'
-elif run2Flag=='2017':
- log.info('EgammaSliceFlags set for %s',run2Flag)
- EgammaSliceFlags.pidVersion = 'ElectronPhotonSelectorTools/trigger/rel21_20170214/'
- EgammaSliceFlags.clusterCorrectionVersion = 'v12phiflip_noecorrnogap'
- EgammaSliceFlags.calibMVAVersion = 'egammaMVACalib/online/v6'
-else:
- log.info('EgammaSliceFlags not set use defaults',run2Flag)
+def run2ConfigAction(run2Flag):
+ if run2Flag=='2016':
+ log.info('EgammaSliceFlags set for %s',run2Flag)
+ EgammaSliceFlags.ringerVersion = 'RingerSelectorTools/TrigL2_20170505_v6'
+ EgammaSliceFlags.pidVersion = 'ElectronPhotonSelectorTools/trigger/rel21_20170217_mc16a/'
+ EgammaSliceFlags.clusterCorrectionVersion = 'v12phiflip_noecorrnogap'
+ EgammaSliceFlags.calibMVAVersion = 'egammaMVACalib/online/v6'
+ EgammaSliceFlags.doSuperClusters=False
+ elif run2Flag=='2017':
+ log.info('EgammaSliceFlags set for %s',run2Flag)
+ EgammaSliceFlags.ringerVersion = 'RingerSelectorTools/TrigL2_20170505_v6'
+ EgammaSliceFlags.pidVersion = 'ElectronPhotonSelectorTools/trigger/rel21_20170217/'
+ EgammaSliceFlags.clusterCorrectionVersion = 'v12phiflip_noecorrnogap'
+ EgammaSliceFlags.calibMVAVersion = 'egammaMVACalib/online/v6'
+ EgammaSliceFlags.doSuperClusters=False
+ elif run2Flag=='2018':
+ log.info('EgammaSliceFlags set for %s',run2Flag)
+ EgammaSliceFlags.ringerVersion = 'RingerSelectorTools/TrigL2_20180125_v8/'
+ EgammaSliceFlags.pidVersion = 'ElectronPhotonSelectorTools/trigger/rel21_20180312/'
+ EgammaSliceFlags.clusterCorrectionVersion = 'v12phiflip_noecorrnogap'
+ EgammaSliceFlags.calibMVAVersion = 'egammaMVACalib/online/v6' # Hey! Here we need to use new calibration constants....
+ EgammaSliceFlags.doSuperClusters=False
+ else:
+ log.info('EgammaSliceFlags not set use defaults',run2Flag)
diff --git a/Trigger/TriggerCommon/TriggerMenu/python/egamma/ElectronDef.py b/Trigger/TriggerCommon/TriggerMenu/python/egamma/ElectronDef.py
index 90b44cf0373f264fba464bd00ebabe8a93aea0c8..322a5c18847e4077d9e470c8c22a1a7ff775fcf6 100644
--- a/Trigger/TriggerCommon/TriggerMenu/python/egamma/ElectronDef.py
+++ b/Trigger/TriggerCommon/TriggerMenu/python/egamma/ElectronDef.py
@@ -14,6 +14,9 @@ from TrigHIHypo.UE import theUEMaker, theFSCellMaker, theElectronUEMonitoring
from TrigMultiVarHypo.TrigL2CaloRingerHypoConfig import TrigL2CaloRingerFexHypo_e_NoCut
from TrigEgammaHypo.TrigEFCaloHypoConfig import TrigEFCaloHypo_EtCut
from TrigEgammaHypo.TrigL2ElectronFexConfig import L2ElectronFex_Clean
+from TrigGenericAlgs.TrigGenericAlgsConf import PESA__DummyCopyAllTEAlgo
+from TriggerMenu.commonUtils.makeCaloSequences import getFullScanCaloSequences
+from TrigGenericAlgs.TrigGenericAlgsConf import PESA__DummyUnseededAllTEAlgo as DummyRoI
from TriggerJobOpts.TriggerFlags import TriggerFlags
logging.getLogger().info("Importing %s",__name__)
log = logging.getLogger("TriggerMenu.egamma.ElectronDef")
@@ -27,7 +30,8 @@ log = logging.getLogger("TriggerMenu.egamma.ElectronDef")
class L2EFChain_e(L2EFChainDef):
# Define frequently used instances here as class variables
-
+ DummyMergerAlgo = PESA__DummyCopyAllTEAlgo("DummyMergerAlgo")
+ fullScanSeqMap = getFullScanCaloSequences()
def __init__(self, chainDict, seqObj):
self.L2sequenceList = []
@@ -69,6 +73,10 @@ class L2EFChain_e(L2EFChainDef):
if '_v7' in TriggerFlags.triggerMenuSetup():
self.use_v7=True
+ self.doCaloIsolation=False
+ for item in self.chainPart['isoInfo']:
+ if 'icalo' in item:
+ self.doCaloIsolation=True
# eXXvh_ID type chains:
if self.use_v7:
self.setup_electron()
@@ -122,9 +130,20 @@ class L2EFChain_e(L2EFChainDef):
thr = self.chainPart['threshold']
log.debug("Apply ringer %s",self._ringer_selection)
- if TriggerFlags.EgammaSlice.doRinger:
+ if 'noringer' in self.chainPart['addInfo'] or 'ion' in self.chainPart['extra']:
+ log.debug('No Ringer selection used. Disable the ringer for this chain.')
+ self._ringer_selection=False
+ elif TriggerFlags.EgammaSlice.doRinger:
log.debug('Ringer selection applied for all chains above 15 GeV %s',thr)
- if float(thr)>15.0:
+ if 'merged' in self.chainPart['IDinfo']:
+ self._ringer_selection=False
+ elif 'bloose' in self.chainPart['IDinfo']:
+ self._ringer_selection=False
+ elif float(thr)>15.0:
+ log.debug('Ringer selection applied for all chains above 15 GeV %s',thr)
+ self._ringer_selection=True
+ elif float(thr) <= 15.0 and TriggerFlags.EgammaSlice.doRingerBelow15GeV:
+ log.debug('Ringer selection applied for all chains below 15 GeV %s',thr)
self._ringer_selection=True
else:
self._ringer_selection=False
@@ -133,8 +152,11 @@ class L2EFChain_e(L2EFChainDef):
elif self.chainPart['trkInfo']=='idperf':
if float(thr)>15.0:
self._ringer_selection=True
+ elif float(thr) <= 15.0 and TriggerFlags.EgammaSlice.doRingerBelow15GeV:
+ self._ringer_selection=True
else:
self._ringer_selection=False
+
log.debug("Apply ringer is set %s",self._ringer_selection)
@@ -194,7 +216,7 @@ class L2EFChain_e(L2EFChainDef):
name = str(self.chainPart['threshold'])
name = name.split('.')[0]
dofastrecseq = TriggerFlags.EgammaSlice.doFastElectronFex
- if 'perf' in self.chainName:
+ if 'perf' in self.chainPartName:
dofastrecseq=False
log.debug('setup_electron %s, apply ringer %s for %s',self.chainName,self._ringer_selection,thr )
# Ringer chains not tuned for low-et
@@ -207,7 +229,7 @@ class L2EFChain_e(L2EFChainDef):
# but
algo = TrigEFCaloHypo_EtCut("TrigEFCaloHypo_e"+name+"_EtCut",thr)
fastrec_algo = L2ElectronFex_Clean()
- fastrec_hypo = self.el_sequences['fastrec'].pop()
+ fastrec_hypo = self.el_sequences['fastrec'][-1]
precisecalocalib = self.el_sequences['precisecalocalib']
precisecalocalib.pop()
precisecalocalib.extend([algo])
@@ -226,15 +248,19 @@ class L2EFChain_e(L2EFChainDef):
if dofastrecseq:
seq_dict['fastrec']=[fastrec_algo,fastrec_hypo]
log.debug('FastRec sequence %s'%seq_dict['fastrec'])
-
+ # remove track hypo from precisetrack step
+ precisetrack = self.el_sequences['precisetrack']
+ precisetrack.pop()
+ seq_dict['precisetrack']=precisetrack
seq_te_dict['fastcalorec']=('L2_e_step1','cl')
seq_te_dict['fastringerhypo']=('L2_e_step2','clhypo')
- seq_te_dict['fasttrack']=('L2_e_step3','id')
+ seq_te_dict['fasttrack']=('L2_e_step3','ftf')
seq_te_dict['fastrec']=('L2_e_step4','')
seq_te_dict['precisecalo']=('EF_e_step1','calo')
seq_te_dict['precisecalocalib']=('EF_e_step2','calocalib')
- seq_te_dict['precisetrack']=('EF_e_step3','id')
- seq_te_dict['preciserec']=('EF_e_step4','')
+ seq_te_dict['precisetrack']=('EF_e_step3','idtrig')
+ if not self.doCaloIsolation:
+ seq_te_dict['preciserec']=('EF_e_step4','')
else:
seq_te_dict['fastcalorec']=('L2_e_step1','cl')
seq_te_dict['fastringerhypo']=('L2_e_step2','clhypo')
@@ -242,9 +268,52 @@ class L2EFChain_e(L2EFChainDef):
seq_te_dict['fastrec']=('L2_e_step4','')
seq_te_dict['precisecalo']=('EF_e_step1','cl')
seq_te_dict['precisecalocalib']=('EF_e_step2','calocalib')
- seq_te_dict['preciserec']=('EF_e_step4','')
+ if not self.doCaloIsolation:
+ seq_te_dict['preciserec']=('EF_e_step3','')
self.setupFromDict(seq_te_dict,seq_dict)
+
+ if self.doCaloIsolation:
+ # full scan topo and merging w/ RoI TEs
+ te_in=''
+ if dofastrecseq:
+ pos=3
+ for step in self.fullScanSeqMap:
+ self.EFsequenceList.insert(pos,[[te_in],self.fullScanSeqMap[step],step])
+ self.EFsignatureList.insert(pos,[[step]] )
+ te_in=step
+ pos+=1
+
+ self.EFsequenceList.insert(pos,[ ['EF_e_step3',te_in],[self.DummyMergerAlgo],'EF_eCache_step3'])
+ self.EFsignatureList.insert(pos,[['EF_eCache_step3']])
+ self.EFsequenceList.insert(pos+1,[['EF_eCache_step3'],self.el_sequences['preciserec'],'EF_e_step4'])
+ self.EFsignatureList.insert(pos+1,[['EF_e_step4']*self.mult])
+ else:
+ pos=2
+ for step in self.fullScanSeqMap:
+ self.EFsequenceList.insert(pos,[[te_in],self.fullScanSeqMap[step],step])
+ self.EFsignatureList.insert(pos,[[step]] )
+ te_in=step
+ pos+=1
+
+ self.EFsequenceList.insert(pos,[ ['EF_e_step2',te_in],[self.DummyMergerAlgo],'EF_eCache_step2'])
+ self.EFsignatureList.insert(pos,[['EF_eCache_step2']])
+ self.EFsequenceList.insert(pos+1,[['EF_eCache_step2'],self.el_sequences['preciserec'],'EF_e_step3'])
+ self.EFsignatureList.insert(pos+1,[['EF_e_step3']*self.mult])
+
+ ########### TE renaming ###########
+
+ self.TErenamingDict['EF_full']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'_fs')
+ self.TErenamingDict['EF_full_cell']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'_fscalocell')
+ self.TErenamingDict['EF_FSTopoClusters']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'_fscalotopo')
+ self.TErenamingDict['EF_FSTopoClustersED']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'_fscalotopoed')
+
+ if dofastrecseq:
+ self.TErenamingDict['EF_eCache_step3']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'_ED')
+ self.TErenamingDict['EF_e_step4']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult)
+ else:
+ self.TErenamingDict['EF_eCache_step2']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'_ED')
+ self.TErenamingDict['EF_e_step3']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult)
def setup_eXXvh_idperf(self):
@@ -275,8 +344,9 @@ class L2EFChain_e(L2EFChainDef):
precisecalocalib.insert(1,theElectronUEMonitoring)
self.L2sequenceList += [[self.L2InputTE,self.el_sequences['fastcalo'],'L2_e_step1']]
- self.EFsequenceList += [[['L2_e_step1'],[theFSCellMaker], 'EF_e_step1_fs']]
- self.EFsequenceList += [[['EF_e_step1_fs'],[theUEMaker], 'EF_e_step1_ue']]
+ self.EFsequenceList += [[[""],[DummyRoI("MinBiasDummyRoI")], 'L2_dummy_sp']]
+ self.EFsequenceList += [[['L2_dummy_sp'],[theFSCellMaker], 'EF_AllCells']]
+ self.EFsequenceList += [[['EF_AllCells'],[theUEMaker], 'EF_UE']]
self.EFsequenceList += [[['L2_e_step1'],self.el_sequences['precisecalo'],'EF_e_step1']]
self.EFsequenceList += [[['EF_e_step1'],precisecalocalib,'EF_e_step2']]
self.EFsequenceList += [[['EF_e_step2'],self.el_sequences['trackrec'],'EF_e_step3']]
@@ -285,8 +355,9 @@ class L2EFChain_e(L2EFChainDef):
########### Signatures ###########
self.L2signatureList += [ [['L2_e_step1']*self.mult] ]
- self.L2signatureList += [ [['EF_e_step1_fs']] ]
- self.L2signatureList += [ [['EF_e_step1_ue']] ]
+ self.EFsignatureList += [ [['L2_dummy_sp']] ]
+ self.EFsignatureList += [ [['EF_AllCells']] ]
+ self.EFsignatureList += [ [['EF_UE']] ]
self.EFsignatureList += [ [['EF_e_step1']*self.mult] ]
self.EFsignatureList += [ [['EF_e_step2']*self.mult] ]
self.EFsignatureList += [ [['EF_e_step3']*self.mult] ]
@@ -296,8 +367,8 @@ class L2EFChain_e(L2EFChainDef):
self.TErenamingDict = {
'L2_e_step1': mergeRemovingOverlap('L2_', self.chainPartNameNoMult+'cl'),
- 'EF_e_step1_fs': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'fs'),
- 'EF_e_step1_ue': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'ue'),
+ #'EF_e_step1_fs': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'fs'),
+ #'EF_e_step1_ue': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'ue'),
'EF_e_step1': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'cl'),
'EF_e_step2': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'calocalib'),
'EF_e_step3': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'trk'),
@@ -349,11 +420,11 @@ class L2EFChain_e(L2EFChainDef):
self.setupFromDict(seq_te_dict,seq_dict)
# Now insert additional steps
- self.EFsequenceList.insert(0,[['L2_e_step3'],[theFSCellMaker], 'EF_e_step1_fs'])
- self.EFsequenceList.insert(1,[['EF_e_step1_fs'],[theUEMaker], 'EF_e_step1_ue'])
- self.EFsignatureList.insert(0, [['EF_e_step1_fs']] )
- self.EFsignatureList.insert(1, [['EF_e_step1_ue']] )
+ self.EFsequenceList.insert(0,[[""],[DummyRoI("MinBiasDummyRoI")], 'L2_dummy_sp'])
+ self.EFsequenceList.insert(1,[['L2_dummy_sp'],[theFSCellMaker], 'EF_AllCells'])
+ self.EFsequenceList.insert(2,[['EF_AllCells'],[theUEMaker], 'EF_UE'])
+ self.EFsignatureList.insert(0, [['L2_dummy_sp']] )
+ self.EFsignatureList.insert(1, [['EF_AllCells']] )
+ self.EFsignatureList.insert(2, [['EF_UE']] )
- self.TErenamingDict['EF_e_step1_fs']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'fs')
- self.TErenamingDict['EF_e_step1_ue']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'ue')
diff --git a/Trigger/TriggerCommon/TriggerMenu/python/egamma/ElectronDefIdTest.py b/Trigger/TriggerCommon/TriggerMenu/python/egamma/ElectronDefIdTest.py
deleted file mode 100644
index a72dc417b2153fe972aa4a386af6e64eff901077..0000000000000000000000000000000000000000
--- a/Trigger/TriggerCommon/TriggerMenu/python/egamma/ElectronDefIdTest.py
+++ /dev/null
@@ -1,998 +0,0 @@
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-""" Electron trigger slice signatures """
-
-__author__ = 'Moritz Backes & Catrin Bernius'
-__version__=""
-__doc__="Implementation of Electron Signature"
-
-from AthenaCommon.Logging import logging
-logging.getLogger().info("Importing %s",__name__)
-log = logging.getLogger("TriggerMenu.egamma.ElectronDef")
-
-from TriggerMenu.menu.HltConfig import L2EFChainDef, mergeRemovingOverlap
-
-##########################################################################################
-#
-# Import and create fexes and hypos
-# Move global imports to class methods
-# Leave commented for now
-##########################################################################################
-#from TrigT2CaloEgamma.TrigT2CaloEgammaConfig import T2CaloEgamma_eGamma, T2CaloEgamma_SwSeed, T2CaloEgamma_SwSeed_NoCut
-#from TrigT2CaloEgamma.TrigT2CaloEgammaConfig import T2CaloEgamma_SwCluster, T2CaloEgamma_Ringer, T2CaloEgamma_cells
-from TrigT2CaloEgamma.TrigT2CaloEgammaConfig import T2CaloEgamma_cells
-#from TrigL2MissingET.TrigL2MissingETConfig import L2CaloMissingET_Fex
-
-#theT2CaloEgamma_eGamma = T2CaloEgamma_eGamma()
-#theT2CaloEgamma_SwSeed = T2CaloEgamma_SwSeed()
-#theT2CaloEgamma_SwSeed_NoCut = T2CaloEgamma_SwSeed_NoCut()
-#theT2CaloEgamma_SwCluster = T2CaloEgamma_SwCluster()
-#theT2CaloEgamma_Ringer = T2CaloEgamma_Ringer()
-#theL2CaloMissingET_Fex = L2CaloMissingET_Fex()
-theT2CaloEgamma_cells_e = T2CaloEgamma_cells("T2CaloEgamma_cells")
-
-#from TrigIDSCAN.TrigIDSCAN_Config import TrigIDSCAN_eGamma
-#from TrigSiTrack.TrigSiTrack_Config import TrigSiTrack_eGamma, TrigSiTrack_eGamma_robust
-#from TrigL2TRTSegFinder.TrigTRTSegFinder_Config import TrigTRTSegFinder_eGamma
-
-#theTrigIDSCAN_eGamma = TrigIDSCAN_eGamma()
-#theTrigSiTrack_eGamma = TrigSiTrack_eGamma()
-#theTrigSiTrack_eGamma_robust = TrigSiTrack_eGamma_robust()
-#theTrigTRTSegFinder_eGamma = TrigTRTSegFinder_eGamma()
-
-#from TrigEgammaHypo.TrigL2CaloHypoConfig import *
-#from TrigEgammaHypo.TrigL2ElectronFexConfig import *
-#from TrigEgammaHypo.TrigL2ElectronHypoConfig import *
-#from TrigMultiVarHypo.TrigMultiVarHypoConfig import TrigRingerNeuralHypoConfig_e10
-#from TrigMultiVarHypo.TrigMultiVarHypoConfig import TrigRingerNeuralHypoConfig_e5
-#from TrigMultiVarHypo.TrigMultiVarHypoConfig import TrigRingerNeuralHypoConfig_e5_NoCut
-#from TrigMultiVarHypo.TrigMultiVarHypoConfig import TrigRingerNeuralFexConfig_e5
-#from TrigMultiVarHypo.TrigMultiVarHypoConfig import TrigRingerNeuralFexConfig_e10
-
-#from TrigCaloRec.TrigCaloRecConfig import TrigCaloCellMaker_eGamma, TrigCaloCellMaker_eGamma_cells, TrigCaloTowerMaker_eGamma, TrigCaloClusterMaker_slw
-#theTrigCaloCellMaker_eGamma = TrigCaloCellMaker_eGamma()
-#theTrigCaloTowerMaker_eGamma = TrigCaloTowerMaker_eGamma()
-#theTrigCaloClusterMaker_slw = TrigCaloClusterMaker_slw()
-
-#from TrigCaloRec.TrigCaloRecConfig import TrigCaloCellMaker_eGamma_cells
-#theTrigCaloCellMaker_eGamma_cells= TrigCaloCellMaker_eGamma_cells()
-
-from TrigInDetConf.TrigInDetSequence import TrigInDetSequence
-[trkfast, trkprec] = TrigInDetSequence("Electron", "electron", "IDTrig").getSequence()
-
-from TrigInDetConf.TrigInDetSequence import TrigInDetSequence
-[theFastTrackFinderxAOD] = TrigInDetSequence("Electron","electron","FastxAOD").getSequence()
-[theL2StarxAOD] = TrigInDetSequence("Electron","electron","L2StarxAOD").getSequence()
-
-#theTrigEFIDOutsideInTRTOnly_Electron = TrigEFIDSequence("Electron","electron","TRTOnly").getSequence()
-#theTrigEFIDCombined_Electron = TrigEFIDCombined("Electron","photon", "Combined").getSequence()
-from TrigFastTrackFinder.TrigFastTrackFinder_Config import TrigFastTrackFinder_eGamma as TrigFastTrackFinder_Electron
-theTrigFastTrackFinder_Electron = TrigFastTrackFinder_Electron()
-
-#from TrigEgammaHypo.TrigEFTrackHypoConfig import *
-#from TrigEgammaHypo.TrigEFElectronHypoConfig import *
-#from TrigEgammaRec.TrigEgammaRecConfig import *
-#theTrigEgammaRec_eGamma = TrigEgammaRec_eGamma()
-
-
-from TrigGenericAlgs.TrigGenericAlgsConf import PrescaleAlgo
-terminateAlgo = PrescaleAlgo('terminateAlgo')
-
-##########################################################################################
-#
-# L2 & EF Chain configuration helper classes
-#
-##########################################################################################
-
-class L2EFChain_e(L2EFChainDef):
-
- def __init__(self, chainDict):
-
- self.L2sequenceList = []
- self.EFsequenceList = []
- self.L2signatureList = []
- self.EFsignatureList = []
- self.TErenamingDict = []
-
- self.chainPart = chainDict['chainParts']
-
- self.chainL1Item = chainDict['L1item']
- self.chainPartL1Item = self.chainPart['L1item']
-
- self.chainCounter = chainDict['chainCounter']
- self.L2Name = 'L2_'+self.chainPart['chainPartName']
- self.EFName = 'EF_'+self.chainPart['chainPartName']
- self.mult = int(self.chainPart['multiplicity'])
- self.chainName = chainDict['chainName']
- self.chainPartName = self.chainPart['chainPartName']
- self.chainPartNameNoMult = self.chainPartName[1:] if self.mult > 1 else self.chainPartName
- self.chainPartNameNoMult += "_"+self.chainL1Item
-
-
- self.L2InputTE = self.chainPartL1Item or self.chainL1Item
- # cut of L1_, _EMPTY,..., & multiplicity
- self.L2InputTE = self.L2InputTE.replace("L1_","")
- self.L2InputTE = self.L2InputTE.split("_")[0]
- self.L2InputTE = self.L2InputTE[1:] if self.L2InputTE[0].isdigit() else self.L2InputTE
-
-
- # eXXvh_ID type chains:
-
- if self.chainPart['trkInfo']=='idperf': #True:# self.chainPart['IDinfo'] \
- #and not self.chainPart['isoInfo'] \
- #and not self.chainPart['FSinfo'] \
- #and not self.chainPart['recoAlg'] \
- #and not self.chainPart['hypoInfo'] \
- #and not self.chainPart['trkInfo'] \
- #and not self.chainPart['reccalibInfo']:
- self.setup_eXXvh_idperf()
- elif self.chainPart['L2IDAlg']:
- self.setup_eXXvh_ID()
- else:
- self.setup_eXXvh_ID_run2()
-
- L2EFChainDef.__init__(self, self.chainName, self.L2Name, self.chainCounter, self.chainL1Item, self.EFName, self.chainCounter, self.L2InputTE)
-
-
- def defineSequences(self):
-
- for sequence in self.L2sequenceList:
- self.addL2Sequence(*sequence)
-
- for sequence in self.EFsequenceList:
- self.addEFSequence(*sequence)
-
- def defineSignatures(self):
-
- for signature in self.L2signatureList:
- self.addL2Signature(*signature)
-
- for signature in self.EFsignatureList:
- self.addEFSignature(*signature)
-
- def defineTErenaming(self):
- self.TErenamingMap = self.TErenamingDict
-
-
-
-
-############################### DEFINE GROUPS OF CHAINS HERE ##############################
-
-
- def setup_eXXvh_ID(self):
- threshold = self.chainPart['threshold']
- IDinfo = self.chainPart['IDinfo']
- isoInfo = self.chainPart['isoInfo']
- addInfo = self.chainPart['addInfo']
- trkInfo = self.chainPart['trkInfo']
- L2IDAlg = self.chainPart['L2IDAlg']
-
- log.info('setup_eXXvh_ID')
- log.info('threshold: %s',threshold)
- log.info('isoInfo: %s',isoInfo)
- log.info('IDinfo: %s',IDinfo)
- log.info('addInfo: %s',addInfo)
- log.info('trkInfo: %s',trkInfo)
-
- # common imports required for EtCut and Electron ID chains
- # L2 Calo FEX
- from TrigT2CaloEgamma.TrigT2CaloEgammaConfig import T2CaloEgamma_eGamma
- theT2CaloEgamma_eGamma = T2CaloEgamma_eGamma()
-
- # L2 Tracking FEX
- from TrigL2SiTrackFinder.TrigL2SiTrackFinder_Config import TrigL2SiTrackFinder_eGammaA
- from TrigL2SiTrackFinder.TrigL2SiTrackFinder_Config import TrigL2SiTrackFinder_eGammaB
- from TrigL2SiTrackFinder.TrigL2SiTrackFinder_Config import TrigL2SiTrackFinder_eGammaC
-
- # L2 Elecgtron FEX
- from TrigEgammaHypo.TrigL2ElectronFexConfig import L2ElectronFex_L2StarA
- from TrigEgammaHypo.TrigL2ElectronFexConfig import L2ElectronFex_L2StarB
- from TrigEgammaHypo.TrigL2ElectronFexConfig import L2ElectronFex_L2StarC
- # Depends on L2 Strategy
- log.info('L2IDAlg: %s', self.chainPart['L2IDAlg'])
- if self.chainPart['L2IDAlg']:
- if L2IDAlg == 'L2StarA':
- theL2TrackingFex = TrigL2SiTrackFinder_eGammaA()
- theL2ElectronFex = L2ElectronFex_L2StarA()
- elif L2IDAlg == 'L2StarB':
- theL2TrackingFex = TrigL2SiTrackFinder_eGammaB()
- theL2ElectronFex = L2ElectronFex_L2StarB()
- elif L2IDAlg == 'L2StarC':
- theL2TrackingFex = TrigL2SiTrackFinder_eGammaC()
- theL2ElectronFex = L2ElectronFex_L2StarC()
- else:
- log.info('Incorrect L2IDAlg')
- # Default
- else:
- log.info('Use default L2StarA tracking')
- theL2TrackingFex = TrigL2SiTrackFinder_eGammaA()
- theL2ElectronFex = L2ElectronFex_L2StarA()
-
-
-
- # EF Calo
- from TrigCaloRec.TrigCaloRecConfig import TrigCaloCellMaker_eGamma, TrigCaloTowerMaker_eGamma, TrigCaloClusterMaker_slw
- theTrigCaloCellMaker_eGamma = TrigCaloCellMaker_eGamma()
- theTrigCaloTowerMaker_eGamma = TrigCaloTowerMaker_eGamma()
- theTrigCaloClusterMaker_slw = TrigCaloClusterMaker_slw()
-
- # EF Tracking
- from InDetTrigRecExample.EFInDetConfig import TrigEFIDInsideOut_Electron
- theEFElectronIDFex = TrigEFIDInsideOut_Electron("Electron").getSequence()
-
- # EF Electron FEX
- from TrigEgammaRec.TrigEgammaRecConfig import TrigEgammaRec_eGamma
- theTrigEgammaRec_eGamma = TrigEgammaRec_eGamma()
- #print 'ESETUP', self.chainPart
- # these can be made more configurable later (according to tracking algorithms etc...)
- if 'etcut' in self.chainPart['addInfo']:
-
- from TrigEgammaHypo.TrigL2CaloHypoConfig import L2CaloHypo_NoCut
- from TrigEgammaHypo.TrigL2ElectronHypoConfig import L2ElectronHypo_e_NoCut
- from TrigEgammaHypo.TrigEFTrackHypoConfig import EFTrackHypo_e_NoCut
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_EtCut
- theL2CaloHypo = L2CaloHypo_NoCut("L2CaloHypo_e"+str(threshold)+"_NoCut",threshold )
- theL2ElectronHypo = L2ElectronHypo_e_NoCut("L2ElectronHypo_e"+str(threshold)+"_NoCut",threshold )
- theEFTrackHypo = EFTrackHypo_e_NoCut("EFTrackHypo_e"+str(threshold)+"_NoCut",threshold)
- theEFElectronHypo = TrigEFElectronHypo_e_EtCut("TrigEFElectronHypo_e"+str(threshold)+"_EtCut",threshold)
-
- elif 'perf' in self.chainPart['addInfo']:
- from TrigEgammaHypo.TrigL2CaloHypoConfig import L2CaloHypo_NoCut
- from TrigEgammaHypo.TrigL2ElectronHypoConfig import L2ElectronHypo_e_NoCut
- from TrigEgammaHypo.TrigEFTrackHypoConfig import EFTrackHypo_e_NoCut
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_NoCut
- theL2CaloHypo = L2CaloHypo_NoCut("L2CaloHypo_e"+str(threshold)+"_NoCut",threshold )
- theL2ElectronHypo = L2ElectronHypo_e_NoCut("L2ElectronHypo_e"+str(threshold)+"_NoCut",threshold )
- theEFTrackHypo = EFTrackHypo_e_NoCut("EFTrackHypo_e"+str(threshold)+"_NoCut",threshold)
- # EF Electron
- theEFElectronHypo = TrigEFElectronHypo_e_NoCut("TrigEFElectronHypo_e"+str(threshold)+"_NoCut",threshold)
-
- elif self.chainPart['IDinfo']:
- algoSuffix = "e%s_%s()" % (str(threshold),IDinfo)
- log.info('chain suffix: %s', algoSuffix)
- #if 'mvt' in algoSuffix:
- # algoSuffix = algoSuffix.replace('mvt','')
- from TrigEgammaHypo.TrigL2CaloHypoConfig import L2CaloHypo_e_ID
- from TrigEgammaHypo.TrigL2ElectronHypoConfig import L2ElectronHypo_e_ID
- from TrigEgammaHypo.TrigL2ElectronHypoConfig import L2ElectronHypo_e_ID_L2TrkAlg
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_ID
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_Iso
- from TrigEgammaHypo.TrigEFTrackHypoConfig import EFTrackHypo_e
-
- # L2 Calo
- theL2CaloHypo = L2CaloHypo_e_ID("TrigL2CaloHypo_e"+str(threshold)+"_"+str(IDinfo),threshold,IDinfo)
-
- # L2 Electron
- if self.chainPart['L2IDAlg']:
- theL2ElectronHypo = L2ElectronHypo_e_ID_L2TrkAlg("TrigL2ElectronHypo_e"+str(threshold)+"_"+str(IDinfo)+"_"+str(L2IDAlg),threshold,IDinfo,L2IDAlg)
- else:
- theL2ElectronHypo = L2ElectronHypo_e_ID("TrigL2ElectronHypo_e"+str(threshold)+"_"+str(IDinfo),threshold,IDinfo)
-
- # EF Track
- theEFTrackHypo = EFTrackHypo_e("EFTrackHypo_e"+str(threshold)+"_"+str(IDinfo),threshold)
-
- # EF Electron
- if self.chainPart['isoInfo']:
- theEFElectronHypo = TrigEFElectronHypo_e_Iso("TrigEFElectronHypo_e"+str(threshold)+"_"+str(IDinfo)+"_"+str(isoInfo),threshold,IDinfo,isoInfo)
- else:
- theEFElectronHypo = TrigEFElectronHypo_e_ID("TrigEFElectronHypo_e"+str(threshold)+"_"+str(IDinfo),threshold,IDinfo)
- else:
- algoSuffix = "e%s_%s()" % (str(threshold),IDinfo)
- log.error('Chain %s could not be assembled', self.chainPartName)
- log.erro('chain suffix: %s', algoSuffix)
- return False
-
- ########### Sequences ###########
-
- self.L2sequenceList += [[self.L2InputTE,
- [theT2CaloEgamma_eGamma, theL2CaloHypo],
- 'L2_e_step1']]
-
- self.L2sequenceList += [[['L2_e_step1'],
- [theL2TrackingFex]+theL2StarxAOD,
- 'L2_e_step2']]
-
- self.L2sequenceList += [[['L2_e_step2'],
- [theL2ElectronFex, theL2ElectronHypo],
- 'L2_e_step3']]
-
- self.EFsequenceList += [[['L2_e_step3'],
- [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
- 'EF_e_step1']]
-
- self.EFsequenceList += [[['EF_e_step1'],
- theEFElectronIDFex+[ theEFTrackHypo],
- 'EF_e_step2']]
-
- self.EFsequenceList += [[['EF_e_step2'],
- [theTrigEgammaRec_eGamma, theEFElectronHypo],
- 'EF_e_step3']]
-
- ########### Signatures ###########
-
- self.L2signatureList += [ [['L2_e_step1']*self.mult] ]
- self.L2signatureList += [ [['L2_e_step2']*self.mult] ]
- self.L2signatureList += [ [['L2_e_step3']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step1']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step2']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step3']*self.mult] ]
-
- ########### TE renaming ###########
-
- self.TErenamingDict = {
- 'L2_e_step1': mergeRemovingOverlap('L2_', self.chainPartNameNoMult+'cl'),
- 'L2_e_step2': mergeRemovingOverlap('L2_', self.chainPartNameNoMult+'id'),
- 'L2_e_step3': mergeRemovingOverlap('L2_', self.chainPartNameNoMult),
- 'EF_e_step1': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'calo'),
- 'EF_e_step2': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'id'),
- 'EF_e_step3': mergeRemovingOverlap('EF_', self.chainPartNameNoMult),
- }
-
-
- def setup_eXXvh_idperf(self):
-
- threshold = self.chainPart['threshold']
- IDinfo = self.chainPart['IDinfo']
- isoInfo = self.chainPart['isoInfo']
- run1 = self.chainPart['trkInfo']
-
- log.info('setup_eXXvh_idperf')
- log.info('threshold: %s',threshold)
- log.info('isoInfo: %s',isoInfo)
- log.info('IDinfo: %s',IDinfo)
- log.info('trkInfo: %s',run1)
-
- # L2 Tracking FEX
- from TrigL2SiTrackFinder.TrigL2SiTrackFinder_Config import TrigL2SiTrackFinder_eGammaA
- from TrigL2SiTrackFinder.TrigL2SiTrackFinder_Config import TrigL2SiTrackFinder_eGammaB
- from TrigL2SiTrackFinder.TrigL2SiTrackFinder_Config import TrigL2SiTrackFinder_eGammaC
- theTrigL2SiTrackFinder_eGammaA=TrigL2SiTrackFinder_eGammaA()
- theTrigL2SiTrackFinder_eGammaB=TrigL2SiTrackFinder_eGammaB()
- theTrigL2SiTrackFinder_eGammaC=TrigL2SiTrackFinder_eGammaC()
- # EF Calo
- from TrigCaloRec.TrigCaloRecConfig import TrigCaloCellMaker_eGamma_cells
- #theTrigCaloCellMaker_eGamma_cells= TrigCaloCellMaker_eGamma_cells()
- from TrigCaloRec.TrigCaloRecConfig import TrigCaloCellMaker_eGamma, TrigCaloTowerMaker_eGamma, TrigCaloClusterMaker_slw
- theTrigCaloCellMaker_eGamma = TrigCaloCellMaker_eGamma()
- theTrigCaloTowerMaker_eGamma = TrigCaloTowerMaker_eGamma()
- theTrigCaloClusterMaker_slw = TrigCaloClusterMaker_slw()
-
- # EF Tracking
- from InDetTrigRecExample.EFInDetConfig import TrigEFIDInsideOut_Electron
- theEFElectronIDFex = TrigEFIDInsideOut_Electron("Electron").getSequence()
-
- # EF Electron FEX
- from TrigEgammaRec.TrigEgammaRecConfig import TrigEgammaRec_eGamma
- theTrigEgammaRec_eGamma = TrigEgammaRec_eGamma()
- #print 'ESETUP', self.chainPart
- # these can be made more configurable later (according to tracking algorithms etc...)
-
- if 'etcut' in self.chainPart['addInfo']:
- from TrigEgammaHypo.TrigL2CaloHypoConfig import L2CaloHypo_NoCut
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_EtCut
- theL2CaloHypo = L2CaloHypo_NoCut("L2CaloHypo_e"+str(threshold)+"_NoCut",threshold )
- theEFElectronHypo = TrigEFElectronHypo_e_EtCut("TrigEFElectronHypo_e"+str(threshold)+"_EtCut",threshold)
- elif self.chainPart['IDinfo']:
- from TrigEgammaHypo.TrigL2CaloHypoConfig import L2CaloHypo_e_ID
- theL2CaloHypo = L2CaloHypo_e_ID("TrigL2CaloHypo_e"+str(threshold)+"_"+str(IDinfo),threshold,IDinfo)
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_ID_CaloOnly
- theEFElectronHypo = \
- TrigEFElectronHypo_e_ID_CaloOnly("TrigEFElectronHypo_e"+str(threshold)+"_"+str(IDinfo)+"_CaloOnly",threshold,IDinfo)
-
-
- ########### Sequences ###########
- trkseq = trkfast+trkprec
-
- #calo thresholds here?
- self.L2sequenceList += [[self.L2InputTE,
- [theT2CaloEgamma_cells_e, theL2CaloHypo],
- 'L2_e_step1']]
-
- self.EFsequenceList += [[['L2_e_step1'],
- [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
- 'EF_e_step1']]
-
- if 'L2Star' in self.chainPart['addInfo']:
- self.EFsequenceList += [[['EF_e_step1'],
- [theTrigL2SiTrackFinder_eGammaA]+theL2StarxAOD+
- [theTrigL2SiTrackFinder_eGammaB]+theL2StarxAOD+
- [theTrigL2SiTrackFinder_eGammaC]+theL2StarxAOD+theEFElectronIDFex,
- 'EF_e_step2']]
- else:
- self.EFsequenceList += [[['EF_e_step1'],
- trkseq,
- 'EF_e_step2']]
-
- self.EFsequenceList += [[['EF_e_step2'],
- [theTrigEgammaRec_eGamma, theEFElectronHypo],
- 'EF_e_step3']]
-
- ########### Signatures ###########
-
- self.L2signatureList += [ [['L2_e_step1']*self.mult] ]
- #self.L2signatureList += [ [['L2_e_step2']*self.mult] ]
- #self.L2signatureList += [ [['L2_e_step3']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step1']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step2']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step3']*self.mult] ]
-
- ########### TE renaming ###########
-
- self.TErenamingDict = {
- 'L2_e_step1': mergeRemovingOverlap('L2_', self.chainPartNameNoMult+'cl'),
- 'EF_e_step1': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'cl'),
- 'EF_e_step2': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'trk'),
- 'EF_e_step3': mergeRemovingOverlap('EF_', self.chainPartNameNoMult),
- }
-
-
- def setup_eXXvh_ID_run2(self):
- threshold = self.chainPart['threshold']
- IDinfo = self.chainPart['IDinfo']
- isoInfo = self.chainPart['isoInfo']
- trkInfo = self.chainPart['trkInfo']
-
- log.info('setup_eXXvh_ID_run2')
- log.info('threshold: %s',threshold)
- log.info('isoInfo: %s',isoInfo)
- log.info('IDinfo: %s',IDinfo)
- log.info('trkInfo: %s',trkInfo)
-
- # common imports required for EtCut and Electron ID chains
- # L2 Calo FEX
- from TrigT2CaloEgamma.TrigT2CaloEgammaConfig import T2CaloEgamma_eGamma
- theT2CaloEgamma_eGamma = T2CaloEgamma_eGamma()
-
- # L2 Elecgtron FEX
- from TrigEgammaHypo.TrigL2ElectronFexConfig import L2ElectronFex_1
- # Depends on L2 Strategy
- theL2ElectronFex = L2ElectronFex_1()
-
- # EF Calo
- from TrigCaloRec.TrigCaloRecConfig import TrigCaloCellMaker_eGamma, TrigCaloTowerMaker_eGamma, TrigCaloClusterMaker_slw
- theTrigCaloCellMaker_eGamma = TrigCaloCellMaker_eGamma()
- theTrigCaloTowerMaker_eGamma = TrigCaloTowerMaker_eGamma()
- theTrigCaloClusterMaker_slw = TrigCaloClusterMaker_slw()
-
- # EF Tracking
- theEFElectronIDFex = theTrigEFIDInsideOutMerged_Electron
- # EF Electron FEX
- from TrigEgammaRec.TrigEgammaRecConfig import TrigEgammaRec_eGamma
- theTrigEgammaRec_eGamma = TrigEgammaRec_eGamma()
- #print 'ESETUP', self.chainPart
- # these can be made more configurable later (according to tracking algorithms etc...)
- if 'etcut' in self.chainPart['addInfo']:
-
- from TrigEgammaHypo.TrigL2CaloHypoConfig import L2CaloHypo_NoCut
- from TrigEgammaHypo.TrigL2ElectronHypoConfig import L2ElectronHypo_e_NoCut
- from TrigEgammaHypo.TrigEFTrackHypoConfig import EFTrackHypo_e_NoCut
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_EtCut
- theL2CaloHypo = L2CaloHypo_NoCut("L2CaloHypo_e"+str(threshold)+"_NoCut",threshold )
- theL2ElectronHypo = L2ElectronHypo_e_NoCut("L2ElectronHypo_e"+str(threshold)+"_NoCut",threshold )
- theEFTrackHypo = EFTrackHypo_e_NoCut("EFTrackHypo_e"+str(threshold)+"_NoCut",threshold)
- theEFElectronHypo = TrigEFElectronHypo_e_EtCut("TrigEFElectronHypo_e"+str(threshold)+"_EtCut",threshold)
- elif 'perf' in self.chainPart['addInfo']:
- from TrigEgammaHypo.TrigL2CaloHypoConfig import L2CaloHypo_NoCut
- from TrigEgammaHypo.TrigL2ElectronHypoConfig import L2ElectronHypo_e_NoCut
- from TrigEgammaHypo.TrigEFTrackHypoConfig import EFTrackHypo_e_NoCut
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_NoCut
- theL2CaloHypo = L2CaloHypo_NoCut("L2CaloHypo_e"+str(threshold)+"_NoCut",threshold )
- theL2ElectronHypo = L2ElectronHypo_e_NoCut("L2ElectronHypo_e"+str(threshold)+"_NoCut",threshold )
- theEFTrackHypo = EFTrackHypo_e_NoCut("EFTrackHypo_e"+str(threshold)+"_NoCut",threshold)
- # EF Electron
- theEFElectronHypo = TrigEFElectronHypo_e_NoCut("TrigEFElectronHypo_e"+str(threshold)+"_NoCut",threshold)
-
- elif self.chainPart['IDinfo']:
- algoSuffix = "e%s_%s()" % (str(threshold),IDinfo)
- log.info('chain suffix: %s', algoSuffix)
- #if 'mvt' in algoSuffix:
- # algoSuffix = algoSuffix.replace('mvt','')
- from TrigEgammaHypo.TrigL2CaloHypoConfig import L2CaloHypo_e_ID
- from TrigEgammaHypo.TrigL2ElectronHypoConfig import L2ElectronHypo_e_ID
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_ID
- from TrigEgammaHypo.TrigEFElectronHypoConfig import TrigEFElectronHypo_e_Iso
- from TrigEgammaHypo.TrigEFTrackHypoConfig import EFTrackHypo_e
-
- # L2 Calo
- theL2CaloHypo = L2CaloHypo_e_ID("TrigL2CaloHypo_e"+str(threshold)+"_"+str(IDinfo),threshold,IDinfo)
-
- # L2 Electron
- theL2ElectronHypo = L2ElectronHypo_e_ID("TrigL2ElectronHypo_e"+str(threshold)+"_"+str(IDinfo),threshold,IDinfo)
-
- # EF Track
- theEFTrackHypo = EFTrackHypo_e("EFTrackHypo_e"+str(threshold)+"_"+str(IDinfo),threshold)
-
- # EF Electron
- if self.chainPart['isoInfo']:
- theEFElectronHypo = TrigEFElectronHypo_e_Iso("TrigEFElectronHypo_e"+str(threshold)+"_"+str(IDinfo)+"_"+str(isoInfo),threshold,IDinfo,isoInfo)
- else:
- theEFElectronHypo = TrigEFElectronHypo_e_ID("TrigEFElectronHypo_e"+str(threshold)+"_"+str(IDinfo),threshold,IDinfo)
- else:
- algoSuffix = "e%s_%s()" % (str(threshold),IDinfo)
- log.error('Chain %s could not be assembled', self.chainPartName)
- log.erro('chain suffix: %s', algoSuffix)
- return False
-
- ########### Sequences ###########
-
- trkcomb1st = list(theTrigEFIDDataPrep_Electron)
- trkcomb1st.append(theTrigFastTrackFinder_Electron)
- trkcomb1st += theFastTrackFinderxAOD
- trkcombfull = list(trkcomb1st)
- trkcombfull += theTrigEFIDInsideOutMerged_Electron
-
- self.L2sequenceList += [[self.L2InputTE,
- [theT2CaloEgamma_eGamma, theL2CaloHypo],
- 'L2_e_step1']]
-
- self.L2sequenceList += [[['L2_e_step1'],
- trkfast,
- 'L2_e_step2']]
-
- self.L2sequenceList += [[['L2_e_step2'],
- [theL2ElectronFex, theL2ElectronHypo],
- 'L2_e_step3']]
-
- self.EFsequenceList += [[['L2_e_step3'],
- [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
- 'EF_e_step1']]
-
- self.EFsequenceList += [[['EF_e_step1'],
- theEFElectronIDFex+[ theEFTrackHypo],
- #trkfast+trkprec+[ theEFTrackHypo],
- 'EF_e_step2']]
-
- self.EFsequenceList += [[['EF_e_step2'],
- [theTrigEgammaRec_eGamma, theEFElectronHypo],
- 'EF_e_step3']]
-
- ########### Signatures ###########
-
- self.L2signatureList += [ [['L2_e_step1']*self.mult] ]
- self.L2signatureList += [ [['L2_e_step2']*self.mult] ]
- self.L2signatureList += [ [['L2_e_step3']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step1']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step2']*self.mult] ]
- self.EFsignatureList += [ [['EF_e_step3']*self.mult] ]
-
- ########### TE renaming ###########
-
- self.TErenamingDict = {
- 'L2_e_step1': mergeRemovingOverlap('L2_', self.chainPartNameNoMult+'cl'),
- 'L2_e_step2': mergeRemovingOverlap('L2_', self.chainPartNameNoMult+'id'),
- 'L2_e_step3': mergeRemovingOverlap('L2_', self.chainPartNameNoMult),
- 'EF_e_step1': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'calo'),
- 'EF_e_step2': mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'id'),
- 'EF_e_step3': mergeRemovingOverlap('EF_', self.chainPartNameNoMult),
- }
-
-# class L2EFChain_e_NoIDTrkCut(L2EFChain_e):
-
-# def defineSequences(self, config):
-# ###### L2 ######
-# # Step 1: Calo Fex and Hypo
-# self.addL2Sequence(self.inputTEs,
-# [theT2CaloEgamma_cells_e, config.L2Config.TrigL2CaloHypo_1],
-# 'L2_e_step1')
-
-# # Step 2: ID Fex
-# #append "_R1" to IDTrkNoCut chains running IDScan and SiTrack
-# if '_R1' in self.sig_id:
-# self.addL2Sequence(['L2_e_step1'],
-# [theTrigL2SiTrackFinder_eGammaA,
-# theTrigL2SiTrackFinder_eGammaB,
-# theTrigL2SiTrackFinder_eGammaC,
-# theTrigL2SiTrackFinder_eGammaBC,
-# theTrigIDSCAN_eGamma, theTrigSiTrack_eGamma, theTrigTRTSegFinder_eGamma,
-# ],
-# 'L2_e_step2')
-
-# elif 'L2Star' in self.sig_id:
-# self.addL2Sequence(['L2_e_step1'],
-# [theTrigL2SiTrackFinder_eGammaA, theTrigL2SiTrackFinder_eGammaB, theTrigL2SiTrackFinder_eGammaC],
-# 'L2_e_step2')
-
-# else:
-# #remove IDScan and SiTrack from IDTrkNoCut chains
-# self.addL2Sequence(['L2_e_step1'],
-# [theTrigL2SiTrackFinder_eGammaA,
-# theTrigL2SiTrackFinder_eGammaB,
-# theTrigL2SiTrackFinder_eGammaC,
-# theTrigL2SiTrackFinder_eGammaBC,
-# theTrigTRTSegFinder_eGamma,
-# ],
-# 'L2_e_step2')
-
-# # Step 3: ID-Calo Fex and Hypo
-# if 'L2Star' in self.sig_id:
-# self.addL2Sequence(['L2_e_step2'], [config.L2Config.TrigL2ElectronFex_1], 'L2_e_step3')
-# else:
-# self.addL2Sequence(['L2_e_step2'],
-# [config.L2Config.TrigL2ElectronFex_1, config.L2Config.TrigL2ElectronHypo_1],
-# 'L2_e_step3')
-
-
-# ###### EF ######
-# # Step 1: Calo Fex
-# self.addEFSequence('L2_e_step3',
-# [theTrigCaloCellMaker_eGamma_cells, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
-# 'EF_e_step1')
-# # Step 2: ID Fex and Hypo
-# self.addEFSequence('EF_e_step1', theTrigEFIDInsideOut_Electron, 'EF_e_step2')
-# self.addEFSequence('EF_e_step2', theTrigEFIDOutsideInTRTOnly_Electron, 'EF_e_step3')
-# # Step 3: ID-Calo Fex and Hypo
-# self.addEFSequence('EF_e_step3',
-# [theTrigEgammaRec_eGamma, config.EFConfig.TrigEFEGammaHypo_1],
-# 'EF_e_step4')
-
-
-# def defineSignatures(self):
-# self.addL2Signature(['L2_e_step1']*self.mult)
-# self.addL2Signature(['L2_e_step2']*self.mult)
-# self.addL2Signature(['L2_e_step3']*self.mult)
-# self.addEFSignature(['EF_e_step1']*self.mult)
-# self.addEFSignature(['EF_e_step2']*self.mult)
-# self.addEFSignature(['EF_e_step3']*self.mult)
-# self.addEFSignature(['EF_e_step4']*self.mult)
-
-# def defineTErenaming(self):
-# self.TErenamingMap = {
-# 'L2_e_step1': mergeRemovingOverlap('L2_', self.sig_id_noMult+'cl'),
-# 'L2_e_step2': mergeRemovingOverlap('L2_', self.sig_id_noMult+'id'),
-# 'L2_e_step3': mergeRemovingOverlap('L2_', self.sig_id_noMult),
-# 'EF_e_step1': mergeRemovingOverlap('EF_', self.sig_id_noMult+'calo'),
-# 'EF_e_step2': mergeRemovingOverlap('EF_', self.sig_id_noMult+'id1'),
-# 'EF_e_step3': mergeRemovingOverlap('EF_', self.sig_id_noMult+'id2'),
-# 'EF_e_step4': mergeRemovingOverlap('EF_', self.sig_id_noMult),
-# }
-
-
-
-
-
-# class L2EFChain_e_L2Star(L2EFChain_e):
-# def defineSequences(self, config):
-
-# lastpart = self.getlastpart(self.sig_id)
-
-# if lastpart == 'L2StarA':
-# myTrigL2SiTrackFinder_eGamma_1 = theTrigL2SiTrackFinder_eGammaA
-# myl2electronfex = L2ElectronFex_L2StarA()
-# elif lastpart == 'L2StarB':
-# myTrigL2SiTrackFinder_eGamma_1 = theTrigL2SiTrackFinder_eGammaB
-# myl2electronfex = L2ElectronFex_L2StarB()
-# elif lastpart == 'L2StarC':
-# myTrigL2SiTrackFinder_eGamma_1 = theTrigL2SiTrackFinder_eGammaC
-# myl2electronfex = L2ElectronFex_L2StarC()
-# else:
-# myTrigL2SiTrackFinder_eGamma_1 = theTrigL2SiTrackFinder_eGammaA
-# myl2electronfex = L2ElectronFex_L2StarA()
-
-
-# l2electronhypo = TrigL2ElectronHypo('L2ElectronHypo_'+self.sig_id)
-
-# ###### L2 ######
-# if ('etcut_L2Star' in self.sig_id):
-# self.addL2Sequence(self.inputTEs,[theT2CaloEgamma_eGamma], 'L2_e_step1')
-# self.addL2Sequence(['L2_e_step1'], [myTrigL2SiTrackFinder_eGamma_1], 'L2_e_step2')
-# self.addL2Sequence(['L2_e_step2'], [myl2electronfex], 'L2_e_step3')
-# else:
-# self.addL2Sequence(self.inputTEs,
-# [theT2CaloEgamma_eGamma, config.L2Config.TrigL2CaloHypo_1],
-# 'L2_e_step1')
-# self.addL2Sequence(['L2_e_step1'], [myTrigL2SiTrackFinder_eGamma_1], 'L2_e_step2')
-# self.addL2Sequence(['L2_e_step2'], [myl2electronfex, l2electronhypo], 'L2_e_step3')
-
-
-# ###### EF ######
-# self.addEFSequence('L2_e_step3',
-# [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
-# 'EF_e_step1')
-
-# if ('etcut_L2Star' in self.sig_id):
-# self.addEFSequence('EF_e_step1', theTrigEFIDInsideOut_Electron, 'EF_e_step2')
-# self.addEFSequence('EF_e_step2', [theTrigEgammaRec_eGamma], 'EF_e_step3')
-# else:
-# self.addEFSequence('EF_e_step1',
-# theTrigEFIDInsideOut_Electron + [config.EFConfig.TrigEFTrackHypo_1],
-# 'EF_e_step2')
-# self.addEFSequence('EF_e_step2',
-# [theTrigEgammaRec_eGamma, config.EFConfig.TrigEFEGammaHypo_1],
-# 'EF_e_step3')
-
-
-
-# ############################################# Savannah #101482 1)
-# class L2EFChain_e_noL2ID(L2EFChain_e):
-# def defineSequences(self, config):
-# self.addL2Sequence(self.inputTEs,
-# [theT2CaloEgamma_eGamma, config.L2Config.TrigL2CaloHypo_1],
-# 'L2_e_step1')
-# self.addEFSequence('L2_e_step1',
-# [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
-# 'EF_e_step1')
-# self.addEFSequence('EF_e_step1',
-# theTrigEFIDInsideOut_Electron + [config.EFConfig.TrigEFTrackHypo_1],
-# 'EF_e_step2')
-# self.addEFSequence('EF_e_step2',
-# [theTrigEgammaRec_eGamma, config.EFConfig.TrigEFEGammaHypo_1],
-# 'EF_e_step3')
-
-# def defineSignatures(self):
-# self.addL2Signature(['L2_e_step1']*self.mult)
-# self.addEFSignature(['EF_e_step1']*self.mult)
-# self.addEFSignature(['EF_e_step2']*self.mult)
-# self.addEFSignature(['EF_e_step3']*self.mult)
-
-# def defineTErenaming(self):
-# self.TErenamingMap = {
-# 'L2_e_step1': mergeRemovingOverlap('L2_', self.sig_id_noMult),
-# 'EF_e_step1': mergeRemovingOverlap('EF_', self.sig_id_noMult+'calo'),
-# 'EF_e_step2': mergeRemovingOverlap('EF_', self.sig_id_noMult+'id'),
-# 'EF_e_step3': mergeRemovingOverlap('EF_', self.sig_id_noMult),
-# }
-
-
-# ############################################# Savannah #101482 2)
-# class L2EFChain_e_noL2IDnoEFID(L2EFChain_e):
-# def defineSequences(self, config):
-# # L2 ######
-# # Step 1: Calo Fex and Hypo
-# self.addL2Sequence(self.inputTEs,
-# [theT2CaloEgamma_eGamma, config.L2Config.TrigL2CaloHypo_1],
-# 'L2_e_step1')
-
-# # EF ######
-# # Step 1: Calo Fex
-# self.addEFSequence('L2_e_step1',
-# [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
-# 'EF_e_step1')
-
-# # Step 3: ID-Calo Fex and Hypo
-# self.addEFSequence('EF_e_step1',
-# [theTrigEgammaRec_eGamma, config.EFConfig.TrigEFEGammaHypo_1],
-# 'EF_e_step2')
-
-# def defineSignatures(self):
-# self.addL2Signature(['L2_e_step1']*self.mult)
-# self.addEFSignature(['EF_e_step1']*self.mult)
-# self.addEFSignature(['EF_e_step2']*self.mult)
-
-# def defineTErenaming(self):
-# self.TErenamingMap = {
-# 'L2_e_step1': mergeRemovingOverlap('L2_', self.sig_id_noMult),
-# 'EF_e_step1': mergeRemovingOverlap('EF_', self.sig_id_noMult+'calo'),
-# 'EF_e_step2': mergeRemovingOverlap('EF_', self.sig_id_noMult),
-# }
-
-# ############################################# Savannah #101482 3)
-# class L2EFChain_e_noL2IDnoEF(L2EFChain_e):
-
-# def defineSequences(self, config):
-# self.addL2Sequence(self.inputTEs,
-# [theT2CaloEgamma_eGamma, config.L2Config.TrigL2CaloHypo_1],
-# 'L2_e_step1')
-
-# def defineSignatures(self):
-# self.addL2Signature(['L2_e_step1']*self.mult)
-
-# def defineTErenaming(self):
-# self.TErenamingMap = {
-# 'L2_e_step1': mergeRemovingOverlap('L2_', self.sig_id_noMult),
-# }
-
-# ############################################# Savannah #101482 4)
-# class L2EFChain_e_noL2noEFID(L2EFChain_e):
-
-# def defineSequences(self, config):
-# self.addEFSequence(self.inputTEs,
-# [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
-# 'EF_e_step1')
-# self.addEFSequence('EF_e_step1',
-# [theTrigEgammaRec_eGamma, config.EFConfig.TrigEFEGammaHypo_1],
-# 'EF_e_step2')
-
-# def defineSignatures(self):
-# self.addEFSignature(['EF_e_step1']*self.mult)
-# self.addEFSignature(['EF_e_step2']*self.mult)
-
-# def defineTErenaming(self):
-# self.TErenamingMap = {
-# 'EF_e_step1': mergeRemovingOverlap('EF_', self.sig_id_noMult+'calo'),
-# 'EF_e_step2': mergeRemovingOverlap('EF_', self.sig_id_noMult),
-# }
-
-# ############################################# Savannah #101482 5)
-# class L2EFChain_e_noL2(L2EFChain_e):
-
-# def defineSequences(self, config):
-# self.addEFSequence(self.inputTEs,
-# [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
-# 'EF_e_step1')
-# self.addEFSequence('EF_e_step1',
-# theTrigEFIDInsideOut_Electron + [config.EFConfig.TrigEFTrackHypo_1],
-# 'EF_e_step2')
-# self.addEFSequence('EF_e_step2',
-# [theTrigEgammaRec_eGamma, config.EFConfig.TrigEFEGammaHypo_1],
-# 'EF_e_step3')
-
-# def defineSignatures(self):
-# self.addEFSignature(['EF_e_step1']*self.mult)
-# self.addEFSignature(['EF_e_step2']*self.mult)
-# self.addEFSignature(['EF_e_step3']*self.mult)
-
-# def defineTErenaming(self):
-# self.TErenamingMap = {
-# 'EF_e_step1': mergeRemovingOverlap('EF_', self.sig_id_noMult+'calo'),
-# 'EF_e_step2': mergeRemovingOverlap('EF_', self.sig_id_noMult+'id'),
-# 'EF_e_step3': mergeRemovingOverlap('EF_', self.sig_id_noMult),
-# }
-
-
-
-##########################################################################################
-#
-# Helper class for writing python code, eg HLT to L1 maps
-#
-##########################################################################################
-class ElectronCodeHelper:
- def __init__(self):
-
- global Electrons
-
- iwidth = int(0)
- for echain in Electrons:
- if iwidth < len(echain.l2chain.sig_id):
- iwidth = len(echain.l2chain.sig_id)
-
- for echain in Electrons:
- l2name = '\''+echain.l2chain.sig_id.rstrip()+'\''
- l1name = '\''+echain.l2chain.lower_chain_name.rstrip()+'\''
- lempty = ''
- for istep in range(len(echain.l2chain.sig_id), iwidth):
- lempty += ' '
-
- for echain in Electrons:
- if echain.l2chain.lower_chain_name not in l1map:
- l1map[echain.l2chain.lower_chain_name] = echain.l2chain.inputTEs
-
-
-##########################################################################################
-#
-# Exception class
-#
-##########################################################################################
-class EgammaMapError(Exception):
- def __init__(self, value):
- self.value = value
- def __str__(self):
- return repr(self.value)
-
-
-##########################################################################################
-#
-# Get list of L1 thresholds (L2 input TEs) for L1 item
-#
-##########################################################################################
-# def getEM_InTEFromItemConfig(item):
-
-# log = logging.getLogger( "EgammaSliceFlags" )
-# tpc = TriggerPythonConfig.currentTriggerConfig()
-
-# if item not in tpc.allItems.keys():
-# raise EgammaMapError('L1 item is not among all keys: '+item)
-
-# resItem = tpc.allItems[item]
-# resTEs = resItem.thresholdNames()
-
-# log.info('Found TEs for item: '+item+str(resTEs))
-# return resTEs
-
-
-
-
-###############################
-## not in v4 menu
-###############################
-
-# class L2EFChain_e_NoIDTrkCut_IDT(L2EFChain_e):
-
-# def defineSequences(self, config):
-# ###### L2 ######
-# # Step 1: Calo Fex and Hypo
-# self.addL2Sequence(self.inputTEs,
-# [theT2CaloEgamma_cells_e, config.L2Config.TrigL2CaloHypo_1],
-# 'L2_e_step1')
-
-# #remove IDScan and SiTrakck from IDTrkNoCut chains
-# self.addL2Sequence(['L2_e_step1'],
-# [theTrigL2SiTrackFinder_eGammaA,
-# theTrigL2SiTrackFinder_eGammaB,
-# theTrigL2SiTrackFinder_eGammaC,
-# theTrigL2SiTrackFinder_eGammaBC,
-# theTrigTRTSegFinder_eGamma,
-# ],
-# 'L2_e_step2')
-
-# # Step 3: ID-Calo Fex and Hypo
-# self.addL2Sequence(['L2_e_step2'],
-# [config.L2Config.TrigL2ElectronFex_1, config.L2Config.TrigL2ElectronHypo_1],
-# 'L2_e_step3')
-
-# ###### EF ######
-# # Step 1: Calo Fex
-# self.addEFSequence('L2_e_step3',
-# [theTrigCaloCellMaker_eGamma_cells, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
-# 'EF_e_step1')
-
-# # Step 3: ID Fex and Hypo
-# self.addEFSequence('EF_e_step1', theTrigEFIDInsideOut_Electron, 'EF_e_step2')
-# self.addEFSequence('EF_e_step2', theTrigEFIDOutsideInTRTOnly_Electron, 'EF_e_step3')
-
-# # Step 4: IDMerged Fex
-# try:
-# from TrigFastTrackFinder.TrigFastTrackFinder_Config import TrigFastTrackFinder_Electron
-# theTrigFastTrackFinder_Electron = TrigFastTrackFinder_Electron()
-# except:
-# theTrigFastTrackFinder_Electron = None
-
-
-# trkseq = theTrigEFIDInsideOut_Electron_MergedDP.getSequence()
-# trkseq.append(theTrigFastTrackFinder_Electron)
-# theTrigEFIDInsideOutMerged_Electron = TrigEFIDSequence("Electron","electron","InsideOutMerged")
-# trkseq += theTrigEFIDInsideOutMerged_Electron.getSequence(),
-# self.addEFSequence('EF_e_step3',
-# trkseq,
-# 'EF_e_step4')
-
-# # Step 3: ID-Calo Fex and Hypo
-# self.addEFSequence('EF_e_step4',
-# [theTrigEgammaRec_eGamma, config.EFConfig.TrigEFEGammaHypo_1],
-# 'EF_e_step5')
-
-# def defineSignatures(self):
-# self.addL2Signature(['L2_e_step1'])
-# self.addL2Signature(['L2_e_step2'])
-# self.addL2Signature(['L2_e_step3'])
-# self.addEFSignature(['EF_e_step1'])
-# self.addEFSignature(['EF_e_step2'])
-# self.addEFSignature(['EF_e_step3'])
-# self.addEFSignature(['EF_e_step4'])
-# self.addEFSignature(['EF_e_step5'])
-
-# def defineTErenaming(self):
-# self.TErenamingMap = {
-# 'L2_e_step1': mergeRemovingOverlap('L2_', self.sig_id+'cl'),
-# 'L2_e_step2': mergeRemovingOverlap('L2_', self.sig_id+'id'),
-# 'L2_e_step3': mergeRemovingOverlap('L2_', self.sig_id),
-# 'EF_e_step1': mergeRemovingOverlap('EF_', self.sig_id+'calo'),
-# 'EF_e_step2': mergeRemovingOverlap('EF_', self.sig_id+'id1'),
-# 'EF_e_step3': mergeRemovingOverlap('EF_', self.sig_id+'id2'),
-# 'EF_e_step4': mergeRemovingOverlap('EF_', self.sig_id+'idt'),
-# 'EF_e_step5': mergeRemovingOverlap('EF_', self.sig_id),
-# }
-
-
-# class L2EFChain_e_TRT_Ringer(L2EFChain_e):
-
-# def defineSequences(self, config):
-# self.addL2Sequence(self.inputTEs,
-# [theT2CaloEgamma_Ringer, config.L2Config.TrigL2CaloHypo_1],
-# 'L2_e_step1')
-# self.addL2Sequence(['L2_e_step1'],
-# [theTrigTRTSegFinder_eGamma],
-# 'L2_e_step2')
-# self.addL2Sequence(['L2_e_step2'],
-# [config.L2Config.TrigL2ElectronFex_1, config.L2Config.TrigL2ElectronHypo_1],
-# 'L2_e_step3')
-# self.addEFSequence('L2_e_step3',
-# [theTrigCaloCellMaker_eGamma, theTrigCaloTowerMaker_eGamma, theTrigCaloClusterMaker_slw],
-# 'EF_e_step1')
-# self.addEFSequence('EF_e_step1',
-# theTrigEFIDOutsideInTRTOnly_Electron + [config.EFConfig.TrigEFTrackHypo_1],
-# 'EF_e_step2')
-# self.addEFSequence('EF_e_step2',
-# [theTrigEgammaRec_eGamma, config.EFConfig.TrigEFEGammaHypo_1],
-# 'EF_e_step3')
-
-
diff --git a/Trigger/TriggerCommon/TriggerMenu/python/egamma/PhotonDef.py b/Trigger/TriggerCommon/TriggerMenu/python/egamma/PhotonDef.py
index 97bcb033c5dc583c674d3c32ed96b5d5ef337905..d3aacd655b002ba1e8b1f824f89abca1f3fa0d40 100755
--- a/Trigger/TriggerCommon/TriggerMenu/python/egamma/PhotonDef.py
+++ b/Trigger/TriggerCommon/TriggerMenu/python/egamma/PhotonDef.py
@@ -15,6 +15,7 @@ from TriggerMenu.menu.HltConfig import L2EFChainDef, mergeRemovingOverlap
from TrigHIHypo.UE import theUEMaker, theFSCellMaker
from TrigInDetConf.TrigInDetSequence import TrigInDetSequence
from TrigGenericAlgs.TrigGenericAlgsConf import PESA__DummyCopyAllTEAlgo
+from TrigGenericAlgs.TrigGenericAlgsConf import PESA__DummyUnseededAllTEAlgo as DummyRoI
from TriggerMenu.commonUtils.makeCaloSequences import getFullScanCaloSequences
from TrigTRTHighTHitCounter.TrigTRTHighTHitCounterConf import TrigTRTHTHCounter, TrigTRTHTHhypo
##################
@@ -69,11 +70,10 @@ class L2EFChain_g(L2EFChainDef):
self.use_v7=True
self.doIsolation=False
- if ('ivloose' in self.chainPart['isoInfo'] or
- 'iloose' in self.chainPart['isoInfo'] or
- 'itight' in self.chainPart['isoInfo']):
- self.doIsolation=True
-
+ caloiso = [x for x in self.chainPart['isoInfo'] if 'icalo' in x]
+ if len(caloiso) > 0:
+ self.doIsolation=True
+
log.debug('Sequences %s ', self.ph_sequences)
# gXX_ID type chains:
@@ -296,13 +296,13 @@ class L2EFChain_g(L2EFChainDef):
self.setupFromDict(seq_te_dict)
# Now insert additional steps
- self.EFsequenceList.insert(0,[['L2_g_step2'],[theFSCellMaker], 'EF_g_step1_fs'])
- self.EFsequenceList.insert(1,[['EF_g_step1_fs'],[theUEMaker], 'EF_g_step1_ue'])
- self.EFsignatureList.insert(0, [['EF_g_step1_fs']] )
- self.EFsignatureList.insert(1, [['EF_g_step1_ue']] )
+ self.EFsequenceList.insert(0,[[""],[DummyRoI("MinBiasDummyRoI")], 'L2_dummy_sp'])
+ self.EFsequenceList.insert(1,[['L2_dummy_sp'],[theFSCellMaker], 'EF_AllCells'])
+ self.EFsequenceList.insert(2,[['EF_AllCells'],[theUEMaker], 'EF_UE'])
+ self.EFsignatureList.insert(0, [['L2_dummy_sp']] )
+ self.EFsignatureList.insert(1, [['EF_AllCells']] )
+ self.EFsignatureList.insert(2, [['EF_UE']] )
- self.TErenamingDict['EF_g_step1_fs']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'_fs')
- self.TErenamingDict['EF_g_step1_ue']=mergeRemovingOverlap('EF_', self.chainPartNameNoMult+'_ue')
def setup_gnocut_hiptrt(self):
# list of required key values for sequences
diff --git a/Trigger/TriggerCommon/TriggerMenu/python/egamma/generateElectronChainDefs.py b/Trigger/TriggerCommon/TriggerMenu/python/egamma/generateElectronChainDefs.py
index 8df8c0fb336fe919914a69a5dde75534beb0f0df..f549d156f051c62cb89bd1a2187e9ac31d769c43 100755
--- a/Trigger/TriggerCommon/TriggerMenu/python/egamma/generateElectronChainDefs.py
+++ b/Trigger/TriggerCommon/TriggerMenu/python/egamma/generateElectronChainDefs.py
@@ -9,14 +9,7 @@ from AthenaCommon.Logging import logging
log = logging.getLogger( 'TriggerMenu.egamma.generateElectronChainDefs' )
log.info("Importing %s",__name__)
-import traceback
-
from TriggerMenu.egamma.ElectronDef import L2EFChain_e as L2EFChain_e
-try:
- from TriggerMenu.egamma.ElectronDefIdTest import L2EFChain_e as L2EFChain_e_IdTest
-except:
- log.error('generateElectronChainDefs: Problems when importing ElectronDefIdTest.')
- log.info(traceback.print_exc())
#from TriggerJobOpts.TriggerFlags import TriggerFlags
from TriggerMenu.menu.MenuUtils import splitChainDict, mergeChainDefs, setupTopoStartFrom
@@ -34,10 +27,7 @@ def generateChainDefs(chainDict):
for subChainDict in listOfChainDicts:
electron_seq = EgammaSequence(subChainDict)
log.debug('Egamma Sequence: %s', electron_seq)
- if "IdTest" in subChainDict["chainParts"]["addInfo"]:
- Electron = L2EFChain_e_IdTest(subChainDict)
- else:
- Electron = L2EFChain_e(subChainDict,electron_seq)
+ Electron = L2EFChain_e(subChainDict,electron_seq)
listOfChainDefs += [Electron.generateHLTChainDef()]
if len(listOfChainDefs)>1:
@@ -108,6 +98,16 @@ def _addTopoInfo(theChainDef,chainDict,doAtL2AndEF=True):
theChainDef.addSequence([IDTP],myInputTEsEF,EFChainName+"_monit")
theChainDef.addSignature(theChainDef.signatureList[-1]['signature_counter']+1,[EFChainName+"_monit"])
+ elif "bBeexv2" in chainDict["topo"] or "bBeexM2700" in chainDict["topo"] or "bBeexM6000" in chainDict["topo"] or "bBeexM6000t" in chainDict["topo"] :
+ # this algorithm is set up in generateBPhysicsChainDef
+ from TriggerMenu.bphysics.generateBPhysicsChainDefs import bBeexTopos
+ inputTEsL2 = theChainDef.signatureList[maxL2SignatureIndex]['listOfTriggerElements']
+ theChainDef = bBeexTopos(theChainDef, chainDict, inputTEsL2, inputTEsEF)
+
+
+ else:
+ pass
+
return theChainDef
diff --git a/Trigger/TriggerCommon/TriggerMenu/python/egamma/generatePhotonChainDefs.py b/Trigger/TriggerCommon/TriggerMenu/python/egamma/generatePhotonChainDefs.py
index 676fe8bdbdb52b8cf531d7c86bccf19180032870..8cfea7bda432142dae70ea6ff5105f933956e8e3 100755
--- a/Trigger/TriggerCommon/TriggerMenu/python/egamma/generatePhotonChainDefs.py
+++ b/Trigger/TriggerCommon/TriggerMenu/python/egamma/generatePhotonChainDefs.py
@@ -46,47 +46,50 @@ def _addTopoInfo(theChainDef,chainDict,doAtL2AndEF=True):
if signature['listOfTriggerElements'][0][0:2] == "L2":
maxL2SignatureIndex = max(maxL2SignatureIndex,signatureIndex)
- inputTEsL2 = theChainDef.signatureList[maxL2SignatureIndex]['listOfTriggerElements']
-
inputTEsEF = theChainDef.signatureList[-1]['listOfTriggerElements']
- L2ChainName = "L2_" + chainDict['chainName']
EFChainName = "EF_" + chainDict['chainName']
- if "Jpsiee" in chainDict["topo"]:
+ if 'dPhi15' in chainDict['topo']:
+ EFChainName = 'EF_2g_OvlRem_dPhi15'
+ from TrigGenericAlgs.TrigGenericAlgsConfig import OverlapRemovalConfig
+ OverlapRemoval_algo = OverlapRemovalConfig('OvlRem', MinPhiDist = 1.5, MinEtaDist = 0)
+
+ theChainDef.addSequence([OverlapRemoval_algo],inputTEsEF,EFChainName)
+ theChainDef.addSignature(theChainDef.signatureList[-1]['signature_counter']+1, [EFChainName])
- from TrigEgammaHypo.TrigEFDielectronMassHypoConfig import TrigEFDielectronMassFex_Jpsi, TrigEFDielectronMassHypo_Jpsi
- from TrigEgammaHypo.TrigL2DielectronMassHypoConfig import TrigL2DielectronMassFex_Jpsiee, TrigL2DielectronMassHypo_Jpsiee
+ elif "Jpsiee" in chainDict["topo"]:
- L2Fex = TrigL2DielectronMassFex_Jpsiee()
- L2Hypo = TrigL2DielectronMassHypo_Jpsiee()
+ from TrigEgammaHypo.TrigEFDielectronMassHypoConfig import TrigEFDielectronMassFex_Jpsi, TrigEFDielectronMassHypo_Jpsi
EFFex = TrigEFDielectronMassFex_Jpsi()
EFHypo = TrigEFDielectronMassHypo_Jpsi()
- theChainDef.addSequence([L2Fex, L2Hypo],inputTEsL2,L2ChainName)
- theChainDef.addSignatureL2([L2ChainName])
-
theChainDef.addSequence([EFFex, EFHypo],inputTEsEF,EFChainName)
theChainDef.addSignature(theChainDef.signatureList[-1]['signature_counter']+1, [EFChainName])
- if "Zeg" in chainDict["topo"]:
+ elif "Zeg" in chainDict["topo"]:
from TrigEgammaHypo.TrigEFDielectronMassHypoConfig import TrigEFDielectronMassFex_Zeg, TrigEFDielectronMassHypo_Zeg
- from TrigEgammaHypo.TrigL2DielectronMassHypoConfig import TrigL2DielectronMassFex_Zeg, TrigL2DielectronMassHypo_Zeg
-
- L2Fex = TrigL2DielectronMassFex_Zeg()
- L2Hypo = TrigL2DielectronMassHypo_Zeg()
EFFex = TrigEFDielectronMassFex_Zeg()
EFHypo = TrigEFDielectronMassHypo_Zeg()
- theChainDef.addSequence([L2Fex, L2Hypo],inputTEsL2,L2ChainName)
- theChainDef.addSignatureL2([L2ChainName])
-
theChainDef.addSequence([EFFex, EFHypo],inputTEsEF,EFChainName)
theChainDef.addSignature(theChainDef.signatureList[-1]['signature_counter']+1, [EFChainName])
+ #elif "Heg" in chainDict["topo"]:
+
+ # from TrigEgammaHypo.TrigEFDielectronMassHypoConfig import TrigEFDielectronMassFex_Heg, TrigEFDielectronMassHypo_Heg
+
+ # EFFex = TrigEFDielectronMassFex_Heg()
+ # EFHypo = TrigEFDielectronMassHypo_Heg()
+
+ # theChainDef.addSequence([EFFex, EFHypo],inputTEsEF,EFChainName)
+ # theChainDef.addSignature(theChainDef.signatureList[-1]['signature_counter']+1, [EFChainName])
+
+ else:
+ pass
return theChainDef