TrigEgammaKeys.py

Go to the documentation of this file.

#  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 
__author__ = "Fernando Monticelli, Debottam Bakshi Gupta, Joao Victor Pinto"
__doc__    = "ConfigSettings"
__all__    = [ "getTrigEgammaKeys" ]
 
#----------------------------------------------------------------
# Configuration of Electron and Photon chains
#----------------------------------------------------------------
 
 
from TrigEDMConfig.TriggerEDM import recordable
from AthenaConfiguration.AthConfigFlags import AthConfigFlags
 
class TrigEgammaKeysBase(object):
 
      """Base clas to configure TrigEgamma Container names. Containers will be record, collections not"""
      def __init__(self, flags: AthConfigFlags, ion=False):
 
 
        """Static class to collect all string manipulation in fast electron sequences """
        self.fastTrackingRoIContainer                   = recordable("HLT_Roi_FastElectron")
        self.fastElectronContainer                      = recordable("HLT_FastElectrons")
 
        """Static class to collect all string manipulation in fast photon sequences """
        self.fastPhotonRoIContainer                     = recordable("HLT_Roi_FastPhoton")
        self.fastPhotonContainer                        = recordable("HLT_FastPhotons")
 
        """Static class to collect all string manipulation in precision calo sequences """
        self.precisionCaloTopoCollection                = 'HLT_egammaTopoCluster'
        self.precisionCaloEgammaRecCollection           = 'HLT_precisionCaloEgammaRecCollection'
        self.precisionElectronCaloClusterContainer      = recordable("HLT_CaloEMClusters_Electron") if not ion else recordable("HLT_HICaloEMClusters") 
        self.precisionPhotonCaloClusterContainer        = recordable("HLT_CaloEMClusters_Photon") if not ion else recordable("HLT_HICaloEMClusters")
        self.precisionTopoClusterContainer              = recordable("HLT_TopoCaloClustersRoI") if not ion else recordable("HLT_TopoCaloClustersHIRoI") 
        self.precisionEgammaRecCollection               = 'HLT_egammaRecCollection'
        self.precisionPhotonEMClusterContainer          = recordable('HLT_TrigEMClusters_Photons')
        self.precisionElectronEMClusterContainer        = recordable('HLT_TrigEMClusters_Electrons')
 
        """Static class to collect all string manipulation in precision photon sequences """
        self.precisionPhotonSuperClusterRecCollection   = 'HLT_PhotonSuperRecCollection'
        self.precisionPhotonSuperClusterCollection      = 'HLT_PhotonSuperClusters'
        self.precisionPhotonContainer                   = recordable('HLT_egamma_Photons')
        self.precisionPhotonIsoContainer                = recordable('HLT_egamma_Iso_Photons')
 
        """Static class to collect all string manipulation in precision electron sequences """
        self.precisionElectronSuperClusterRecCollection    = 'HLT_ElectronSuperRecCollection'
        self.precisionElectronSuperClusterCollection    = 'HLT_ElectronSuperClusters'
        self.precisionElectronContainer                 = recordable('HLT_egamma_Electrons')
 
        """Static class to collect all string manipulation in precision egamma sequences """
        self.precisionEgammaSuperClusterRecCollection    = 'HLT_EgammaSuperRecCollection'
 
        #
        # Special sequences
        #
        self.TrigTRTHTCountsContainer                   = recordable("HLT_TrigTRTHTCounts")
        self.egEventShape                               = recordable('HLT_HIEventShapeEG')
        self._flags = flags       
 
 
 
      @property
      def precisionTrackingContainer(self):
          return self._flags.Trigger.InDetTracking.electron.tracks_IDTrig
 
      @property
      def fastTrackParticleContainer(self):
          return self._flags.Trigger.InDetTracking.electron.tracks_FTF
 
 
 
