def addGroup(self, group): from Gaugi import ToolSvc emulator = ToolSvc.retrieve("Emulator") if not emulator.isValid(group.chain().name()): emulator += group.chain() self.__groups.append(group)
def configure(l1item): # Get the emulator tool from Gaugi import ToolSvc emulator = ToolSvc.retrieve("Emulator") name = 'Hypo__' + l1item # Check if this hypo is in cache if not emulator.isValid(name): # We need to create the hypo tool # L1 configuration parameters hypo = TrigEgammaL1CaloHypoTool( name, WPNames=['Tight', 'Medium', 'Loose' ], # must be: ["T","M","L"] (Tight,Medium and Loose) HadCoreCutMin=[ 1.0, 1.0, 1.0, 1.0 ], # must be a list with for values: (default,tight,medium and loose) 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.], IsolCutMax=50, L1Item=l1item) emulator += hypo return name
def attach( hypos ): from Gaugi import ToolSvc emulator = ToolSvc.retrieve( "Emulator" ) names = [] for hypo in hypos: names.append( hypo.name() ) if not emulator.isValid( hypo.name() ): emulator+=hypo return names
def accept(self, key): # is in cache? if key in self.decorations(): # decision in cache return self.getDecor(key) # get the accept decision from the TDT metadata elif (self._dataframe is DataframeEnum.Electron_v1 or DataframeEnum.Photon_v1) and key.startswith('TDT__'): # TDT__HLT__e28_lhtight_nod0_ivarloose # TDT__EFCalo__e28_lhtight_nod0_ivarloose tdt = self.getContext().getHandler("HLT__TDT") trigInfo = key.split('__') tdt.core(DecisionCore.TriggerDecisionTool) # athena core # TDT__AcceptType__trigItem passed = tdt.ancestorPassed('HLT_' + trigInfo[-1], AcceptType.fromstring(trigInfo[1])) accept = Accept(key) accept.setCutResult('pass', passed) self.setDecor(key, accept) return accept # get the accept decision from the Emulation metadata elif (self._dataframe is DataframeEnum.Electron_v1 or DataframeEnum.Photon_v1) and key.startswith('EMU__'): # EMU__HLT__e28_lhtight_nod0_ivarloose tdt = self.getContext().getHandler("HLT__TDT") trigInfo = key.split('__') tdt.core(DecisionCore.TrigEgammaEmulationTool ) # athena emulation e/g core # EMU__AcceptType__trigItem passed = tdt.ancestorPassed('HLT_' + trigInfo[-1], AcceptType.fromstring(trigInfo[1])) accept = Accept(key) accept.setCutResult('pass', passed) self.setDecor(key, accept) return accept # This name is not in metadata and not in cache, let's access the emulation svc and run it! else: emulator = ToolSvc.retrieve("Emulator") if emulator.isValid(key): accept = emulator.accept(self.getContext(), key) self.setDecor(key, accept) return accept else: MSG_FATAL(self, "It's is not possble to interpreter the key: %s.", key)
def configure( trigger ): from TrigEgammaEmulationTool import TriggerInfo info = TriggerInfo( trigger ) etthr = info.etthr() from Gaugi import ToolSvc emulator = ToolSvc.retrieve("Emulator") pidname = info.pidname() name = 'Hypo__HLT__' + info.signature()[0]+str(int(etthr)) + '_' + info.pidname() if not emulator.isValid(name): hypo = TrigEgammaElectronHypoTool(name, Branch = 'trig_EF_el_'+info.pidname() ) emulator+=hypo return name
def configure( trigger ): from TrigEgammaEmulationTool import TriggerInfo info = TriggerInfo( trigger ) etthr = info.etthr() from Gaugi import ToolSvc emulator = ToolSvc.retrieve("Emulator") name = 'Hypo__L2Photon__' + info.signature()[0]+str(int(etthr)) + '_' + info.pidname() if not emulator.isValid(name): hypo = TrigEgammaL2PhotonHypoTool(name, EtCut = (etthr - 3)*GeV) emulator+=hypo return name
def configure( trigger ): from TrigEgammaEmulationTool import TriggerInfo info = TriggerInfo( trigger ) etthr = info.etthr() from Gaugi import ToolSvc emulator = ToolSvc.retrieve("Emulator") name = 'Hypo__HLT__' + info.signature()[0]+str(int(etthr)) + '_' + info.isolationType() # Taken from: https://gitlab.cern.ch/atlas/athena/-/blob/master/Trigger/TrigHypothesis/TrigEgammaHypo/python/TrigEFElectronHypoConfig.py isolation_dict = { 'ivarloose' : [-1, -1, -1,0.100,-1,-1], 'ivarmedium' : [-1, -1, -1,0.065,-1,-1], 'ivartight' : [-1, -1, -1,0.05,-1,-1], 'iloose' : [0.100, -1, -1,-1,-1,-1], } caloisolation_dict = { 'icaloloose' : [-1, -1, -1,0.2,-1,-1], 'icalomedium' : [-1, -1, -1,0.15,-1,-1], 'icalotight' : [-1, -1, -1,0.1,-1,-1], } pidname = info.isolationType() relEtConeCuts = caloisolation_dict[pidname] if 'icalo' in pidname else [-1, -1, -1,-1, -1, -1] relPtConeCuts = isolation_dict[pidname] if not 'icalo' in pidname else [-1, -1, -1,-1, -1, -1] if not emulator.isValid(name): hypo = TrigEgammaElectronIsolationHypoTool(name, UseClusETforCaloIso = True, UseClusETforTrackIso = True, PtConeCut = [-1, -1, -1,-1,-1,-1], EtConeCut = [-1, -1, -1,-1, -1, -1], RelPtConeCut = relPtConeCuts, RelEtConeCut = relEtConeCuts, ) emulator+=hypo return name
def configure(trigger): from TrigEgammaEmulationTool import TriggerInfo info = TriggerInfo(trigger) etthr = info.etthr() from Gaugi import ToolSvc emulator = ToolSvc.retrieve("Emulator") pidname = info.pidname() name = 'Hypo__L2Calo__' + info.signature()[0] + str( int(etthr)) + '_' + info.pidname() if not emulator.isValid(name): def same(value): return [value] * 9 if info.signature() == 'electron': from .TrigEgammaL2CaloHypoCuts import L2CaloCutMaps cuts = L2CaloCutMaps(etthr) elif info.signature() == 'photon': from .TrigEgammaL2CaloHypoCuts import L2CaloPhotonCutMaps cuts = L2CaloPhotonCutMaps(etthr) hypo = TrigEgammaL2CaloHypoTool( name, dETACLUSTERthr=0.1, dPHICLUSTERthr=0.1, EtaBins=[0.0, 0.6, 0.8, 1.15, 1.37, 1.52, 1.81, 2.01, 2.37, 2.47], F1thr=same(0.005), ETthr=same(0), ET2thr=same(90.0 * GeV), HADET2thr=same(999.0), WETA2thr=same(99999.), WSTOTthr=same(99999.), F3thr=same(99999.), HADETthr=cuts.MapsHADETthr[pidname], CARCOREthr=cuts.MapsCARCOREthr[pidname], CAERATIOthr=cuts.MapsCAERATIOthr[pidname], ) emulator += hypo return name
def configure(trigger): from TrigEgammaEmulationTool import TriggerInfo info = TriggerInfo(trigger) etthr = info.etthr() from Gaugi import ToolSvc emulator = ToolSvc.retrieve("Emulator") name = 'Hypo__L2Electron__' + info.signature()[0] + str( int(etthr)) + '_' + info.pidname() if not emulator.isValid(name): hypo = TrigEgammaL2ElectronHypoTool(name, EtCut=(etthr - 3) * GeV, TrackPt=1 * GeV, CaloTrackdETA=0.2, CaloTrackdPHI=0.3, CaloTrackdEoverPLow=0, CaloTrackdEoverPHigh=999, TRTRatio=-999) if etthr < 15: hypo.TrackPt = 1 * GeV elif etthr >= 15 and etthr < 20: hypo.TrackPt = 2 * GeV elif etthr >= 20 and etthr < 50: hypo.TrackPt = 3 * GeV else: hypo.TrackPt = 5 * GeV hypo.CaloTrackdETA = 999 hypo.CaloTrackdPHI = 999 emulator += hypo return name
def initialize(self): if not ToolSvc.retrieve("Emulator"): MSG_FATAL(self, "The emulator tool is not in the ToolSvc") return StatusCode.SUCCESS
def initialize(self): self.__signature = self.__trigInfo.signature() # Configure the L2Calo hypo step from TrigEgammaEmulationTool.TrigEgammaL1CaloHypoTool import configure self.__l1caloItem = configure(self.__l1item) if self.__trigInfo.signature() == 'electron': # Configure L2Calo step if self.__trigInfo.ringer(): if self.__trigInfo.etthr() > 15: #GeV from TrigEgammaEmulationTool import installElectronRingerZeeFromVersion as configure else: from TrigEgammaEmulationTool import installElectronRingerJpsieeFromVersion as configure version = self.__trigInfo.ringerVersion() names = configure(version) # define like tight, medium, loose and vloose self.__l2caloItem = names[self.__trigInfo.pidnameIdx()] version = self.__trigInfo.ringerVersion("fast_el") if version is not None: names = configure(version, step="fast_el") self.__l2Item = names[self.__trigInfo.pidnameIdx()] else: from TrigEgammaEmulationTool.TrigEgammaL2ElectronHypoTool import configure self.__l2Item = configure(self.__trigger) else: # Configure the L2Calo hypo step from TrigEgammaEmulationTool.TrigEgammaL2CaloHypoTool import configure self.__l2caloItem = configure(self.__trigger) # Configure the L2 hypo step from TrigEgammaEmulationTool.TrigEgammaL2ElectronHypoTool import configure self.__l2Item = configure(self.__trigger) # Configure the HLT hypo step from TrigEgammaEmulationTool.TrigEgammaElectronHypoTool import configure self.__hltItem = configure(self.__trigger) if self.__trigInfo.isolated(): self.__applyIsolation = True from TrigEgammaEmulationTool.TrigEgammaElectronIsolationHypoTool import configure self.__hltIsoItem = configure(self.__trigger) else: self.__applyIsolation = False elif self.__trigInfo.signature() == 'photon': # Configure L2Calo step if self.__trigInfo.ringer(): from TrigEgammaEmulationTool import installPhotonRingerZradFromVersion as configure version = self.__trigInfo.ringerVersion() names = configure(version) # define like tight, medium, loose and vloose self.__l2caloItem = names[self.__trigInfo.pidnameIdx()] else: # Configure the L2Calo hypo step from TrigEgammaEmulationTool.TrigEgammaL2CaloHypoTool import configure self.__l2caloItem = configure(self.__trigger) # Configure the EFCalo hypo step from TrigEgammaEmulationTool.TrigEgammaL2PhotonHypoTool import configure self.__l2Item = configure(self.__trigger) # Configure the HLT hypo step from TrigEgammaEmulationTool.TrigEgammaPhotonHypoTool import configure self.__hltItem = configure(self.__trigger) if self.__trigInfo.isolated(): self.__applyIsolation = True from TrigEgammaEmulationTool.TrigEgammaPhotonIsolationHypoTool import configure self.__hltIsoItem = configure(self.__trigger) else: self.__applyIsolation = False else: MSG_FATAL(self, "Signature not found") # configure et cuts self.__l2caloEtCut = (self.__trigInfo.etthr() - 3) * GeV self.__efcaloEtCut = (self.__trigInfo.etthr()) * GeV self.__hltEtCut = (self.__trigInfo.etthr()) * GeV from Gaugi import ToolSvc emulator = ToolSvc.retrieve("Emulator") if emulator.retrieve(self.__l1caloItem).initialize().isFailure(): MSG_FATAL(self, "It's not possible to initialize the tool with name %s", self.__l1caloItem) if emulator.retrieve(self.__l2caloItem).initialize().isFailure(): MSG_FATAL(self, "It's not possible to initialize the tool with name %s", self.__l2caloItem) if emulator.retrieve(self.__l2Item).initialize().isFailure(): MSG_FATAL(self, "It's not possible to initialize the tool with name %s", self.__l2Item) if emulator.retrieve(self.__hltItem).initialize().isFailure(): MSG_FATAL(self, "It's not possible to initialize the tool with name %s", self.__hltItem) if self.__applyIsolation: if emulator.retrieve(self.__hltIsoItem).initialize().isFailure(): MSG_FATAL( self, "It's not possible to initialize the tool with name %s", self.__hltItem) # Print chain info steps MSG_INFO(self, "") MSG_INFO(self, "+ Chain with name : %s", self.name()) MSG_INFO(self, "|--> L1Calo : %s", self.__l1caloItem) MSG_INFO(self, "|--> L2Calo EtCut : %d", self.__l2caloEtCut) MSG_INFO(self, "|--> L2Calo : %s", self.__l2caloItem) MSG_INFO(self, "|--> L2 : %s", self.__l2Item) MSG_INFO(self, "|--> EFCalo EtCut : %d", self.__efcaloEtCut) MSG_INFO(self, "|--> HLT EtCut : %d", self.__hltEtCut) MSG_INFO(self, "|--> HLT : %s", self.__hltItem) if self.__applyIsolation: MSG_INFO(self, "|--> HLTIso : %s", self.__hltIsoItem) self.init_lock() return StatusCode.SUCCESS
def initialize(self): MSG_INFO(self, 'Initializing EventSimulator...') if super(EventReader, self).initialize().isFailure(): MSG_FATAL(self, "Impossible to initialize the TEventLoop services.") # RingerPhysVal hold the address of required branches if self._dataframe is DataframeEnum.Lorenzetti_v1: #self._t.SetBranchStatus("*", False) from CaloCell import CaloCellCollection from CaloRings import CaloRings from CaloCluster import CaloCluster from EventInfo import EventInfo from GaugiKernel.schema import Lorenzetti_v1 self._event = Lorenzetti_v1() self._t.GetEntry(0) else: return StatusCode.FATAL MSG_INFO(self, "Creating containers...") self._containersSvc['EventInfoContainer'] = EventInfo() self._containersSvc['CaloCellsContainer'] = CaloCellCollection() self._containersSvc['CaloRingsContainer'] = CaloRings() self._containersSvc['CaloClusterContainer'] = CaloCluster() # configure all EDMs needed for key, edm in self._containersSvc.items(): # attach the EDM pointer into the context list self.getContext().setHandler(key, edm) # add properties edm.dataframe = self._dataframe edm.tree = self._t edm.level = self._level edm.event = self._event edm.setContext(self.getContext()) # If initializations is failed, we must remove this from the container # service if (edm.initialize().isFailure()): MSG_WARNING(self, 'Impossible to create the EDM: %s', key) self.getContext().initialize() MSG_INFO(self, 'Initializing all tools...') from Gaugi import ToolSvc as toolSvc self._alg_tools = toolSvc.getTools() for alg in self._alg_tools: if alg.status is StatusTool.DISABLE: continue # Retrieve all services alg.level = self._level alg.setContext(self.getContext()) alg.setStoreGateSvc(self.getStoreGateSvc()) alg.dataframe = self._dataframe if alg.isInitialized(): continue if alg.initialize().isFailure(): MSG_FATAL(self, "Impossible to initialize the tool name: %s", alg.name) return StatusCode.SUCCESS
#pidname = 'MediumLLH_DataDriven_Rel21_Run2_2018' pidname = 'ph_tight' evt.setCutValue(SelectionType.SelectionPID, pidname) evt.setCutValue(EtCutType.L2CaloAbove, 15) ToolSvc += evt from TrigEgammaEmulationTool import Chain triggerList = [ Chain("EMU_g10_tight_noringer", "L1_EM3", "HLT_g10_tight_noringer"), Chain("EMU_g10_tight_ringer_v1", "L1_EM3", "HLT_g10_tight_ringer_v1"), ] # Add all chains into the emulator emulator = ToolSvc.retrieve("Emulator") for chain in triggerList: print(chain.name()) if not emulator.isValid(chain.name()): emulator += chain from QuadrantTools import QuadrantTool alg = QuadrantTool("Quadrant") alg.add_quadrant( 'HLT_g10_tight_noringer', "EMU_g10_tight_noringer", # T2Calo 'HLT_g10_tight_ringer_v1', "EMU_g10_tight_ringer_v1") # Ringer v1 etlist = [15.0, 20.0, 25.0, 30.0, 35.0, 40.0, 45.0, 50.0, 50000.0] etalist = [0.0, 0.6, 0.8, 1.15, 1.37, 1.52, 1.81, 2.01, 2.37, 2.47]
def initialize(self): MSG_INFO(self, 'Initializing EventATLAS...') if super(EventATLAS, self).initialize().isFailure(): MSG_FATAL(self, "Impossible to initialize the TEventLoop services.") if self._dataframe is DataframeEnum.Electron_v1: from EventAtlas import Electron_v1 self._event = Electron_v1() elif self._dataframe is DataframeEnum.ElectronForward_v1: from EventAtlas import ElectronForward_v1 self._event = ElectronForward_v1() elif self._dataframe is DataframeEnum.Photon_v1: from EventAtlas import Photon_v1 self._event = Photon_v1() else: return StatusCode.FATAL MSG_INFO(self, "Creating containers...") # Allocating containers from EventAtlas import Electron from EventAtlas import ElectronForward from EventAtlas import Photon from EventAtlas import TrigEMCluster from EventAtlas import TrigElectron from EventAtlas import CaloCluster from EventAtlas import TrackParticle from EventAtlas import EmTauRoI from EventAtlas import EventInfo from EventAtlas import MonteCarlo from EventAtlas import TDT from EventAtlas import Menu # Initialize the base of this container. # Do not change this key names! self._containersSvc = { # event dataframe containers 'EventInfoContainer': EventInfo(), 'MonteCarloContainer': MonteCarlo(), 'CaloClusterContainer': CaloCluster(), 'MenuContainer': Menu(), } if self._dataframe is DataframeEnum.Electron_v1: self._containersSvc.update({ 'ElectronContainer': Electron(), 'TrackParticleContainer': TrackParticle(), 'HLT__TrigElectronContainer': TrigElectron(), 'HLT__ElectronContainer': Electron(), 'HLT__TrackParticleContainer': TrackParticle(), }) self._containersSvc.update({ 'HLT__TrigEMClusterContainer': TrigEMCluster(), 'HLT__CaloClusterContainer': CaloCluster(), 'HLT__EmTauRoIContainer': EmTauRoI(), }) elif self._dataframe is DataframeEnum.ElectronForward_v1: self._containersSvc.update( {'ElectronForwardContainer': ElectronForward()}) elif self._dataframe is DataframeEnum.Photon_v1: self._containersSvc.update({ 'PhotonContainer': Photon(), 'HLT__PhotonContainer': Photon(), }) self._containersSvc.update({ 'HLT__TrigEMClusterContainer': TrigEMCluster(), 'HLT__CaloClusterContainer': CaloCluster(), 'HLT__EmTauRoIContainer': EmTauRoI(), }) else: return StatusCode.FATAL if self._dataframe is DataframeEnum.Electron_v1 or DataframeEnum.Photon_v1: self._containersSvc.update({ # metadata containers 'HLT__TDT': TDT(), }) # force the event id number for this event looper #self._containersSvc['EventInfoContainer'].setId( self.id() ) # Add decoration for ATLAS event information self._containersSvc['EventInfoContainer'].setDecor( "is_fakes", True if 'fakes' in self._treePath else False) # configure all EDMs needed for key, edm in self._containersSvc.items(): self.getContext().setHandler(key, edm) # add properties edm.dataframe = self._dataframe edm.tree = self._t edm.level = self._level edm.event = self._event edm.setContext(self.getContext()) # enable hlt property by the container key name if 'HLT' in key: edm.is_hlt = True # set basepath into the root file if edm.useMetadataParams(): edm.setMetadataParams({ 'basepath': self._metadataInputFile[1].rsplit('/', 1)[0], 'file': self._metadataInputFile[0] }) # remove the last name after '/' (tree name) # If initializations is failed, we must remove this from the container # service MSG_INFO(self, "Initialize the dataframe with name: %s", key) if (edm.initialize().isFailure()): MSG_WARNING(self, 'Impossible to create the EDM: %s', key) self.getContext().initialize() MSG_INFO(self, 'Initializing all tools...') from Gaugi import ToolSvc as toolSvc self._alg_tools = toolSvc.getTools() for alg in self._alg_tools: if alg.status is StatusTool.DISABLE: continue # Retrieve all services alg.level = self._level alg.setContext(self.getContext()) alg.setStoreGateSvc(self.getStoreGateSvc()) alg.dataframe = self._dataframe if alg.isInitialized(): continue if alg.initialize().isFailure(): MSG_FATAL(self, "Impossible to initialize the tool name: %s", alg.name) return StatusCode.SUCCESS