Collaboration diagram for TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig:

Public Member Functions
	__init__ (self, flags, name, triggerList=[], OutputLevel=0, ElectronTriggerList=single_electron_triggers, PhotonTriggerList=single_photon_triggers)
	core (self)
	update (self)
	configure (self)
	setupChain (self, trigger)
	setupL1Calo (self, name, info)

Public Attributes
	flags = flags
	name = name
	TriggerList = triggerList
	OutputLevel = OutputLevel
	ElectronTriggerList = ElectronTriggerList
	PhotonTriggerList = PhotonTriggerList
	ElectronCBConfigFilePath = None
	ElectronDNNConfigFilePath = None
	ElectronLHConfigFilePath = None
	FastCaloConfigFilePath = None
	PhotonCBConfigFilePath = None

Private Attributes
list	__chains = []
list	__configured_triggers = []
	__emulator

Detailed Description

Definition at line 11 of file TrigEgammaEmulationToolConfigMT.py.

Constructor & Destructor Documentation

◆ init()

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.

                             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()

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()

TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.core ( self )

Definition at line 39 of file TrigEgammaEmulationToolConfigMT.py.

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

◆ setupChain()

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()

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()

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
 

Member Data Documentation

◆ __chains

list TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.__chains = []

private

Definition at line 23 of file TrigEgammaEmulationToolConfigMT.py.

◆ __configured_triggers

list TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.__configured_triggers = []

private

Definition at line 36 of file TrigEgammaEmulationToolConfigMT.py.

◆ __emulator

TrigEgammaEmulationToolConfigMT.TrigEgammaEmulationToolConfig.__emulator

private

Initial value:

=  CompFactory.Trig.TrigEgammaEmulationToolMT( self.name, 
                                                               ElectronTriggerList = self.ElectronTriggerList,
                                                               PhotonTriggerList = self.PhotonTriggerList )

Definition at line 64 of file TrigEgammaEmulationToolConfigMT.py.