python.HLT.Muon.MuonMenuSequences Namespace Reference

Functions
def	muFastAlgSequenceCfg (flags, selCAName="", is_probe_leg=False)
	************* Step1 ************* ### --------------------------------------------------—# More...
def	muFastCalibAlgSequenceCfg (flags, is_probe_leg=False)
def	muFastSequenceGenCfg (flags, is_probe_leg=False)
def	muFastCalibSequenceGenCfg (flags, is_probe_leg=False)
def	mul2mtSAOvlpRmSequenceGenCfg (flags, is_probe_leg=False)
def	muCombAlgSequenceCfg (flags, selCAName="", is_probe_leg=False, trackingMode="FTF")
	************* Step2 ************* ### --------------------------------------------------—# More...
def	muCombSequenceGenCfg (flags, is_probe_leg=False, trackingMode="FTF")
def	mul2IOOvlpRmSequenceGenCfg (flags, is_probe_leg=False, trackingMode="FTF")
def	muCombLRTAlgSequenceCfg (flags, is_probe_leg=False)
def	muCombLRTSequenceGenCfg (flags, is_probe_leg=False, trackingMode="FTF")
def	muCombOvlpRmSequenceGenCfg (flags, is_probe_leg=False, trackingMode="FTF")
def	mul2mtCBOvlpRmSequenceGenCfg (flags, is_probe_leg=False, trackingMode="FTF")
def	muEFSAAlgSequenceCfg (flags, is_probe_leg=False)
	EFSA step ###. More...
def	muEFSASequenceGenCfg (flags, is_probe_leg=False)
def	muEFCBAlgSequenceCfg (flags, suffix, selCAName='', is_probe_leg=False)
	EFCB seq ###. More...
def	muEFCBSequenceGenCfg (flags, is_probe_leg=False)
def	muEFCBl2ioSequenceGenCfg (flags, is_probe_leg=False)
def	muEFCBl2mtSequenceGenCfg (flags, is_probe_leg=False)
def	muEFCBIDperfSequenceGenCfg (flags, is_probe_leg=False)
def	muEFIDtpSequenceGenCfg (flags, is_probe_leg=False)
def	muEFCBLRTAlgSequenceCfg (flags, selCAName='', is_probe_leg=False)
def	muEFCBLRTSequenceGenCfg (flags, is_probe_leg=False)
def	muEFCBLRTIDperfSequenceGenCfg (flags, is_probe_leg=False)
def	muEFSAFSAlgSequenceCfg (flags)
	EF SA full scan ###. More...
def	muEFSAFSSequenceGenCfg (flags, is_probe_leg=False)
def	muEFCBFSAlgSequenceCfg (flags, is_probe_leg=False)
	EF CB full scan ###. More...
def	muEFCBFSSequenceGenCfg (flags, is_probe_leg=False)
def	efLateMuRoIAlgSequenceCfg (flags, is_probe_leg=False)
def	efLateMuRoISequenceGenCfg (flags, is_probe_leg=False)
def	efLateMuAlgSequenceCfg (flags, is_probe_leg=False)
def	efLateMuSequenceGenCfg (flags, is_probe_leg=False)
def	muEFIsoAlgSequenceCfg (flags, doMSiso=False, is_probe_leg=False)
	efMuiso step ### More...
def	muEFIsoSequenceGenCfg (flags, is_probe_leg=False)
def	muEFMSIsoSequenceGenCfg (flags, is_probe_leg=False)
def	muRoiClusterSequenceGenCfg (flags)
	Muon RoI Cluster Trigger for MS LLP Searches ##. More...
def	getBphysChainNames ()
	Get Bphysics triggers to # filter chains where we # don't want to run muComb #. More...
def	getInsideOutMuonChainNames ()
	Get muon triggers except L2 inside-out trigger to filter chains where we don't want to run L2SA IO mode. More...
def	getMultiTrackChainNames ()
	Get muon triggers except L2 multi-track trigger to filter chains where we don't want to run L2SA multi-track mode. More...

Variables
	log
	muNames
	muNamesLRT
	muNamesFS

Function Documentation

efLateMuAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.efLateMuAlgSequenceCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 834 of file MuonMenuSequences.py.

def efLateMuAlgSequenceCfg(flags, is_probe_leg=False):
 
    from .MuonRecoSequences import muEFInsideOutRecoSequenceCfg, muonDecodeCfg, muonIDFastTrackingSequenceCfg
    selAcc = SelectionCA('EFLateMuAlg', isProbe=is_probe_leg)
    
    viewName = "EFLateMuReco"
    viewcreator = CompFactory.ViewCreatorNamedROITool
    roiTool = viewcreator(ROILinkName="feature")
                                                         
    recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView=True, mergeUsingFeature=True, isProbe=is_probe_leg)
 
 
    #Clone and replace offline flags so we can set muon trigger specific values
    muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
    muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
    #decode data in these RoIs
    recoLateMu.mergeReco(muonDecodeCfg(muonflags,RoIs=recoLateMu.name+"RoIs"))
    #ID fast tracking
    recoLateMu.mergeReco(muonIDFastTrackingSequenceCfg(flags, recoLateMu.name+"RoIs","muonLate" ))
    #inside-out reco sequence
    recoLateMu.mergeReco(muEFInsideOutRecoSequenceCfg(muonflagsCB, recoLateMu.name+"RoIs", "LateMu", ''))
    sequenceOut = muNames.EFCBInOutName+'_Late'
 
 
    from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
    robPrefetchAlg = ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName)
    selAcc.mergeReco(recoLateMu, robPrefetchCA = robPrefetchAlg)
 
    return (selAcc, sequenceOut)
 
 
@AccumulatorCache

efLateMuRoIAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.efLateMuRoIAlgSequenceCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 795 of file MuonMenuSequences.py.