class TrigEgammaKeys_LRT(TrigEgammaKeysBase):
    # This class contians modified base configuration class for LRT electron trigger chains
    def __init__(self, flags: AthConfigFlags, ion):
        TrigEgammaKeysBase.__init__(self, flags, ion)
        
        self.fastTrackingRoIContainer               = recordable("HLT_Roi_FastElectron_LRT")
        self.fastElectronContainer                  = recordable('HLT_FastElectrons_LRT')
        self.precisionElectronEMClusterContainer    = recordable('HLT_TrigEMClusters_Electrons_LRT')
        self.precisionElectronCaloClusterContainer  = recordable("HLT_CaloEMClusters_LRT")
        self.precisionElectronContainer             = recordable('HLT_egamma_Electrons_LRT')
        self.precisionTopoClusterContainer          = recordable("HLT_TopoCaloClustersRoI_LRT")
 
    @property
    def precisionTrackingContainer(self):
          return self._flags.Trigger.InDetTracking.electronLRT.tracks_IDTrig
 
    @property
    def fastTrackParticleContainer(self):
          return self._flags.Trigger.InDetTracking.electronLRT.tracks_FTF
 
 
class TrigEgammaKeys_GSF(TrigEgammaKeysBase):
    # This class contians modified base configuration class for GSF electron trigger chains
    def __init__(self, flags: AthConfigFlags, ion):
        TrigEgammaKeysBase.__init__(self, flags, ion)
        self.precisionElectronEMClusterContainer    = recordable('HLT_TrigEMClusters_Electrons_GSF')
        
        # from HLT_IDTrack_Electron to HLT_IDTrack_Electron by refit alg
        self.precisionElectronTrkCollectionGSF          = 'HLT_IDTrkTrack_Electron_GSF'
        self.precisionElectronTrackParticleContainerGSF = recordable('HLT_IDTrack_Electron_GSF')
        self.precisionElectronContainer                 = recordable('HLT_egamma_Electrons_GSF')
    @property
    def precisionTrackingContainer(self):
          return self._flags.Trigger.InDetTracking.electron.tracks_IDTrig
 
    @property
    def fastTrackParticleContainer(self):
          return self._flags.Trigger.InDetTracking.electron.tracks_FTF
 
 
class TrigEgammaKeys_LRTGSF(TrigEgammaKeysBase):
    # This class contians modified base configuration class for LRT_GSF electron trigger chains
    def __init__(self, flags: AthConfigFlags, ion):
        TrigEgammaKeysBase.__init__(self, flags, ion)
        self.precisionElectronEMClusterContainer    = recordable('HLT_TrigEMClusters_Electrons_LRTGSF')
        
        # from HLT_IDTrack_Electron to HLT_IDTrack_Electron by refit alg
        self.precisionElectronTrkCollectionGSF          = 'HLT_IDTrkTrack_Electron_LRTGSF'
        self.precisionElectronTrackParticleContainerGSF = recordable('HLT_IDTrack_Electron_LRTGSF')
        self.precisionElectronCaloClusterContainer      = recordable("HLT_CaloEMClusters_LRT")
        self.precisionElectronContainer                 = recordable('HLT_egamma_Electrons_LRTGSF')
 
    @property
    def precisionTrackingContainer(self):
          return self._flags.Trigger.InDetTracking.electronLRT.tracks_IDTrig
    
    @property
    def fastTrackParticleContainer(self):
          return self._flags.Trigger.InDetTracking.electronLRT.tracks_FTF
 
#
# Get keys from variant name
#
from AthenaConfiguration.AccumulatorCache import AccumulatorCache
 
@AccumulatorCache
def getTrigEgammaKeys(flags: AthConfigFlags, name='', ion=False):
 
    _d = {
        # Dictionary that maps a string to a configuration setting for electron and photon chains
        ''         : TrigEgammaKeysBase(flags, ion),
        '_noGSF'   : TrigEgammaKeysBase(flags, ion),
        '_LRT'     : TrigEgammaKeys_LRT(flags, ion),
        '_GSF'     : TrigEgammaKeys_GSF(flags, ion),
        '_LRTGSF'  : TrigEgammaKeys_LRTGSF(flags, ion),
        }
 
    if name in _d.keys():
        return _d[name]
    else:
        raise Exception('getTrigEgammaKeys() called with non valid name : ' + name + ' valid names are:' + str(_d.keys()) )