def generatePhotonsCfg(flags): acc = ComponentAccumulator() from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import MenuSequence, ChainStep, Chain, RecoFragmentsPool from TrigEgammaHypo.TrigEgammaFastCaloHypoTool import TrigEgammaFastCaloHypoToolFromDict from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastCaloHypoAlgMT l2CaloHypo = TrigEgammaFastCaloHypoAlgMT("EgammaFastPhotonCaloHypo") l2CaloHypo.CaloClusters = 'L2CaloEMClusters' from TriggerMenuMT.HLTMenuConfig.Electron.ElectronRecoSequences import l2CaloRecoCfg l2CaloReco = RecoFragmentsPool.retrieve(l2CaloRecoCfg, flags) acc.merge(l2CaloReco) fastCaloSequence = MenuSequence( Sequence=l2CaloReco.sequence(), Maker=l2CaloReco.inputMaker(), Hypo=l2CaloHypo, HypoToolGen=TrigEgammaFastCaloHypoToolFromDict) fastCaloStep = ChainStep("Photon_step1", [fastCaloSequence]) l2PhotonReco = RecoFragmentsPool.retrieve(l2PhotonRecoCfg, flags) acc.merge(l2PhotonReco) from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastPhotonHypoAlgMT l2PhotonHypo = TrigEgammaFastPhotonHypoAlgMT() l2PhotonHypo.Photons = "L2Photons" l2PhotonHypo.RunInView = True from TrigEgammaHypo.TrigEgammaFastPhotonHypoTool import TrigEgammaFastPhotonHypoToolFromDict l2PhotonSequence = MenuSequence( Sequence=l2PhotonReco.sequence(), Maker=l2PhotonReco.inputMaker(), Hypo=l2PhotonHypo, HypoToolGen=TrigEgammaFastPhotonHypoToolFromDict) l2PhotonStep = ChainStep("Photon_step2", [l2PhotonSequence]) chains = [ Chain(c.split()[0], c.split()[1], [fastCaloStep, l2PhotonStep]) for c in flags.Trigger.menu.photons ] return acc, chains
def serial_zip(allSteps, chainName): n_chains = len(allSteps) newsteps = [] for chain_index, chainsteps in enumerate(allSteps): for step_index, step in enumerate(chainsteps): log.debug('chain_index: ' + str(chain_index) + " step_index: " + str(step_index)) # create list of correct length stepList = [None] * n_chains # put the step from the current sub-chain into the right place stepList[chain_index] = step log.debug('Put step: ' + str(step.name)) # all other steps should contain an empty sequence for step_index2, emptyStep in enumerate(stepList): if emptyStep is None: seqName = getEmptySeqName(step.name, chain_index, step_index + 1) emptySeq = RecoFragmentsPool.retrieve(getEmptyMenuSequence, flags=None, name=seqName) stepList[step_index2] = ChainStep( seqName, Sequences=[emptySeq], chainDicts=step.chainDicts) newsteps.append(stepList) log.debug('After serial_zip') for s in newsteps: log.debug(', '.join(map(str, [step.name for step in s]))) return newsteps
def caloClusterRecoSequence( flags, name="HLTCaloClusterMakerFS", RoIs="HLT_FSJETRoI", outputName="HLT_TopoCaloClustersFS"): """ Create the EM-level fullscan clusters """ cell_sequence, cells_name = RecoFragmentsPool.retrieve(cellRecoSequence, flags=None, RoIs=RoIs) from TrigCaloRec.TrigCaloRecConfig import TrigCaloClusterMakerMT_topo alg = TrigCaloClusterMakerMT_topo( name, doMoments=True, doLC=False, cells=cells_name) alg.CaloClusters = recordable(outputName) return parOR(name+"RecoSequence", [cell_sequence, alg]), alg.CaloClusters
def getJetChainStep(self): from TriggerMenuMT.HLTMenuConfig.Jet.JetMenuSequences import jetMenuSequence from TriggerMenuMT.HLTMenuConfig.Jet.JetRecoSequences import jetRecoDictToString jetDefStr = jetRecoDictToString(self.recoDict) stepName = "Step1_jet_" + jetDefStr jetSeq1 = RecoFragmentsPool.retrieve( jetMenuSequence, None, **self.recoDict) # the None will be used for flags in future return ChainStep(stepName, [jetSeq1], multiplicity=[1], chainDicts=[self.dict])
def tauTwoStepTrackSeqIso(): (sequence, ftfIsoViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(tauFTFIsoSequence, ConfigFlags) from TrigTauHypo.TrigTauHypoConf import TrigEFTauMVHypoAlgMT precisionHypo = TrigEFTauMVHypoAlgMT("EFTauMVHypoAlgFinal") precisionHypo.taujetcontainer = sequenceOut from TrigTauHypo.TrigTauHypoTool import TrigEFTauMVHypoToolFromDict return MenuSequence(Sequence=sequence, Maker=ftfIsoViewsMaker, Hypo=precisionHypo, HypoToolGen=TrigEFTauMVHypoToolFromDict)
def tauCaloRecoSequence(InViewRoIs, SeqName): global TauCaloJetContainer # lc sequence (lcTopoInViewSequence, lcCaloSequenceOut) = RecoFragmentsPool.retrieve(HLTLCTopoRecoSequence, InViewRoIs) tauCaloRoiUpdaterAlg = _algoTauRoiUpdater(inputRoIs=InViewRoIs, clusters=lcCaloSequenceOut) updatedRoIs = tauCaloRoiUpdaterAlg.RoIOutputKey tauCaloOnlyAlg = _algoTauCaloOnly(L1RoIs=InViewRoIs, inputRoIs=updatedRoIs, clusters=lcCaloSequenceOut) RecoSequence = parOR( SeqName, [lcTopoInViewSequence, tauCaloRoiUpdaterAlg, tauCaloOnlyAlg]) return (RecoSequence, tauCaloOnlyAlg.Key_trigTauJetOutputContainer)
def LCCaloClusterRecoSequence( flags, name="HLTCaloClusterCalibratorLCFS", RoIs="HLT_FSJETRoI", outputName="HLT_TopoCaloClustersLCFS"): """ Create the LC calibrated fullscan clusters The clusters will be created as a shallow copy of the EM level clusters """ em_sequence, em_clusters = RecoFragmentsPool.retrieve(caloClusterRecoSequence, flags=None, RoIs=RoIs) from TrigCaloRec.TrigCaloRecConfig import TrigCaloClusterCalibratorMT_LC alg = TrigCaloClusterCalibratorMT_LC( name, InputClusters = em_clusters, OutputClusters = outputName, OutputCellLinks = outputName+"_cellLinks") return parOR(name+"RecoSequence", [em_sequence, alg]), alg.OutputClusters
def tauCaloMVAMenuSequence(name): (sequence, tauCaloMVAViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(tauCaloMVASequence, ConfigFlags) # hypo from TrigTauHypo.TrigTauHypoConf import TrigTauCaloHypoAlgMT theTauCaloMVAHypo = TrigTauCaloHypoAlgMT(name + "L2CaloMVAHypo") theTauCaloMVAHypo.taujets = sequenceOut from TrigTauHypo.TrigTauHypoTool import TrigL2TauHypoToolFromDict return MenuSequence(Sequence=sequence, Maker=tauCaloMVAViewsMaker, Hypo=theTauCaloMVAHypo, HypoToolGen=TrigL2TauHypoToolFromDict)
def tauTrackTwoEFSeq(): (sequence, efViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(tauEFSequence, ConfigFlags) from TrigTauHypo.TrigTauHypoConf import TrigEFTauMVHypoAlgMT precisionHypo = TrigEFTauMVHypoAlgMT("EFTauMVHypoAlg") precisionHypo.taujetcontainer = sequenceOut from TrigTauHypo.TrigTauHypoTool import TrigEFTauMVHypoToolFromDict return MenuSequence(Sequence=sequence, Maker=efViewsMaker, Hypo=precisionHypo, HypoToolGen=TrigEFTauMVHypoToolFromDict)
def tauTwoStepTrackSeqCore(): (sequence, ftfCoreViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(tauFTFCoreSequence, ConfigFlags) from TrigTauHypo.TrigTauHypoConf import TrigTrackPreSelHypoAlgMT fastTrkHypo = TrigTrackPreSelHypoAlgMT("TrackPreSelHypoAlg_RejectEmpty") fastTrkHypo.trackcollection = sequenceOut from TrigTauHypo.TrigTauHypoTool import TrigTauTrackHypoToolFromDict return MenuSequence(Sequence=sequence, Maker=ftfCoreViewsMaker, Hypo=fastTrkHypo, HypoToolGen=TrigTauTrackHypoToolFromDict)
def muCombOvlpRmSequence(): (l2muCombSequence, l2muCombViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(muCombAlgSequence, ConfigFlags) ### set up muCombHypo algorithm ### from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigmuCombHypoAlg trigmuCombHypo = TrigmuCombHypoAlg("TrigL2MuCBHypoAlg") trigmuCombHypo.MuonL2CBInfoFromMuCombAlg = sequenceOut from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigmuCombHypoToolwORFromDict return MenuSequence(Sequence=l2muCombSequence, Maker=l2muCombViewsMaker, Hypo=trigmuCombHypo, HypoToolGen=TrigmuCombHypoToolwORFromDict)
def muEFSASequence(): (muonEFSAonlySequence, efsaViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(muEFSAAlgSequence, ConfigFlags) # setup EFSA hypo from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFHypoAlg trigMuonEFSAHypo = TrigMuonEFHypoAlg("TrigMuonEFSAHypoAlg") trigMuonEFSAHypo.MuonDecisions = sequenceOut from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFMSonlyHypoToolFromDict return MenuSequence(Sequence=muonEFSAonlySequence, Maker=efsaViewsMaker, Hypo=trigMuonEFSAHypo, HypoToolGen=TrigMuonEFMSonlyHypoToolFromDict)
def muIsoSequence(): (l2muIsoSequence, l2muIsoViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(muIsoAlgSequence, ConfigFlags) # set up hypo from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuisoHypoAlg trigmuIsoHypo = TrigMuisoHypoAlg("L2MuisoHypoAlg") trigmuIsoHypo.MuonL2ISInfoName = sequenceOut from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuisoHypoToolFromDict return MenuSequence(Sequence=l2muIsoSequence, Maker=l2muIsoViewsMaker, Hypo=trigmuIsoHypo, HypoToolGen=TrigMuisoHypoToolFromDict)
def muEFIsoSequence(): (efmuIsoSequence, efmuIsoViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(muEFIsoAlgSequence, ConfigFlags) # set up hypo from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFTrackIsolationHypoAlg trigmuefIsoHypo = TrigMuonEFTrackIsolationHypoAlg("EFMuisoHypoAlg") trigmuefIsoHypo.EFMuonsName = sequenceOut from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFTrackIsolationHypoToolFromDict return MenuSequence(Sequence=efmuIsoSequence, Maker=efmuIsoViewsMaker, Hypo=trigmuefIsoHypo, HypoToolGen=TrigMuonEFTrackIsolationHypoToolFromDict)
def muFastOvlpRmSequence(): (l2muFastSequence, l2MuViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(muFastAlgSequence, ConfigFlags) ### set up MuFastHypo ### from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMufastHypoAlg trigMufastHypo = TrigMufastHypoAlg("TrigL2MufastHypoAlg") trigMufastHypo.MuonL2SAInfoFromMuFastAlg = sequenceOut from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMufastHypoToolwORFromDict return MenuSequence(Sequence=l2muFastSequence, Maker=l2MuViewsMaker, Hypo=trigMufastHypo, HypoToolGen=TrigMufastHypoToolwORFromDict)
def minbiasTrackMenuSequence(): # menu components # retrieve the reco seuqnece from TriggerMenuMT.HLTMenuConfig.MinBias.MinBiasTrkRecoSequences import minbiasTrackAthSequence (minbiasTrackSequence, InputMakerAlg, sequenceOut) = RecoFragmentsPool.retrieve(minbiasTrackAthSequence, ConfigFlags) #hypo mbHypoAlg = MbCountHypoAlgMT("MinBiasHypoAlg_trk") mbHypoAlg.MinBiasContainerKey = sequenceOut return MenuSequence(Sequence=minbiasTrackSequence, Maker=InputMakerAlg, Hypo=mbHypoAlg, HypoToolGen=TrigMinBiasHypoToolFromDict)
def muCombSequence(): (l2muCombSequence, l2muCombViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(muCombAlgSequence, ConfigFlags) ### set up muCombHypo algorithm ### from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigmuCombHypoAlg #trigmuCombHypo = TrigmuCombHypoAlg("L2muCombHypoAlg") # avoid to have "Comb" string in the name due to HLTCFConfig.py. trigmuCombHypo = TrigmuCombHypoAlg("TrigL2MuCBHypoAlg") trigmuCombHypo.MuonL2CBInfoFromMuCombAlg = sequenceOut from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigmuCombHypoToolFromDict return MenuSequence(Sequence=l2muCombSequence, Maker=l2muCombViewsMaker, Hypo=trigmuCombHypo, HypoToolGen=TrigmuCombHypoToolFromDict)
def getStep(self, stepID, stepPartName, sequenceCfgArray, comboHypoCfg=ComboHypoCfg, comboTools=[]): stepName = 'Step%d' % stepID + '_%d' % self.mult + stepPartName if self.mult > 1: stepName = 'Step%d' % stepID + '_N' + stepPartName log.debug("Configuring step " + stepName) seqArray = [] for sequenceCfg in sequenceCfgArray: seqArray.append(RecoFragmentsPool.retrieve(sequenceCfg, None)) return ChainStep(stepName, seqArray, [self.mult], [self.dict], comboHypoCfg=comboHypoCfg, comboToolConfs=comboTools)
def efLateMuSequence(): (muonEFLateSequence, eflateViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(efLateMuAlgSequence, ConfigFlags) # setup EFCB hypo from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFHypoAlg trigMuonEFLateHypo = TrigMuonEFHypoAlg("TrigMuonEFCombinerLateMuHypoAlg") trigMuonEFLateHypo.MuonDecisions = sequenceOut from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFCombinerHypoToolFromDict return MenuSequence(Sequence=muonEFLateSequence, Maker=eflateViewsMaker, Hypo=trigMuonEFLateHypo, HypoToolGen=TrigMuonEFCombinerHypoToolFromDict)
def muEFCBFSSequence(): (muonEFCBFSSequence, efcbfsInputMaker, sequenceOut) = RecoFragmentsPool.retrieve(muEFCBFSAlgSequence, ConfigFlags) # setup EFCB hypo from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFHypoAlg trigMuonEFCBFSHypo = TrigMuonEFHypoAlg("TrigMuonEFFSCombinerHypoAlg") trigMuonEFCBFSHypo.MuonDecisions = sequenceOut from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFCombinerHypoToolFromName return MenuSequence(Sequence=muonEFCBFSSequence, Maker=efcbfsInputMaker, Hypo=trigMuonEFCBFSHypo, HypoToolGen=TrigMuonEFCombinerHypoToolFromName)
def muEFCBSequence(): (muonEFCBSequence, efcbViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(muEFCBAlgSequence, ConfigFlags) # setup EFCB hypo from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFHypoAlg trigMuonEFCBHypo = TrigMuonEFHypoAlg("TrigMuonEFCombinerHypoAlg") trigMuonEFCBHypo.MuonDecisions = sequenceOut trigMuonEFCBHypo.MapToPreviousDecisions = True from TrigMuonHypoMT.TrigMuonHypoMTConfig import TrigMuonEFCombinerHypoToolFromDict return MenuSequence(Sequence=muonEFCBSequence, Maker=efcbViewsMaker, Hypo=trigMuonEFCBHypo, HypoToolGen=TrigMuonEFCombinerHypoToolFromDict)
def precisionCaloMenuSequence(name): """ Creates precisionCalo MENU sequence """ (sequence, precisionCaloViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(precisionCaloSequence, ConfigFlags) #Hypo from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaPrecisionCaloHypoAlgMT from TrigEgammaHypo.TrigEgammaPrecisionCaloHypoTool import TrigEgammaPrecisionCaloHypoToolFromDict thePrecisionCaloHypo = TrigEgammaPrecisionCaloHypoAlgMT( name + "precisionCaloHypo") thePrecisionCaloHypo.CaloClusters = sequenceOut return MenuSequence(Sequence=sequence, Maker=precisionCaloViewsMaker, Hypo=thePrecisionCaloHypo, HypoToolGen=TrigEgammaPrecisionCaloHypoToolFromDict)
def fastCaloMenuSequence(name, doRinger): """ Creates Egamma Fast Calo MENU sequence The Hypo name changes depending on name, so for different implementations (Electron, Gamma,....) The doRinger flag is to use or not the Ringer hypo """ (sequence, fastCaloViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(fastCaloSequence, {'doRinger' : doRinger}) # check if use Ringer and are electron because there aren't ringer for photons yet: # hypo from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastCaloHypoAlgMT theFastCaloHypo = TrigEgammaFastCaloHypoAlgMT(name+"EgammaFastCaloHypo") theFastCaloHypo.CaloClusters = sequenceOut CaloMenuDefs.L2CaloClusters = sequenceOut from TrigEgammaHypo.TrigEgammaFastCaloHypoTool import TrigEgammaFastCaloHypoToolFromDict return MenuSequence( Sequence = sequence, Maker = fastCaloViewsMaker, Hypo = theFastCaloHypo, HypoToolGen = TrigEgammaFastCaloHypoToolFromDict )
def precisionElectronMenuSequence(): # retrieve the reco seuqence+EVC (electronPrecisionAthSequence, precisionElectronViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(precisionElectronSequence, ConfigFlags) # make the Hypo from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaPrecisionElectronHypoAlgMT thePrecisionElectronHypo = TrigEgammaPrecisionElectronHypoAlgMT( "TrigEgammaPrecisionElectronHypoAlgMT") thePrecisionElectronHypo.Electrons = sequenceOut thePrecisionElectronHypo.RunInView = True from TrigEgammaHypo.TrigEgammaPrecisionElectronHypoTool import TrigEgammaPrecisionElectronHypoToolFromDict return MenuSequence( Maker=precisionElectronViewsMaker, Sequence=electronPrecisionAthSequence, Hypo=thePrecisionElectronHypo, HypoToolGen=TrigEgammaPrecisionElectronHypoToolFromDict)
def fastElectronMenuSequence(): """ Creates 2nd step Electron MENU sequence""" # retrievee the reco seuqence+IM (electronAthSequence, l2ElectronViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(fastElectronSequence, ConfigFlags) # make the Hypo from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaFastElectronHypoAlgMT theElectronHypo = TrigEgammaFastElectronHypoAlgMT() theElectronHypo.Electrons = sequenceOut theElectronHypo.RunInView = True from TrigEgammaHypo.TrigEgammaFastElectronHypoTool import TrigEgammaFastElectronHypoToolFromDict return MenuSequence(Maker=l2ElectronViewsMaker, Sequence=electronAthSequence, Hypo=theElectronHypo, HypoToolGen=TrigEgammaFastElectronHypoToolFromDict)
def precisionPhotonMenuSequence(name): # This will be executed after pricisionCalo, so we need to pickup indeed the topoClusters by precisionCalo and add them here as requirements from AthenaConfiguration.AllConfigFlags import ConfigFlags """Creates precisionPhoton sequence""" (sequence, precisionPhotonViewsMaker, sequenceOut) = RecoFragmentsPool.retrieve(precisionPhotonSequence, ConfigFlags) # Hypo from TrigEgammaHypo.TrigEgammaHypoConf import TrigEgammaPrecisionPhotonHypoAlgMT from TrigEgammaHypo.TrigEgammaPrecisionPhotonHypoTool import TrigEgammaPrecisionPhotonHypoToolFromDict thePrecisionPhotonHypo = TrigEgammaPrecisionPhotonHypoAlgMT( name + "precisionPhotonHypo") thePrecisionPhotonHypo.Photons = sequenceOut return MenuSequence(Sequence=sequence, Maker=precisionPhotonViewsMaker, Hypo=thePrecisionPhotonHypo, HypoToolGen=TrigEgammaPrecisionPhotonHypoToolFromDict)
def precisionCaloRecoSequence(DummyFlag, RoIs): log.debug('DummyFlag = %s', str(DummyFlag)) log.debug('RoIs = %s', RoIs) egammaTopoClusterCopier = AlgFactory( egammaAlgsConf.egammaTopoClusterCopier, name='TrigEgammaTopoClusterCopier' + RoIs, InputTopoCollection="caloclusters", OutputTopoCollection=precisionCaloMenuDefs.precisionCaloClusters, OutputTopoCollectionShallow="tmp_" + precisionCaloMenuDefs.precisionCaloClusters, doAdd=False) from TrigT2CaloCommon.CaloDef import HLTRoITopoRecoSequence (precisionRecoSequence, caloclusters) = RecoFragmentsPool.retrieve(HLTRoITopoRecoSequence, RoIs) algo = egammaTopoClusterCopier() algo.InputTopoCollection = caloclusters precisionRecoSequence += algo sequenceOut = algo.OutputTopoCollection return (precisionRecoSequence, sequenceOut)
def generateChains(): from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import Chain, ChainStep, RecoFragmentsPool from DecisionHandling.TestUtils import makeChain testChains = [] ################################################################## # egamma chains ################################################################## if opt.doEgammaSlice == True: from TriggerMenuMT.HLTMenuConfig.Egamma.ElectronDef import electronFastCaloCfg, fastElectronSequenceCfg, precisionCaloSequenceCfg fastCaloSeq = RecoFragmentsPool.retrieve(electronFastCaloCfg, None) electronSeq = RecoFragmentsPool.retrieve(fastElectronSequenceCfg, None) precisionCaloSeq = RecoFragmentsPool.retrieve(precisionCaloSequenceCfg, None) FastCaloStep = ChainStep("ElectronFastCaloStep", [fastCaloSeq]) FastElectronStep = ChainStep("ElectronFastTrackStep", [electronSeq]) PrecisionCaloStep = ChainStep("ElectronPrecisionCaloStep", [precisionCaloSeq]) electronChains = [ makeChain(name='HLT_e3_etcut1step_L1EM3', L1Thresholds=["EM3"], ChainSteps=[FastCaloStep]), makeChain( name='HLT_e3_etcut_L1EM3', L1Thresholds=["EM3"], ChainSteps=[FastCaloStep, FastElectronStep, PrecisionCaloStep]), makeChain( name='HLT_e5_etcut_L1EM3', L1Thresholds=["EM3"], ChainSteps=[FastCaloStep, FastElectronStep, PrecisionCaloStep]), makeChain( name='HLT_e7_etcut_L1EM3', L1Thresholds=["EM3"], ChainSteps=[FastCaloStep, FastElectronStep, PrecisionCaloStep]) ] testChains += electronChains from TriggerMenuMT.HLTMenuConfig.Egamma.PhotonDef import fastPhotonCaloSequenceCfg, fastPhotonSequenceCfg, precisionPhotonCaloSequenceCfg fastCaloSeq = RecoFragmentsPool.retrieve(fastPhotonCaloSequenceCfg, None) fastPhotonSeq = RecoFragmentsPool.retrieve(fastPhotonSequenceCfg, None) precisionCaloPhotonSeq = RecoFragmentsPool.retrieve( precisionPhotonCaloSequenceCfg, None) FastCaloStep = ChainStep("PhotonFastCaloStep", [fastCaloSeq]) fastPhotonStep = ChainStep("PhotonStep2", [fastPhotonSeq]) precisionCaloPhotonStep = ChainStep("precisionCaloPhotonStep", [precisionCaloPhotonSeq]) photonChains = [ makeChain(name='HLT_g5_etcut_L1EM3', L1Thresholds=["EM3"], ChainSteps=[ FastCaloStep, fastPhotonStep, precisionCaloPhotonStep ]) ] testChains += photonChains ################################################################## # muon chains ################################################################## if opt.doMuonSlice == True: from TriggerMenuMT.HLTMenuConfig.Muon.MuonSequenceSetup import muFastSequence, muCombSequence, muEFSASequence, muIsoSequence, muEFCBSequence, muEFSAFSSequence, muEFCBFSSequence MuonChains = [] # step1 mufastS = muFastSequence() step1mufast = ChainStep("Step1_muFast", [mufastS]) # step2 mucombS = muCombSequence() step2muComb = ChainStep("Step2_muComb", [mucombS]) # step3 muEFSAS = muEFSASequence() step3muEFSA = ChainStep("Step3_muEFSA", [muEFSAS]) step3muIso = ChainStep("Step3_muIso", [muIsoSequence()]) # step4 muEFCBS = muEFCBSequence() step4muEFCB = ChainStep("Step4_muEFCB", [muEFCBS]) emptyStep = ChainStep("Step2_empty", multiplicity=[]) ## single muon trigger MuonChains += [ makeChain(name='HLT_mu6fast_L1MU6', L1Thresholds=["MU6"], ChainSteps=[step1mufast]) ] MuonChains += [ makeChain(name='HLT_mu6Comb_L1MU6', L1Thresholds=["MU6"], ChainSteps=[step1mufast, step2muComb]) ] MuonChains += [ makeChain(name='HLT_mu6_L1MU6', L1Thresholds=["MU6"], ChainSteps=[ step1mufast, step2muComb, step3muEFSA, step4muEFCB ]) ] MuonChains += [ makeChain(name='HLT_mu6msonly_L1MU6', L1Thresholds=["MU6"], ChainSteps=[step1mufast, emptyStep, step3muEFSA]) ] # removed due to muEFSA isuue(?) MuonChains += [ makeChain(name='HLT_mu20_ivar_L1MU6', L1Thresholds=["MU6"], ChainSteps=[step1mufast, step2muComb, step3muIso]) ] # multi muon trigger # 2muons symmetric step1_2mufast_sym = ChainStep("Step1_2muFast_sym", [mufastS], multiplicity=[2]) step2_2muComb_sym = ChainStep("Step2_2muComb_sym", [mucombS], multiplicity=[2]) step3_2muEFSA_sym = ChainStep("Step3_2muEFSA_sym", [muEFSAS], multiplicity=[2]) step4_2muEFCB_sym = ChainStep("Step4_2muEFCB_sym", [muEFCBS], multiplicity=[2]) MuonChains += [ makeChain(name='HLT_2mu6Comb_L12MU6', L1Thresholds=["MU6"], ChainSteps=[step1_2mufast_sym, step2_2muComb_sym]) ] # 2muons asymmetric (this will change): 2 sequences, 2 seeds step1_2mufast_asym = ChainStep("Step1_2muFast_asym", [mufastS, mufastS], multiplicity=[1, 1]) step2_2muComb_asym = ChainStep("Step1_2muComb_asym", [mucombS, mucombS], multiplicity=[1, 1]) step3_2muEFSA_asym = ChainStep("Step3_2muEFSA_asym", [muEFSAS, muEFSAS], multiplicity=[1, 1]) step4_2muEFCB_asym = ChainStep("Step4_2muEFCB_asym", [muEFCBS, muEFCBS], multiplicity=[1, 1]) MuonChains += [ makeChain(name='HLT_mu6_mu4_L12MU4', L1Thresholds=["MU4", "MU6"], ChainSteps=[step1_2mufast_asym, step2_2muComb_asym]) ] #FS Muon trigger # Full scan MS tracking step stepFSmuEFSA = ChainStep("Step_FSmuEFSA", [muEFSAFSSequence()]) stepFSmuEFCB = ChainStep("Step_FSmuEFCB", [muEFCBFSSequence()]) MuonChains += [ makeChain(name='HLT_mu6noL1_L1MU6', L1Thresholds=["FSNOSEED"], ChainSteps=[stepFSmuEFSA, stepFSmuEFCB]) ] testChains += MuonChains ################################################################## # jet chains ################################################################## if opt.doJetSlice == True: from DecisionHandling.jetMenuHelper import jetMenuSequenceFromString # small-R jets, different calibrations HLT_AntiKt4EMTopoJets_subjesIS jetSeq_a4_tc_em = jetMenuSequenceFromString("a4_tc_em_subjesIS") step_a4_tc_em = ChainStep("Step_jet_a4_tc_em", [jetSeq_a4_tc_em]) jetSeq_a4_tc_em_subjes = jetMenuSequenceFromString("a4_tc_em_subjes") step_a4_tc_em_subjes = ChainStep("Step_jet_a4_subjes_tc_em", [jetSeq_a4_tc_em_subjes]) jetSeq_a4_tc_em_nocalib = jetMenuSequenceFromString( "a4_tc_em_nojcalib") step_a4_tc_em_nocalib = ChainStep("Step_jet_a4_nojcalib_tc_em", [jetSeq_a4_tc_em_nocalib]) # jetSeq_a4_tc_lcw = jetMenuSequenceFromString("a10_tc_lcw_subjesIS") # step_a4_tc_lcw=ChainStep("Step_jet_a10_tc_lcw", [jetSeq_a4_tc_lcw]) # large-R jets jetSeq_a10_tc_lcw_subjes = jetMenuSequenceFromString( "a10_tc_lcw_subjes") step_a10_tc_lcw_subjes = ChainStep("Step_jet_a10_subjes_tc_lcw", [jetSeq_a10_tc_lcw_subjes]) jetSeq_a10r = jetMenuSequenceFromString("a10r_tc_em_subjesIS") step_a10r = ChainStep("Step_jet_a10r", [jetSeq_a10r]) jetChains = [ makeChain(name='HLT_j45_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a4_tc_em]), makeChain(name='HLT_j85_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a4_tc_em]), makeChain(name='HLT_j420_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a4_tc_em]), makeChain(name='HLT_j260_320eta490_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a4_tc_em]), # makeChain(name='HLT_j225_gsc420_boffperf_split', ChainSteps=[step_a4_tc_em] ), makeChain(name='HLT_j0_vbenfSEP30etSEP34mass35SEP50fbet_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a4_tc_em]), makeChain(name='HLT_j460_a10_lcw_subjes_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a10_tc_lcw_subjes]), makeChain(name='HLT_j460_a10r_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a10r]), makeChain(name='HLT_3j200_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a4_tc_em]), makeChain( name='HLT_5j70_0eta240_L1J20', L1Thresholds=["J20"], ChainSteps=[step_a4_tc_em] ), # 5j70_0eta240_L14J15 (J20 until multi-object L1 seeds supported) ] testChains += jetChains ################################################################## # bjet chains ################################################################## if opt.doBjetSlice == True: from DecisionHandling.jetMenuHelper import jetMenuSequenceFromString from TriggerMenuMT.HLTMenuConfig.Bjet.BjetSequenceSetup import getBJetSequence jetSequence = jetMenuSequenceFromString("a4_tc_em_subjesgscIS_ftf") step1 = ChainStep("Step1_bjet", [jetSequence]) step2 = ChainStep("Step2_bjet", [getBJetSequence()]) bjetChains = [ makeChain(name='HLT_j45_ftf_subjesgscIS_boffperf_split_L1J20', L1Thresholds=["J20"], ChainSteps=[step1, step2]), makeChain(name='HLT_j45_ftf_subjesgscIS_bmv2c1070_split_L1J20', L1Thresholds=["J20"], ChainSteps=[step1, step2]), makeChain(name='HLT_j45_ftf_subjesgscIS_bmv2c1070_L1J20', L1Thresholds=["J20"], ChainSteps=[step1, step2]) ] testChains += bjetChains ################################################################## # tau chains ################################################################## if opt.doTauSlice == True and False: from TriggerMenuMT.HLTMenuConfig.Tau.TauMenuSequences import getTauSequence step1 = ChainStep("Step1_tau", [getTauSequence('calo')]) step1MVA = ChainStep("Step1MVA_tau", [getTauSequence('calo_mva')]) #This runs the tau-preselection(TP) step step2TP = ChainStep("Step2TP_tau", [getTauSequence('track_core')]) #This runs the EFTauMV hypo on top of fast tracks step2PT = ChainStep("Step2PT_tau", [getTauSequence('precision')]) tauChains = [ makeChain(name='HLT_tau0_perf_ptonly_L1TAU12', L1Thresholds=["TAU12"], ChainSteps=[step1, step2]), makeChain(name='HLT_tau25_medium1_tracktwo_L1TAU12IM', L1Thresholds=["TAU12IM"], ChainSteps=[step1, step2TP]), makeChain(name='HLT_tau35_mediumRNN_tracktwoMVA_L1TAU12IM', L1Thresholds=["TAU20IM"], ChainSteps=[step1MVA, step2PT]) ] testChains += tauChains ################################################################## # MET chains ################################################################## if opt.doMETSlice == True: from TriggerMenuMT.HLTMenuConfig.MET.METMenuSequences import metMenuSequence from TriggerMenuMT.HLTMenuConfig.MET.ConfigHelpers import extractMETRecoDict cellRecoDict = extractMETRecoDict({'EFrecoAlg': "cell"}) metCellSeq = metMenuSequence(None, **cellRecoDict) pufitRecoDict = extractMETRecoDict({'EFrecoAlg': "tcpufit"}) metClusterPufitSeq = metMenuSequence(None, **pufitRecoDict) metCellStep = ChainStep("Step1_met_cell", [metCellSeq]) metClusterPufitStep = ChainStep("Step1_met_clusterpufit", [metClusterPufitSeq]) comboStep_cell_clusterpufit = ChainStep( "Step1_combo_cell_clusterpufit", [metCellSeq, metClusterPufitSeq], multiplicity=[1, 1]) metChains = [ makeChain(name="HLT_xe65_L1XE50", L1Thresholds=["XE50"], ChainSteps=[metCellStep]), makeChain(name="HLT_xe30_L1XE10", L1Thresholds=["XE10"], ChainSteps=[metCellStep]), makeChain(name="HLT_xe30_tcpufit_L1XE10", L1Thresholds=["XE10"], ChainSteps=[metClusterPufitStep]), makeChain(name='HLT_xe30_cell_xe30_tcpufit_L1XE10', L1Thresholds=["XE10", "XE10"], ChainSteps=[comboStep_cell_clusterpufit]) ] testChains += metChains ################################################################## # B-physics and light states chains ################################################################## if opt.doBphysicsSlice == True: from TriggerMenuMT.HLTMenuConfig.Muon.MuonSequenceSetup import muFastSequence, muCombSequence, muEFSASequence, muEFCBSequence from TrigBphysHypo.TrigMultiTrkComboHypoConfig import DimuL2ComboHypoCfg, DimuEFComboHypoCfg step1_dimufast = ChainStep("Step1_dimuFast", [muFastSequence()], multiplicity=[2]) step2_dimuComb = ChainStep("Step2_dimuComb", [muCombSequence()], multiplicity=[2], comboHypoCfg=DimuL2ComboHypoCfg) step3_dimuEFSA = ChainStep("Step3_dimuEFSA", [muEFSASequence()], multiplicity=[2]) step4_dimuEFCB = ChainStep("Step4_dimuEFCB", [muEFCBSequence()], multiplicity=[2], comboHypoCfg=DimuEFComboHypoCfg) steps = [ step1_dimufast, step2_dimuComb, step3_dimuEFSA, step4_dimuEFCB ] BphysChains = [ makeChain(name='HLT_2mu4_bBmumu_L12MU4', L1Thresholds=["MU4"], ChainSteps=steps), makeChain(name='HLT_2mu4_bDimu_L12MU4', L1Thresholds=["MU4"], ChainSteps=steps), makeChain(name='HLT_2mu4_bJpsimumu_L12MU4', L1Thresholds=["MU4"], ChainSteps=steps), makeChain(name='HLT_2mu6_bJpsimumu_L12MU6', L1Thresholds=["MU6"], ChainSteps=steps), makeChain(name='HLT_2mu4_bUpsimumu_L12MU4', L1Thresholds=["MU4"], ChainSteps=steps) ] testChains += BphysChains ################################################################## # combined chains ################################################################## if opt.doCombinedSlice == True: from TriggerMenuMT.HLTMenuConfig.Egamma.ElectronDef import electronFastCaloCfg fastCaloSeq = RecoFragmentsPool.retrieve(electronFastCaloCfg, None) from TriggerMenuMT.HLTMenuConfig.Muon.MuonSequenceSetup import muFastSequence comboStep_et_mufast = ChainStep( "Step1_et_mufast", [fastCaloSeq, muFastSequence()], multiplicity=[1, 1]) comboStep_mufast_etcut1_step1 = ChainStep( "Step1_mufast_etcut1", [muFastSequence(), fastCaloSeq], multiplicity=[1, 1]) comboChains = [ makeChain(name='HLT_e3_etcut_mu6_L1EM8I_MU10', L1Thresholds=["EM8I", "MU10"], ChainSteps=[comboStep_et_mufast]) ] # comboChains += [Chain(name='HLT_mu8fast_e8_etcut1step', ChainSteps=[ comboStep_mufast_etcut1_step1 ])] testChains += comboChains
def gamMenuSequence(step, reconame, hyponame): (Sequence, IM, seqOut) = RecoFragmentsPool.retrieve(makeElSequence,ConfigFlags,name=reconame, step=step) elHypo = ElGamHypo(hyponame+"Step"+step+"GamHypo") elHypo.Input = seqOut return MenuSequence( Maker=IM, Sequence=Sequence, Hypo=elHypo, HypoToolGen=ElTestHypoTool)
def muMenuSequence(step, reconame, hyponame): (Sequence, IM, seqOut) = RecoFragmentsPool.retrieve(makeMuSequence,ConfigFlags,name=reconame, step=step) muHypo = MuHypo(hyponame+"Step"+step+"MuHypo") muHypo.Input = seqOut return MenuSequence( Maker=IM, Sequence=Sequence, Hypo=muHypo, HypoToolGen=MuTestHypoTool)