def efLateMuRoIAlgSequenceCfg(flags, is_probe_leg=False):
 
    selAcc = SelectionCA('EFLateMuSel', isProbe=is_probe_leg)
    
    viewName = "EFLateMuRoIReco"
    viewcreator = CompFactory.ViewCreatorInitialROITool
    roiTool = viewcreator()
                                                         
    recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg)
 
    from .MuonRecoSequences import efLateMuRoISequenceCfg
 
    #Get Late Muon RoIs
    efLateMuRoIAcc, sequenceOut = efLateMuRoISequenceCfg(flags)
    recoLateMu.mergeReco(efLateMuRoIAcc)
 
    selAcc.mergeReco(recoLateMu)
    return (selAcc, sequenceOut)
 
 
@AccumulatorCache

efLateMuRoISequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.efLateMuRoISequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 816 of file MuonMenuSequences.py.

def efLateMuRoISequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = efLateMuRoIAlgSequenceCfg(flags, is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonLateMuRoIHypoAlgCfg, TrigMuonLateMuRoIHypoToolFromDict
    latemuHypo = TrigMuonLateMuRoIHypoAlgCfg( flags,
                              name = 'TrigMuonLateMuRoIHypoAlg',
                              LateRoIs = sequenceOut)
 
    selAcc.addHypoAlgo(latemuHypo)
    
    latemuRoISequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonLateMuRoIHypoToolFromDict)
 
 
    return latemuRoISequence
 
 

efLateMuSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.efLateMuSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 866 of file MuonMenuSequences.py.

def efLateMuSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = efLateMuAlgSequenceCfg(flags, is_probe_leg=False)
 
    # setup EFCB hypo
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg
    trigMuonEFLateHypo = TrigMuonEFHypoAlgCfg( "TrigMuonEFCombinerLateMuHypoAlg", MuonDecisions = sequenceOut )
 
    selAcc.addHypoAlgo(trigMuonEFLateHypo)
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFCombinerHypoToolFromDict
 
    return MenuSequence(flags, selAcc,
                          HypoToolGen = TrigMuonEFCombinerHypoToolFromDict )
 
 
 

getBphysChainNames()

def python.HLT.Muon.MuonMenuSequences.getBphysChainNames

(

)

Get Bphysics triggers to # filter chains where we # don't want to run muComb #.

Definition at line 996 of file MuonMenuSequences.py.

def getBphysChainNames():
    from ..Config.GenerateMenuMT import GenerateMenuMT
    menu = GenerateMenuMT()  # get menu singleton
    chains = [chain.name for chain in menu.chainsInMenu['Bphysics']]
    return chains
 

getInsideOutMuonChainNames()

def python.HLT.Muon.MuonMenuSequences.getInsideOutMuonChainNames

(

)

Get muon triggers except L2 inside-out trigger to filter chains where we don't want to run L2SA IO mode.

Definition at line 1007 of file MuonMenuSequences.py.

def getInsideOutMuonChainNames():
    from ..Config.GenerateMenuMT import GenerateMenuMT
    menu = GenerateMenuMT()  # get menu singleton
    chains = [chain.name for chain in menu.chainsInMenu['Muon'] if "l2io" in chain.name]
    chains += [chain.name for chain in menu.chainsInMenu['Bphysics'] if not any(key in chain.name for key in ['noL2Comb','l2mt'])]
    return chains
 

getMultiTrackChainNames()

def python.HLT.Muon.MuonMenuSequences.getMultiTrackChainNames

(

)

Get muon triggers except L2 multi-track trigger to filter chains where we don't want to run L2SA multi-track mode.

Definition at line 1019 of file MuonMenuSequences.py.

def getMultiTrackChainNames():
    from ..Config.GenerateMenuMT import GenerateMenuMT
    menu = GenerateMenuMT()  # get menu singleton
    chains = [chain.name for chain in menu.chainsInMenu['Muon'] if "l2mt" in chain.name]
    chains += [chain.name for chain in menu.chainsInMenu['Bphysics'] if "l2mt" in chain.name]
    return chains

muCombAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muCombAlgSequenceCfg	(		flags,
			selCAName = "",
			is_probe_leg = False,
			trackingMode = "FTF"
	)

************* Step2 ************* ### --------------------------------------------------—#

Definition at line 166 of file MuonMenuSequences.py.

