Collaboration diagram for TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig:

Public Member Functions
def	__init__ (self, flags, name, triggerList=[], OutputLevel=0, ElectronTriggerList=single_electron_triggers, PhotonTriggerList=single_photon_triggers)

def	core (self)

def	update (self)

def	configure (self)

def	setupChain (self, trigger)

def	setupL1Calo (self, name, info)

Public Attributes
	flags

	name

	TriggerList

	OutputLevel

	ElectronTriggerList

	PhotonTriggerList

	ElectronCBConfigFilePath

	ElectronDNNConfigFilePath

	ElectronLHConfigFilePath

	FastCaloConfigFilePath

	PhotonCBConfigFilePath

Private Attributes
	__chains

	__configured_triggers

	__emulator

Detailed Description

Definition at line 11 of file TrigEgammaEmulationToolConfigMT.py.

Constructor & Destructor Documentation

◆ init()

def TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.__init__	(	self,
		flags,
		name,
		triggerList = `[]`,
		OutputLevel = `0`,
		ElectronTriggerList = `single_electron_triggers`,
		PhotonTriggerList = `single_photon_triggers`
	)

Definition at line 16 of file TrigEgammaEmulationToolConfigMT.py.

     def __init__(self, flags, name, triggerList         = [],
                              OutputLevel         = 0, 
                              ElectronTriggerList = single_electron_triggers, 
                              PhotonTriggerList   = single_photon_triggers):
  
         self.flags = flags
         self.name = name
         self.__chains = []
         self.TriggerList = triggerList
         self.OutputLevel = OutputLevel
         self.ElectronTriggerList = ElectronTriggerList
         self.PhotonTriggerList = PhotonTriggerList
  
         # force cofnig file path
         self.ElectronCBConfigFilePath = None
         self.ElectronDNNConfigFilePath = None
         self.ElectronLHConfigFilePath = None
         self.FastCaloConfigFilePath = None
         self.PhotonCBConfigFilePath = None
  
         self.__configured_triggers = []
  
  

Member Function Documentation

◆ configure()

def TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.configure ( self )

Definition at line 54 of file TrigEgammaEmulationToolConfigMT.py.

     def configure(self):
  
         from TrigEgammaHypo.TrigEgammaFastCaloHypoTool          import createTrigEgammaFastCaloSelectors
         from TrigEgammaHypo.TrigEgammaPrecisionPhotonHypoTool   import createTrigEgammaPrecisionPhotonSelectors
         from TrigEgammaHypo.TrigEgammaPrecisionElectronHypoTool import TrigEgammaPrecisionElectronCBSelectorCfg
         from TrigEgammaHypo.TrigEgammaPrecisionElectronHypoTool import TrigEgammaPrecisionElectronLHSelectorCfg
         from TrigEgammaHypo.TrigEgammaPrecisionElectronHypoTool import TrigEgammaPrecisionElectronDNNSelectorCfg
  
  
         # create the emulator tool
         self.__emulator = CompFactory.Trig.TrigEgammaEmulationToolMT( self.name, 
                                                                ElectronTriggerList = self.ElectronTriggerList,
                                                                PhotonTriggerList = self.PhotonTriggerList )
         
         # NOTE: will be adapt next
         self.__emulator.RingerTools              = createTrigEgammaFastCaloSelectors(ConfigFilePath = self.FastCaloConfigFilePath)
         self.__emulator.ElectronLHSelectorTools  = TrigEgammaPrecisionElectronLHSelectorCfg(ConfigFilePath = self.ElectronLHConfigFilePath).getPublicTools()
         self.__emulator.ElectronCBSelectorTools  = TrigEgammaPrecisionElectronCBSelectorCfg(ConfigFilePath = self.ElectronCBConfigFilePath).getPublicTools()
         self.__emulator.ElectronDNNSelectorTools = TrigEgammaPrecisionElectronDNNSelectorCfg(ConfigFilePath = self.ElectronDNNConfigFilePath).getPublicTools()
         self.__emulator.PhotonCBSelectorTools    = createTrigEgammaPrecisionPhotonSelectors(ConfigFilePath = self.PhotonCBConfigFilePath)
         for tool in self.__emulator.ElectronDNNSelectorTools:
             tool.skipAmbiguityCut =True  
         for tool in self.__emulator.ElectronLHSelectorTools:
             tool.skipDeltaPoverP = True
     