def muCombAlgSequenceCfg(flags, selCAName="", is_probe_leg=False, trackingMode = "FTF"):
    
    from .MuonRecoSequences  import muFastRecoSequenceCfg, muCombRecoSequenceCfg, muonIDFastTrackingSequenceCfg, muonIDCosmicTrackingSequenceCfg, isCosmic
 
    selAccCB = SelectionCA('L2MuCombSel'+selCAName, isProbe=is_probe_leg)
    
    viewName="Cosmic" if isCosmic(flags) else "L2MuCombReco"
 
    ViewCreatorFetchFromViewROITool=CompFactory.ViewCreatorFetchFromViewROITool
    #temporarily using different view names until L2 SA sequence is migrated to CA
    roiTool         = ViewCreatorFetchFromViewROITool(RoisWriteHandleKey="HLT_Roi_L2SAMuon", InViewRoIs = muNames.L2forIDName)
    requireParentView = True
 
    recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView, isProbe=is_probe_leg)
    muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
 
    
    sequenceOut = muNames.L2CBName
 
    acc = ComponentAccumulator()
    from TrigMuonEF.TrigMuonEFConfig import MuonChainFilterAlgCfg
 
 
    from TriggerMenuMT.HLT.Config.ControlFlow.MenuComponentsNaming import CFNaming
    filterInput = [ CFNaming.inputMakerOutName('IM_'+viewName) ]
    extraLoads = []
    for decision in filterInput:
      extraLoads += [( 'xAOD::TrigCompositeContainer' , 'StoreGateSvc+%s' % decision )]
 
    if isCosmic(flags):
        recoCB.mergeReco(muonIDCosmicTrackingSequenceCfg( flags, viewName+"RoIs" , "cosmics", extraLoads, extraLoads ))
    else:
        recoCB.mergeReco(muonIDFastTrackingSequenceCfg(flags, viewName+"RoIs", "muon", extraLoads, extraLoads, trackingMode = trackingMode ))
 
    # for nominal muComb
    seql2cb = seqAND("l2muCombFilterSequence{}".format("_probe" if is_probe_leg else ""))
    acc.addSequence(seql2cb)
 
    #Filter algorithm to run muComb only if non-Bphysics muon chains are active
    muonChainFilter = MuonChainFilterAlgCfg(muonflags, "FilterBphysChains", ChainsToFilter = getBphysChainNames(), 
                                            InputDecisions = filterInput,
                                            L2MuCombContainer = sequenceOut,
                                            WriteMuComb = True, WriteMuFast=False)
    acc.merge(muonChainFilter, sequenceName=seql2cb.name)
 
 
 
    acc.merge(muCombRecoSequenceCfg(flags, viewName+"RoIs", "FTF", l2mtmode=False, l2CBname = sequenceOut ), sequenceName=seql2cb.name)
 
    # for L2 multi-track SA
    MultiTrackChains = getMultiTrackChainNames()
    MultiTrackChainFilter = MuonChainFilterAlgCfg(muonflags, "CBFilterMultiTrackChains", ChainsToFilter = MultiTrackChains, 
                                                  InputDecisions = filterInput,
                                                  L2MuFastContainer = muNames.L2SAName+"l2mtmode", 
                                                  L2MuCombContainer = muNames.L2CBName+"l2mtmode",
                                                  WriteMuComb = True, NotGate = True)
 
 
    seql2cbmt = seqAND("l2mtmuCombFilterSequence{}".format("_probe" if is_probe_leg else ""))
    acc.addSequence(seql2cbmt)
    acc.merge(MultiTrackChainFilter, sequenceName=seql2cbmt.name)
 
 
    sequenceOutL2mtCB = muNames.L2CBName+"l2mtmode"
    acc.merge(muCombRecoSequenceCfg(flags, viewName+"RoIs", "FTF", l2mtmode=True, l2CBname = sequenceOutL2mtCB ), sequenceName=seql2cbmt.name)
 
 
 
    # for Inside-out L2SA
    seql2iocb = seqAND("l2muFastIOFilterSequence{}".format("_probe" if is_probe_leg else ""))
    acc.addSequence(seql2iocb)
 
    from .MuonRecoSequences  import isCosmic
    sequenceOutL2SAIO = muNames.L2SAName+"IOmode"
    insideoutMuonChainFilter = MuonChainFilterAlgCfg("FilterInsideOutMuonChains", ChainsToFilter = getInsideOutMuonChainNames(),
                                                     InputDecisions = filterInput,
                                                     L2MuFastContainer = sequenceOutL2SAIO, L2MuCombContainer = muNames.L2CBName+"IOmode",
                                                     WriteMuFast = True, WriteMuComb = True, NotGate=True)
 
    acc.merge(insideoutMuonChainFilter, sequenceName=seql2iocb.name)
    acc.merge(muFastRecoSequenceCfg(muonflags, viewName+"RoIs", doFullScanID=isCosmic(flags) , InsideOutMode=True), sequenceName=seql2iocb.name)
    recoCB.mergeReco(acc)
 
 
    from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si
    robPrefetchAlg = ROBPrefetchingAlgCfg_Si(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
    selAccCB.mergeReco(recoCB, robPrefetchCA=robPrefetchAlg)
 
    return (selAccCB, sequenceOut)
 
 
@AccumulatorCache

muCombLRTAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muCombLRTAlgSequenceCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 298 of file MuonMenuSequences.py.

def muCombLRTAlgSequenceCfg(flags, is_probe_leg=False):
 
    selAcc = SelectionCA('l2muCombLRT', isProbe=is_probe_leg)
    
    viewName="l2muCombLRT"
    ViewCreatorCenteredOnIParticleTool=CompFactory.ViewCreatorCentredOnIParticleROITool
  
    roiTool         = ViewCreatorCenteredOnIParticleTool(RoisWriteHandleKey = recordable("HLT_Roi_L2SAMuon_LRT"), 
                                                         RoIZedWidth=flags.Trigger.InDetTracking.muonLRT.zedHalfWidth,
                                                         RoIEtaWidth=flags.Trigger.InDetTracking.muonLRT.etaHalfWidth,
                                                         RoIPhiWidth=flags.Trigger.InDetTracking.muonLRT.phiHalfWidth,
                                                         UseZedPosition=False)
    requireParentView = True
 
    recol2cb = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView, isProbe=is_probe_leg)
 
    
    from .MuonRecoSequences  import muCombRecoSequenceCfg, muonIDFastTrackingSequenceCfg
    sequenceOut = muNamesLRT.L2CBName
    recol2cb.mergeReco(muCombRecoSequenceCfg(flags, viewName+"RoIs", "FTF_LRT", l2CBname = sequenceOut ))
 
    extraLoads = []
 
    recol2cb.mergeReco(muonIDFastTrackingSequenceCfg(flags, viewName+"RoIs" , "muonLRT", extraLoads, doLRT=True ))
 
 
    from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si
    robPrefetchAlg = ROBPrefetchingAlgCfg_Si(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
    selAcc.mergeReco(recol2cb, robPrefetchAlg)
 
 
    return (selAcc, sequenceOut)
 
 
@AccumulatorCache

muCombLRTSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muCombLRTSequenceGenCfg	(		flags,
			is_probe_leg = False,
			trackingMode = "FTF"
	)

Definition at line 333 of file MuonMenuSequences.py.

def muCombLRTSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
 
    (selAcc, sequenceOut) = muCombLRTAlgSequenceCfg(flags, is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, TrigmuCombHypoToolFromDict
    l2cbHypo = TrigmuCombHypoAlgCfg( flags,
                                     name = 'TrigL2MuCBLRTHypoAlg',
                                     MuonL2CBInfoFromMuCombAlg = sequenceOut,
                                     RoILinkName = "l2lrtroi",
                                     )
 
    selAcc.addHypoAlgo(l2cbHypo)
    
    l2cbSequence = MenuSequence(flags, selAcc,
                                  HypoToolGen = TrigmuCombHypoToolFromDict)
 
 
    return l2cbSequence
 
 
@AccumulatorCache

muCombOvlpRmSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muCombOvlpRmSequenceGenCfg	(		flags,
			is_probe_leg = False,
			trackingMode = "FTF"
	)

Definition at line 354 of file MuonMenuSequences.py.

def muCombOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
 
    (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "", is_probe_leg, trackingMode = trackingMode)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, TrigmuCombHypoToolwORFromDict
    l2cbHypo = TrigmuCombHypoAlgCfg( flags,
                                     name = 'TrigL2MuCBHypoAlg',
                                     MuonL2CBInfoFromMuCombAlg = sequenceOut,
                                     )
 
    selAcc.addHypoAlgo(l2cbHypo)
    
    l2cbSequence = MenuSequence(flags, selAcc,
                                  HypoToolGen = TrigmuCombHypoToolwORFromDict)
 
    return l2cbSequence
 
 
@AccumulatorCache

muCombSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muCombSequenceGenCfg	(		flags,
			is_probe_leg = False,
			trackingMode = "FTF"
	)

Definition at line 259 of file MuonMenuSequences.py.

def muCombSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
 
    (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "", is_probe_leg, trackingMode = trackingMode)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, TrigmuCombHypoToolFromDict
    l2cbHypo = TrigmuCombHypoAlgCfg( flags,
                                     name = 'TrigL2MuCBHypoAlg',
                                     MuonL2CBInfoFromMuCombAlg = sequenceOut,
                                     )
 
    selAcc.addHypoAlgo(l2cbHypo)
    
    l2cbSequence = MenuSequence(flags, selAcc,
                                  HypoToolGen = TrigmuCombHypoToolFromDict)
 
 
    return l2cbSequence
 
 
@AccumulatorCache

muEFCBAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBAlgSequenceCfg	(		flags,
			suffix,
			selCAName = '',
			is_probe_leg = False
	)

EFCB seq ###.

Definition at line 448 of file MuonMenuSequences.py.

def muEFCBAlgSequenceCfg(flags, suffix, selCAName='', is_probe_leg=False):
 
    from .MuonRecoSequences import isCosmic
    selAccCB = SelectionCA('EFMuCBSel_RoI'+selCAName+suffix, isProbe=is_probe_leg)
    
    viewName="EFMuCBReco_RoI"+suffix if not isCosmic(flags) else "CosmicEFCB"
    ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
    #temporarily using different view names until L2 SA sequence is migrated to CA
    roiTool         = ViewCreatorTool(ROILinkName="l2cbroi")
 
    recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg, mergeUsingFeature=True)
 
    #By default the EFCB sequence will run both outside-in and
    #(if zero muons are found) inside-out reconstruction
    from TrigMuonEF.TrigMuonEFConfig import MuonFilterAlgCfg, MergeEFMuonsAlgCfg
    from .MuonRecoSequences import muEFCBRecoSequenceCfg, muEFInsideOutRecoSequenceCfg
 
    acc = ComponentAccumulator()
    seqmerge = seqAND("muonCBInsideOutMergingSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
    acc.addSequence(seqmerge)
 
    #outside-in reco sequence
    acc2 = ComponentAccumulator()
    seqreco = parOR("muonEFCBandInsideOutRecoSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
    acc2.addSequence(seqreco)
    muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
    acc2.merge(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "RoI", suffix ), sequenceName=seqreco.name)
    sequenceOutCB = muNames.EFCBOutInName+suffix
 
    #Algorithm to filter events with no muons
    acc3 = ComponentAccumulator()
    seqfilter = seqAND("muonEFInsideOutSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
    acc3.addSequence(seqfilter)
    muonFilter = MuonFilterAlgCfg(flags, name="FilterZeroMuons"+suffix, MuonContainerLocation=sequenceOutCB)
    acc3.merge(muonFilter, sequenceName=seqfilter.name)
 
    #inside-out reco sequence - runs only if filter is passed
    acc4 = ComponentAccumulator()
    seqio = parOR("efmuInsideOutViewNode_RoI{}{}".format(suffix, "_probe" if is_probe_leg else ""))
    acc4.addSequence(seqio)
    acc4.merge(muEFInsideOutRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "RoI", suffix), sequenceName=seqio.name+suffix)
    sequenceOutInsideOut = muNames.EFCBInOutName+suffix
 
    acc3.merge(acc4, sequenceName=seqfilter.name)
    acc2.merge(acc3, sequenceName=seqreco.name)
    acc.merge(acc2, sequenceName=seqmerge.name)
    #Merge muon containers from outside-in and inside-out reco
    mergeMuons = MergeEFMuonsAlgCfg(flags, name="MergeEFMuons"+suffix, MuonCBContainerLocation=sequenceOutCB, 
                                    MuonInsideOutContainerLocation=sequenceOutInsideOut, MuonOutputLocation=muNames.EFCBName+suffix)
 
    acc.merge(mergeMuons, sequenceName=seqmerge.name)
    recoCB.mergeReco(acc)
    selAccCB.mergeReco(recoCB)
 
    return (selAccCB, muNames.EFCBName)
 
 
@AccumulatorCache

muEFCBFSAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBFSAlgSequenceCfg	(		flags,
			is_probe_leg = False
	)

EF CB full scan ###.

Definition at line 717 of file MuonMenuSequences.py.

def muEFCBFSAlgSequenceCfg(flags, is_probe_leg=False):
 
    selAccCB = SelectionCA('EFMuCBSel_FS', isProbe=is_probe_leg)
    
    viewName="EFMuCBReco_FS"
    #temporarily using different view names until L2 SA sequence is migrated to CA
    roiTool         = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = "MuonCandidates_FS_ROIs")
 
    recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg, mergeUsingFeature=True, 
                          PlaceMuonInView=True, InViewMuons = "InViewMuons", InViewMuonCandidates = "MuonCandidates_FS")
 
 
    from TrigMuonEF.TrigMuonEFConfig import MuonFilterAlgCfg, MergeEFMuonsAlgCfg
    from .MuonRecoSequences import muEFCBRecoSequenceCfg, muEFInsideOutRecoSequenceCfg
    #outside-in reco sequence
    acc = ComponentAccumulator()
    seqmerge = seqAND("muonCBInsideOutMergingSequenceEFCBFS{}".format("_probe" if is_probe_leg else ""))
    acc.addSequence(seqmerge)
 
    muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
    acc2 = ComponentAccumulator()
    seqreco = parOR("muonEFCBFSInsideOutRecoSequence{}".format("_probe" if is_probe_leg else ""))
    acc2.addSequence(seqreco)
 
    acc2.merge(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "FS", ''), sequenceName=seqreco.name)
    sequenceOutCB = muNamesFS.EFCBOutInName
 
    #Alg fitltering for no muon events
    muonFilter =  MuonFilterAlgCfg(flags, name="FilterZeroMuonsEFCBFS", MuonContainerLocation = sequenceOutCB)
 
    acc3 = ComponentAccumulator()
    seqfilt = seqAND("muonEFCBFSInsideOutSequence{}".format("_probe" if is_probe_leg else ""))
    acc3.addSequence(seqfilt)
    acc3.merge(muonFilter, sequenceName=seqfilt.name)
 
 
    #If filter passed
    acc4 = ComponentAccumulator()
    seqio = parOR("efmuInsideOutViewNode_FS{}".format("_probe" if is_probe_leg else ""))
    acc4.addSequence(seqio)
 
    muonEFInsideOutRecoAlgSequence = muEFInsideOutRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "FS", '' )
    acc4.merge(muonEFInsideOutRecoAlgSequence, sequenceName=seqio.name)
    acc3.merge(acc4, sequenceName=seqfilt.name)
    acc2.merge(acc3, sequenceName=seqreco.name)
    acc.merge(acc2, sequenceName=seqmerge.name)
    sequenceOutInsideOut = muNamesFS.EFCBInOutName
 
    #Merge muon containers from O-I and I-O reco
    mergeMuons = MergeEFMuonsAlgCfg(flags, name="MergeEFCBFSMuons", MuonCBContainerLocation = sequenceOutCB, 
                                    MuonInsideOutContainerLocation = sequenceOutInsideOut, MuonOutputLocation = muNamesFS.EFCBName)
    acc.merge(mergeMuons, sequenceName=seqmerge.name)
    recoCB.mergeReco(acc)
 
    sequenceOut = muNamesFS.EFCBName
    selAccCB.mergeReco(recoCB)
 
    return (selAccCB, sequenceOut)
 
 
@AccumulatorCache

muEFCBFSSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBFSSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 778 of file MuonMenuSequences.py.

def muEFCBFSSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFCBFSAlgSequenceCfg(flags, is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromName
    efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
                              name = 'TrigMuonEFFSCombinerHypoAlg',
                              MuonDecisions = sequenceOut)
 
    selAcc.addHypoAlgo(efmuCBHypo)
    
    efmuCBSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFCombinerHypoToolFromName)
 
    return efmuCBSequence
 
 

muEFCBIDperfSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBIDperfSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 563 of file MuonMenuSequences.py.

def muEFCBIDperfSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idperf', is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
    efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
                                       name = 'TrigMuonEFCombinerIDperfHypoAlg',
                                       IncludeSAmuons=True,
                                       MuonDecisions = sequenceOut,
                                       MapToPreviousDecisions=True)
 
    selAcc.addHypoAlgo(efmuCBHypo)
    
    efmuCBSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
 
    return efmuCBSequence
 
 
@AccumulatorCache

muEFCBl2ioSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBl2ioSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 525 of file MuonMenuSequences.py.

def muEFCBl2ioSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags,'IOmode', '', is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
    efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
                              name = 'TrigMuonEFCombinerHypoAlgIOmode',
                              MuonDecisions = sequenceOut+'IOmode',
                              MapToPreviousDecisions=True)
 
    selAcc.addHypoAlgo(efmuCBHypo)
    
    efmuCBSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
 
    return efmuCBSequence
 
 