◆ core()

def TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.core ( self )

Definition at line 39 of file TrigEgammaEmulationToolConfigMT.py.

     def core(self):
         self.update()
         return self.__emulator
  
  

◆ setupChain()

def TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.setupChain	(	self,
		trigger
	)

Definition at line 82 of file TrigEgammaEmulationToolConfigMT.py.

     def setupChain( self, trigger ):
  
         import cppyy
         cppyy.load_library('libElectronPhotonSelectorToolsDict')
  
         from TriggerMenuMT.HLT.Config.Utility.DictFromChainName import dictFromChainName
         d = dictFromChainName(self.flags, trigger)
  
         signature = d['signatures'][0]
  
         from TrigEgammaHypo.TrigEgammaFastCaloHypoTool          import TrigEgammaFastCaloHypoToolFromDict
         from TrigEgammaHypo.TrigEgammaFastElectronHypoTool      import TrigEgammaFastElectronHypoToolFromDict
         from TrigEgammaHypo.TrigEgammaFastPhotonHypoTool        import TrigEgammaFastPhotonHypoToolFromDict
         from TrigEgammaHypo.TrigEgammaPrecisionCaloHypoTool     import TrigEgammaPrecisionCaloHypoToolFromDict
         from TrigEgammaHypo.TrigEgammaPrecisionElectronHypoTool import TrigEgammaPrecisionElectronHypoToolFromDict
         from TrigEgammaHypo.TrigEgammaPrecisionPhotonHypoTool   import TrigEgammaPrecisionPhotonHypoToolFromDict
         from TrigEgammaHypo.TrigEgammaPrecisionTrackingHypoTool import TrigEgammaPrecisionTrackingHypoToolFromDict
  
         # Configure L1Calo 
         L1CaloTool = self.setupL1Calo(trigger + "_Step0" , d)
         sequence = list()
         # Configure HLT
         FastCaloTool = TrigEgammaFastCaloHypoToolFromDict(d, tool = CompFactory.Trig.TrigEgammaEmulationFastCaloHypoTool(trigger+'_Step1') )
         PrecisionCaloTool       = TrigEgammaPrecisionCaloHypoToolFromDict(d, tool = CompFactory.Trig.TrigEgammaEmulationPrecisionCaloHypoTool(trigger+'_Step3'))
         if signature == 'Electron':
             isEtCut = bool(d['chainParts'][0]['addInfo'])
             isIdperf = bool(d['chainParts'][0]['idperfInfo'])
             FastTool                = TrigEgammaFastElectronHypoToolFromDict(d, tool = CompFactory.Trig.TrigEgammaEmulationFastElectronHypoTool(trigger+'_Step2'))            
             if isEtCut:     
                 sequence = [FastCaloTool, FastTool, PrecisionCaloTool]
             elif isIdperf:  
                 PrecisionTrackingTool   = TrigEgammaPrecisionTrackingHypoToolFromDict(d, tool = CompFactory.Trig.TrigEgammaEmulationPrecisionTrackingHypoTool(trigger+'_Step4'))
                 sequence = [FastCaloTool, FastTool, PrecisionCaloTool, PrecisionTrackingTool]
             else:           
                 PrecisionTrackingTool   = TrigEgammaPrecisionTrackingHypoToolFromDict(d, tool = CompFactory.Trig.TrigEgammaEmulationPrecisionTrackingHypoTool(trigger+'_Step4'))
                 PrecisionTool           = TrigEgammaPrecisionElectronHypoToolFromDict(d, tool = CompFactory.Trig.TrigEgammaEmulationPrecisionElectronHypoTool(trigger+'_Step5'))
                 sequence = [FastCaloTool, FastTool, PrecisionCaloTool, PrecisionTrackingTool, PrecisionTool]
         elif signature == 'Photon':
             isEtCut = bool(d['chainParts'][0]['addInfo'])
             FastTool                = TrigEgammaFastPhotonHypoToolFromDict(d, tool = CompFactory.Trig.TrigEgammaEmulationFastPhotonHypoTool(trigger+'_Step2'))
             if isEtCut:
                 sequence = [FastCaloTool, FastTool, PrecisionCaloTool]
             else:
                 PrecisionTool           = TrigEgammaPrecisionPhotonHypoToolFromDict(d, tool = CompFactory.Trig.TrigEgammaEmulationPrecisionPhotonHypoTool(trigger+'_Step5'))
                 sequence = [FastCaloTool, FastTool, PrecisionCaloTool, PrecisionTool]
  
         chain = CompFactory.Trig.TrigEgammaEmulationChain(
                                     name                    = trigger,
                                     L1Seed                  = L1CaloTool,
                                     # Steps                   = [FastCaloTool, FastTool, PrecisionCaloTool, PrecisionTrackingTool, PrecisionTool],
                                     Steps                   = sequence,
                                     Chain                   = trigger,
                                     Signature               = signature.lower(),
                                     OutputLevel             = self.OutputLevel
         )
  
         return chain
  
  
  