@AccumulatorCache

muEFCBl2mtSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBl2mtSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 544 of file MuonMenuSequences.py.

def muEFCBl2mtSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags,'l2mtmode', '', is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
    efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
                              name = 'TrigMuonEFCombinerHypoAlgl2mtmode',
                              MuonDecisions = sequenceOut+'l2mtmode',
                              MapToPreviousDecisions=True)
 
    selAcc.addHypoAlgo(efmuCBHypo)
    
    efmuCBSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
 
    return efmuCBSequence
 
 
@AccumulatorCache

muEFCBLRTAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBLRTAlgSequenceCfg	(		flags,
			selCAName = '',
			is_probe_leg = False
	)

Definition at line 600 of file MuonMenuSequences.py.

def muEFCBLRTAlgSequenceCfg(flags, selCAName='', is_probe_leg=False):
 
    selAccCB = SelectionCA('EFMuCBLRTSel'+selCAName, isProbe=is_probe_leg)
    
    viewName="EFMuCBLRTReco"
    ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
    roiTool         = ViewCreatorTool(ROILinkName="l2lrtroi")
 
    recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, mergeUsingFeature=True, isProbe=is_probe_leg)
 
    from .MuonRecoSequences import muEFCBRecoSequenceCfg
 
    #outside-in reco sequence
    muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
    recoCB.mergeReco(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "LRT", ''))
    sequenceOut = muNamesLRT.EFCBName
 
    selAccCB.mergeReco(recoCB)
 
    return (selAccCB, sequenceOut)
 
 
@AccumulatorCache

muEFCBLRTIDperfSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBLRTIDperfSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 643 of file MuonMenuSequences.py.

def muEFCBLRTIDperfSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, 'idperf', is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
    efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
                                          name = 'TrigMuonEFCombinerHypoAlgLRTIDPerf',
                                          IncludeSAmuons=True,
                                          MuonDecisions = sequenceOut,
                                          MapToPreviousDecisions=True)
 
 
    selAcc.addHypoAlgo(efmuCBLRTHypo)
    
    efmuCBSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
 
    return efmuCBSequence
 
 

muEFCBLRTSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBLRTSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 623 of file MuonMenuSequences.py.

def muEFCBLRTSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, '', is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
    efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
                                          name = 'TrigMuonEFCombinerHypoAlgLRT',
                                          MuonDecisions = sequenceOut,
                                          MapToPreviousDecisions=True)
 
 
    selAcc.addHypoAlgo(efmuCBLRTHypo)
    
    efmuCBSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
 
    return efmuCBSequence
 
 
@AccumulatorCache

muEFCBSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFCBSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 506 of file MuonMenuSequences.py.

def muEFCBSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', '', is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
    efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
                              name = 'TrigMuonEFCombinerHypoAlg',
                              MuonDecisions = sequenceOut,
                              MapToPreviousDecisions=True)
 
    selAcc.addHypoAlgo(efmuCBHypo)
    
    efmuCBSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
 
    return efmuCBSequence
 
 
@AccumulatorCache

muEFIDtpSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFIDtpSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 583 of file MuonMenuSequences.py.

def muEFIDtpSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idtp', is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFIdtpHypoAlgCfg, TrigMuonEFIdtpHypoToolFromDict
    efmuCBHypo = TrigMuonEFIdtpHypoAlgCfg( flags,
                                       name = 'TrigMuonEFIdtpHypoAlg')
 
 
    selAcc.addHypoAlgo(efmuCBHypo)
    
    efmuCBSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFIdtpHypoToolFromDict)
 
    return efmuCBSequence
 
 

muEFIsoAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muEFIsoAlgSequenceCfg	(		flags,
			doMSiso = False,
			is_probe_leg = False
	)

efMuiso step ###

Definition at line 885 of file MuonMenuSequences.py.

def muEFIsoAlgSequenceCfg(flags, doMSiso=False, is_probe_leg=False):
    name = ""
    if doMSiso:
        name = "MS"
 
 
    selAccIso = SelectionCA('EFMuIso'+name, isProbe=is_probe_leg)
    
    viewName="EFMuIsoReco"+name
    if doMSiso:
        roisWriteHandleKey = "Roi_MuonIsoMS"
    else:
        roisWriteHandleKey = recordable("HLT_Roi_MuonIso")
 
    roiTool         = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = roisWriteHandleKey, 
                                                                       RoIEtaWidth=flags.Trigger.InDetTracking.muonIso.etaHalfWidth,
                                                                       RoIPhiWidth=flags.Trigger.InDetTracking.muonIso.phiHalfWidth,
                                                                       RoIZedWidth=flags.Trigger.InDetTracking.muonIso.zedHalfWidth)
 
    recoIso = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg, mergeUsingFeature=True,
                          PlaceMuonInView=True, InViewMuons = "IsoViewMuons"+name, InViewMuonCandidates = "IsoMuonCandidates"+name)
 
 
    
    from .MuonRecoSequences  import efmuisoRecoSequenceCfg
    sequenceOut = muNames.EFIsoMuonName+name
    recoIso.mergeReco(efmuisoRecoSequenceCfg( flags, viewName+"RoIs", "IsoViewMuons"+name, doMSiso ))
 
 
    from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si
    robPrefetchAlg = ROBPrefetchingAlgCfg_Si(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
 
    selAccIso.mergeReco(recoIso, robPrefetchCA = robPrefetchAlg)
 
    return (selAccIso, sequenceOut)
 
 
@AccumulatorCache

muEFIsoSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFIsoSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 923 of file MuonMenuSequences.py.

def muEFIsoSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, False, is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
    efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
                                                      name = 'EFMuisoHypoAlg',
                                                      EFMuonsName = sequenceOut)
 
    selAcc.addHypoAlgo(efmuisoHypo)
    
    efmuisoSequence = MenuSequence(flags, selAcc,
                                     HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
 
    return efmuisoSequence
 
 
@AccumulatorCache

muEFMSIsoSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFMSIsoSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 941 of file MuonMenuSequences.py.

def muEFMSIsoSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, True, is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
    efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
                                                      name = 'EFMuMSisoHypoAlg',
                                                      EFMuonsName = sequenceOut)
 
    selAcc.addHypoAlgo(efmuisoHypo)
    
    efmuisoSequence = MenuSequence(flags, selAcc,
                                     HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
 
    return efmuisoSequence
 
 

muEFSAAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muEFSAAlgSequenceCfg	(		flags,
			is_probe_leg = False
	)

EFSA step ###.

Definition at line 395 of file MuonMenuSequences.py.

def muEFSAAlgSequenceCfg(flags, is_probe_leg=False):
 
    selAccMS = SelectionCA('EFMuMSSel_RoI', isProbe=is_probe_leg)
    
    viewName="EFMuMSReco_RoI"
    ViewCreatorFetchFromViewROITool=CompFactory.ViewCreatorFetchFromViewROITool
    #temporarily using different view names until L2 SA sequence is migrated to CA
    roiTool         = ViewCreatorFetchFromViewROITool(RoisWriteHandleKey="HLT_Roi_L2SAMuonForEF", InViewRoIs = "forMS", ViewToFetchFrom = "L2MuFastRecoViews")
    requireParentView = True
 
    recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView, isProbe=is_probe_leg)
 
 
    #Clone and replace offline flags so we can set muon trigger specific values
    muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
    from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
    #Run decoding again since we are using updated RoIs
    recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=viewName+"RoIs"))
    
    muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags, viewName+'RoIs', 'RoI' )
    recoMS.mergeReco(muEFSARecoSequenceAcc)
 
    from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
    prefetch=ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
    selAccMS.mergeReco(recoMS, robPrefetchCA=prefetch)
 
    return (selAccMS, sequenceOut)
 
 
@AccumulatorCache

muEFSAFSAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muEFSAFSAlgSequenceCfg

(

flags

)

EF SA full scan ###.

Definition at line 667 of file MuonMenuSequences.py.