◆ setupL1Calo()

def TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.setupL1Calo	(	self,
		name,
		info
	)

Definition at line 145 of file TrigEgammaEmulationToolConfigMT.py.

     def setupL1Calo( self, name , info):
  
         from AthenaConfiguration.ComponentFactory import CompFactory
         import re
  
         #chainName = info['chainName']
         L1Item = info['chainParts'][0]['L1threshold']
         L1thr = float( re.findall(r'\d+', L1Item)[0] )
         wp = 0 # default
  
         #                        [Default, Tight , Medium, Loose ]
         HadCoreCutMin          = [ 1.0   ,  1.0  ,  1.0  ,  1.0  ]
         HadCoreCutOff          = [-0.2   , -0,2  , -0.2  , -0.2  ]
         HadCoreSlope           = [ 1/23. ,  1/23.,  1/23.,  1/23.]
         EmIsolCutMin           = [ 2.0   ,  1.0  ,  1.0  ,  1.5  ]
         EmIsolCutOff           = [-1.8   , -2.6  , -2.0  , -1.8  ]
         EmIsolSlope            = [ 1/8.  ,  1/8. ,  1/8. ,  1/8. ]
  
         # Configure L1
         L1CaloTool = CompFactory.Trig.TrigEgammaEmulationL1CaloHypoTool(
                                     name                   = name,
                                     L1Item                 = L1Item,
                                     L1Thr                  = L1thr, 
                                     HadCoreCutMin          = HadCoreCutMin[wp],
                                     HadCoreCutOff          = HadCoreCutOff[wp],
                                     HadCoreSlope           = HadCoreSlope[wp],
                                     EmIsolCutMin           = EmIsolCutMin[wp],
                                     EmIsolCutOff           = EmIsolCutOff[wp],
                                     EmIsolSlope            = EmIsolSlope[wp],
                                     IsolCutMax             = 50,
                                     OutputLevel            = self.OutputLevel)
  
         return L1CaloTool
  
  
  
  
  
  
  
  

◆ update()

def TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.update ( self )

Definition at line 44 of file TrigEgammaEmulationToolConfigMT.py.

     def update(self):
         for trigger in self.TriggerList:
             if trigger not in self.__configured_triggers:
                 hypo = self.setupChain(trigger)
                 self.__emulator.HypoTools += [hypo]
                 self.__configured_triggers += trigger
  