def muEFSAFSAlgSequenceCfg(flags):
 
    selAccMS = SelectionCA('EFMuMSSel_FS')
    
    viewName="EFMuMSReco_FS"
    ViewCreatorFSROITool=CompFactory.ViewCreatorFSROITool
    roiTool         = ViewCreatorFSROITool(RoisWriteHandleKey="MuonFS_RoIs")
    requireParentView = False
                                                         
    recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView)
 
 
    #Clone and replace offline flags so we can set muon trigger specific values
    muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
    from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
    recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=recoMS.name+"RoIs"))
    
    muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags, recoMS.name+'RoIs', 'FS' )
    recoMS.mergeReco(muEFSARecoSequenceAcc)
 
    selAccMS.mergeReco(recoMS)
 
    return (selAccMS, sequenceOut)
 
 
@AccumulatorCache

muEFSAFSSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFSAFSSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 693 of file MuonMenuSequences.py.

def muEFSAFSSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFSAFSAlgSequenceCfg(flags)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromName
 
    efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
                              name = 'TrigMuonEFMSonlyHypo_FS',
                              MuonDecisions = sequenceOut,
                              IncludeSAmuons=True)
 
    selAcc.addHypoAlgo(efmuMSHypo)
    
    efmuMSSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFMSonlyHypoToolFromName)
 
 
    return efmuMSSequence
 
 

muEFSASequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muEFSASequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 425 of file MuonMenuSequences.py.

def muEFSASequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muEFSAAlgSequenceCfg(flags, is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromDict
    efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
                              name = 'TrigMuonEFMSonlyHypo_RoI',
                              MuonDecisions = sequenceOut,
                              IncludeSAmuons=True)
 
    selAcc.addHypoAlgo(efmuMSHypo)
    
    efmuMSSequence = MenuSequence(flags, selAcc,
                                    HypoToolGen = TrigMuonEFMSonlyHypoToolFromDict)
 
 
    return efmuMSSequence
 
 

muFastAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muFastAlgSequenceCfg	(		flags,
			selCAName = "",
			is_probe_leg = False
	)

************* Step1 ************* ### --------------------------------------------------—#

Definition at line 24 of file MuonMenuSequences.py.

def muFastAlgSequenceCfg(flags, selCAName="", is_probe_leg=False):
 
    selAccSA = SelectionCA('L2MuFastSel'+selCAName, isProbe=is_probe_leg)
    
    viewName="L2MuFastReco"
 
    recoSA = InViewRecoCA(name=viewName, isProbe=is_probe_leg)
 
    
    muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
    from .MuonRecoSequences import muFastRecoSequenceCfg, muonDecodeCfg
    recoSA.mergeReco(muonDecodeCfg(muonflags,RoIs=viewName+'RoIs'))
 
    extraLoads = []
    from TriggerMenuMT.HLT.Config.ControlFlow.MenuComponentsNaming import CFNaming
    filterInput = [ CFNaming.inputMakerOutName('IM_'+viewName) ]
    for decision in filterInput:
      extraLoads += [( 'xAOD::TrigCompositeContainer', 'StoreGateSvc+%s' % decision )]
 
    from .MuonRecoSequences  import  isCosmic
    acc = ComponentAccumulator()
    seql2sa = seqAND("L2MuonSASeq{}".format("_probe" if is_probe_leg else ""))
    acc.addSequence(seql2sa)
    muFastRecoSeq = muFastRecoSequenceCfg( muonflags, viewName+'RoIs', doFullScanID= isCosmic(flags), extraLoads=extraLoads )
    sequenceOut = muNames.L2SAName
    acc.merge(muFastRecoSeq, sequenceName=seql2sa.name)
 
    
    seqFilter = seqAND("L2MuonMTSeq{}".format("_probe" if is_probe_leg else ""))
    acc.addSequence(seqFilter)
    from TrigMuonEF.TrigMuonEFConfig import MuonChainFilterAlgCfg
    MultiTrackChains = getMultiTrackChainNames()
    MultiTrackChainFilter = MuonChainFilterAlgCfg(muonflags, "SAFilterMultiTrackChains", ChainsToFilter = MultiTrackChains, 
                                                  InputDecisions = filterInput,
                                                  L2MuFastContainer = muNames.L2SAName+"l2mtmode", 
                                                  L2MuCombContainer = muNames.L2CBName+"l2mtmode",
                                                  WriteMuFast = True, NotGate = True)
 
    acc.merge(MultiTrackChainFilter, sequenceName=seqFilter.name)
    muFastl2mtRecoSeq = muFastRecoSequenceCfg( muonflags, viewName+'RoIs', doFullScanID= isCosmic(flags), l2mtmode=True )
    acc.merge(muFastl2mtRecoSeq, sequenceName=seqFilter.name)
    recoSA.mergeReco(acc)
 
    from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
    robPrefetch = ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
 
    selAccSA.mergeReco(recoSA, robPrefetchCA=robPrefetch)
 
 
    return (selAccSA, sequenceOut)
 
 

muFastCalibAlgSequenceCfg()

def python.HLT.Muon.MuonMenuSequences.muFastCalibAlgSequenceCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 77 of file MuonMenuSequences.py.

def muFastCalibAlgSequenceCfg(flags, is_probe_leg=False):
 
    selAccSA = SelectionCA('L2MuFastCalibSel', isProbe=is_probe_leg)
    
    viewName="L2MuFastCalibReco"
 
    recoSA = InViewRecoCA(name=viewName, isProbe=is_probe_leg)
 
    
    muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
    from .MuonRecoSequences import muFastRecoSequenceCfg, muonDecodeCfg
    recoSA.mergeReco(muonDecodeCfg(muonflags,RoIs=viewName+'RoIs'))
 
    from .MuonRecoSequences  import  isCosmic
    muFastRecoSeq = muFastRecoSequenceCfg( muonflags, viewName+'RoIs', doFullScanID= isCosmic(flags), calib=True )
    sequenceOut = muNames.L2SAName+"Calib"
    recoSA.mergeReco(muFastRecoSeq)
 
 
    from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
    robPrefetchAlg = ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
    selAccSA.mergeReco(recoSA, robPrefetchCA=robPrefetchAlg)
 
    return (selAccSA, sequenceOut)
 
 
@AccumulatorCache

muFastCalibSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muFastCalibSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 124 of file MuonMenuSequences.py.

def muFastCalibSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muFastCalibAlgSequenceCfg(flags, is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
    l2saHypo = TrigMufastHypoAlgCfg( flags,
                                     name = 'TrigL2MufastCalibHypoAlg',
                                     MuonL2SAInfoFromMuFastAlg = sequenceOut)
 
    selAcc.addHypoAlgo(l2saHypo)
    
    l2saSequence = MenuSequence(flags, selAcc,
                                  HypoToolGen = TrigMufastHypoToolFromDict)
 
 
    return l2saSequence
 
 
@AccumulatorCache

muFastSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muFastSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 105 of file MuonMenuSequences.py.

def muFastSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muFastAlgSequenceCfg(flags, "", is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
    l2saHypo = TrigMufastHypoAlgCfg( flags,
                                     name = 'TrigL2MufastHypoAlg',
                                     MuonL2SAInfoFromMuFastAlg = sequenceOut)
 
    selAcc.addHypoAlgo(l2saHypo)
    
    l2saSequence = MenuSequence(flags, selAcc,
                                  HypoToolGen = TrigMufastHypoToolFromDict)
 
 
    return l2saSequence
 
 
@AccumulatorCache

mul2IOOvlpRmSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.mul2IOOvlpRmSequenceGenCfg	(		flags,
			is_probe_leg = False,
			trackingMode = "FTF"
	)

Definition at line 279 of file MuonMenuSequences.py.

def mul2IOOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
 
 
    (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "IO", is_probe_leg, trackingMode = trackingMode)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, Trigl2IOHypoToolwORFromDict
    l2cbHypo = TrigmuCombHypoAlgCfg( flags,
                                     name = 'TrigL2MuCBIOHypoAlg',
                                     MuonL2CBInfoFromMuCombAlg = sequenceOut+"IOmode",
                                     )
 
    selAcc.addHypoAlgo(l2cbHypo)
    
    l2cbSequence = MenuSequence(flags, selAcc,
                                  HypoToolGen = Trigl2IOHypoToolwORFromDict)
 
    return l2cbSequence
 
 

mul2mtCBOvlpRmSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.mul2mtCBOvlpRmSequenceGenCfg	(		flags,
			is_probe_leg = False,
			trackingMode = "FTF"
	)

Definition at line 373 of file MuonMenuSequences.py.

def mul2mtCBOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
 
    (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "mt", is_probe_leg, trackingMode = trackingMode)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, Trigl2mtCBHypoToolwORFromDict
    l2cbHypo = TrigmuCombHypoAlgCfg( flags,
                                     name = 'TrigL2mtMuCBHypoAlg',
                                     MuonL2CBInfoFromMuCombAlg = sequenceOut+"l2mtmode",
                                    )
 
    selAcc.addHypoAlgo(l2cbHypo)
    
    l2cbSequence = MenuSequence(flags, selAcc,
                                  HypoToolGen = Trigl2mtCBHypoToolwORFromDict)
 
    return l2cbSequence
 
 

mul2mtSAOvlpRmSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.mul2mtSAOvlpRmSequenceGenCfg	(		flags,
			is_probe_leg = False
	)

Definition at line 143 of file MuonMenuSequences.py.

def mul2mtSAOvlpRmSequenceGenCfg(flags, is_probe_leg=False):
 
    (selAcc, sequenceOut) = muFastAlgSequenceCfg(flags, "mt", is_probe_leg)
 
    from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
    l2saHypo = TrigMufastHypoAlgCfg( flags,
                                     name = 'TrigL2mtMufastHypoAlg',
                                     MuonL2SAInfoFromMuFastAlg = muNames.L2SAName+"l2mtmode")
 
    selAcc.addHypoAlgo(l2saHypo)
    
    l2saSequence = MenuSequence(flags, selAcc,
                                  HypoToolGen = TrigMufastHypoToolFromDict)
 
 
    return l2saSequence
 
 
 
#-----------------------------------------------------#

muRoiClusterSequenceGenCfg()

def python.HLT.Muon.MuonMenuSequences.muRoiClusterSequenceGenCfg

(

flags

)

Muon RoI Cluster Trigger for MS LLP Searches ##.

Definition at line 962 of file MuonMenuSequences.py.

def muRoiClusterSequenceGenCfg(flags):
 
    from TrigLongLivedParticles.TrigLongLivedParticlesConfig import MuonClusterConfig
    from TrigLongLivedParticlesHypo.TrigLongLivedParticlesHypoConfig import MuonClusterHypoAlgConfig, TrigLongLivedParticlesHypoToolFromDict
 
    selAcc = SelectionCA('muRoIClusterSel')
    
    viewName="MuRoIClusReco"
    viewcreator         = CompFactory.ViewCreatorInitialROITool
    roiTool = viewcreator()
                                                         
    recoRoICluster = InEventRecoCA(name=viewName, RoITool = roiTool, mergeUsingFeature = False, RoIs = 'HLT_muVtxCluster_RoIs')
    recoRoICluster.mergeReco(MuonClusterConfig(flags, 'muvtxMuonCluster'))
    selAcc.mergeReco(recoRoICluster)
 
 
    hypoAlg = MuonClusterHypoAlgConfig( flags,
                              name = 'MuRoiClusterHypoAlg')
 
    selAcc.addHypoAlgo(hypoAlg)
    
    muRoIClusterSequence = MenuSequence(flags, selAcc,
                                          HypoToolGen = TrigLongLivedParticlesHypoToolFromDict)
 
    return muRoIClusterSequence
 
 
 

Variable Documentation

log

python.HLT.Muon.MuonMenuSequences.log

Definition at line 12 of file MuonMenuSequences.py.

muNames

python.HLT.Muon.MuonMenuSequences.muNames

Definition at line 16 of file MuonMenuSequences.py.

muNamesFS

python.HLT.Muon.MuonMenuSequences.muNamesFS

Definition at line 18 of file MuonMenuSequences.py.

muNamesLRT

python.HLT.Muon.MuonMenuSequences.muNamesLRT

Definition at line 17 of file MuonMenuSequences.py.