ATLAS Offline Software
Loading...
Searching...
No Matches
Functions | Variables
python.HLT.Muon.MuonMenuSequences Namespace Reference

Functions

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

Variables

 log = logging.getLogger(__name__)
 muNames = muonNames().getNames('RoI')
 muNamesLRT = muonNames().getNames('LRT')
 muNamesFS = muonNames().getNames('FS')

Function Documentation

◆ efLateMuAlgSequenceCfg()

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

Definition at line 857 of file MuonMenuSequences.py.

857def efLateMuAlgSequenceCfg(flags, is_probe_leg=False):
858
859 from .MuonRecoSequences import muEFInsideOutRecoSequenceCfg, muonDecodeCfg, muonIDFastTrackingSequenceCfg
860 selAcc = SelectionCA('EFLateMuAlg', isProbe=is_probe_leg)
861
862 viewName = "EFLateMuReco"
863 viewcreator = CompFactory.ViewCreatorNamedROITool
864 roiTool = viewcreator(ROILinkName="feature")
865
866 recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView=True, mergeUsingFeature=True, isProbe=is_probe_leg)
867
868
869 #Clone and replace offline flags so we can set muon trigger specific values
870 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
871 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
872 #decode data in these RoIs
873 recoLateMu.mergeReco(muonDecodeCfg(muonflags,RoIs=recoLateMu.name+"RoIs"))
874 #ID fast tracking
875 recoLateMu.mergeReco(muonIDFastTrackingSequenceCfg(flags, recoLateMu.name+"RoIs","muonLate" ))
876 #inside-out reco sequence
877 recoLateMu.mergeReco(muEFInsideOutRecoSequenceCfg(muonflagsCB, recoLateMu.name+"RoIs", "LateMu", ''))
878 sequenceOut = muNames.EFCBInOutName+'_Late'
879
880
881 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
882 robPrefetchAlg = ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName)
883 selAcc.mergeReco(recoLateMu, robPrefetchCA = robPrefetchAlg)
884
885 return (selAcc, sequenceOut)
886
887
888@AccumulatorCache

◆ efLateMuRoIAlgSequenceCfg()

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

Definition at line 818 of file MuonMenuSequences.py.

818def efLateMuRoIAlgSequenceCfg(flags, is_probe_leg=False):
819
820 selAcc = SelectionCA('EFLateMuSel', isProbe=is_probe_leg)
821
822 viewName = "EFLateMuRoIReco"
823 viewcreator = CompFactory.ViewCreatorInitialROITool
824 roiTool = viewcreator()
825
826 recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg)
827
828 from .MuonRecoSequences import efLateMuRoISequenceCfg
829
830 #Get Late Muon RoIs
831 efLateMuRoIAcc, sequenceOut = efLateMuRoISequenceCfg(flags)
832 recoLateMu.mergeReco(efLateMuRoIAcc)
833
834 selAcc.mergeReco(recoLateMu)
835 return (selAcc, sequenceOut)
836
837
838@AccumulatorCache

◆ efLateMuRoISequenceGenCfg()

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

Definition at line 839 of file MuonMenuSequences.py.

839def efLateMuRoISequenceGenCfg(flags, is_probe_leg=False):
840
841 (selAcc, sequenceOut) = efLateMuRoIAlgSequenceCfg(flags, is_probe_leg)
842
843 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonLateMuRoIHypoAlgCfg, TrigMuonLateMuRoIHypoToolFromDict
844 latemuHypo = TrigMuonLateMuRoIHypoAlgCfg( flags,
845 name = 'TrigMuonLateMuRoIHypoAlg',
846 LateRoIs = sequenceOut)
847
848 selAcc.addHypoAlgo(latemuHypo)
849
850 latemuRoISequence = MenuSequence(flags, selAcc,
851 HypoToolGen = TrigMuonLateMuRoIHypoToolFromDict)
852
853
854 return latemuRoISequence
855
856

◆ efLateMuSequenceGenCfg()

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

Definition at line 889 of file MuonMenuSequences.py.

889def efLateMuSequenceGenCfg(flags, is_probe_leg=False):
890
891 (selAcc, sequenceOut) = efLateMuAlgSequenceCfg(flags, is_probe_leg=False)
892
893 # setup EFCB hypo
894 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg
895 trigMuonEFLateHypo = TrigMuonEFHypoAlgCfg( "TrigMuonEFCombinerLateMuHypoAlg", MuonDecisions = sequenceOut )
896
897 selAcc.addHypoAlgo(trigMuonEFLateHypo)
898 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFCombinerHypoToolFromDict
899
900 return MenuSequence(flags, selAcc,
901 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict )
902
903
904

◆ getBphysChainNames()

python.HLT.Muon.MuonMenuSequences.getBphysChainNames ( )

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

Definition at line 1019 of file MuonMenuSequences.py.

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

◆ getInsideOutMuonChainNames()

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 1030 of file MuonMenuSequences.py.

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

◆ getMultiTrackChainNames()

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 1042 of file MuonMenuSequences.py.

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

◆ muCombAlgSequenceCfg()

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

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

Definition at line 166 of file MuonMenuSequences.py.

166def muCombAlgSequenceCfg(flags, selCAName="", is_probe_leg=False, trackingMode = "FTF"):
167
169 from .MuonRecoSequences import muFastRecoSequenceCfg, muCombRecoSequenceCfg, muonIDFastTrackingSequenceCfg, muonIDCosmicTrackingSequenceCfg, isCosmic
170
171 selAccCB = SelectionCA('L2MuCombSel'+selCAName, isProbe=is_probe_leg)
172
173 viewName="Cosmic" if isCosmic(flags) else "L2MuCombReco"
174
175 ViewCreatorFetchFromViewROITool=CompFactory.ViewCreatorFetchFromViewROITool
176 #temporarily using different view names until L2 SA sequence is migrated to CA
177 roiTool = ViewCreatorFetchFromViewROITool(RoisWriteHandleKey="HLT_Roi_L2SAMuon", InViewRoIs = muNames.L2forIDName)
178 requireParentView = True
179
180 recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView, isProbe=is_probe_leg)
181 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
182
183
184 sequenceOut = muNames.L2CBName
185
186 acc = ComponentAccumulator()
187 from TrigMuonEF.TrigMuonEFConfig import MuonChainFilterAlgCfg
188
189
190 from TriggerMenuMT.HLT.Config.ControlFlow.MenuComponentsNaming import CFNaming
191 filterInput = [ CFNaming.inputMakerOutName('IM_'+viewName) ]
192 extraLoads = []
193 for decision in filterInput:
194 extraLoads += [( 'xAOD::TrigCompositeContainer' , 'StoreGateSvc+%s' % decision )]
195
196 if isCosmic(flags):
197 recoCB.mergeReco(muonIDCosmicTrackingSequenceCfg( flags, viewName+"RoIs" , "cosmics", extraLoads, extraLoads ))
198 else:
199 recoCB.mergeReco(muonIDFastTrackingSequenceCfg(flags, viewName+"RoIs", "muon", extraLoads, extraLoads, trackingMode = trackingMode ))
200
201 # for nominal muComb
202 seql2cb = seqAND("l2muCombFilterSequence{}".format("_probe" if is_probe_leg else ""))
203 acc.addSequence(seql2cb)
204
205 #Filter algorithm to run muComb only if non-Bphysics muon chains are active
206 muonChainFilter = MuonChainFilterAlgCfg(muonflags, "FilterBphysChains", ChainsToFilter = getBphysChainNames(),
207 InputDecisions = filterInput,
208 L2MuCombContainer = sequenceOut,
209 WriteMuComb = True, WriteMuFast=False)
210 acc.merge(muonChainFilter, sequenceName=seql2cb.name)
211
212
213
214 acc.merge(muCombRecoSequenceCfg(flags, viewName+"RoIs", "FTF", l2mtmode=False, l2CBname = sequenceOut ), sequenceName=seql2cb.name)
215
216 # for L2 multi-track SA
217 MultiTrackChains = getMultiTrackChainNames()
218 MultiTrackChainFilter = MuonChainFilterAlgCfg(muonflags, "CBFilterMultiTrackChains", ChainsToFilter = MultiTrackChains,
219 InputDecisions = filterInput,
220 L2MuFastContainer = muNames.L2SAName+"l2mtmode",
221 L2MuCombContainer = muNames.L2CBName+"l2mtmode",
222 WriteMuComb = True, NotGate = True)
223
224
225 seql2cbmt = seqAND("l2mtmuCombFilterSequence{}".format("_probe" if is_probe_leg else ""))
226 acc.addSequence(seql2cbmt)
227 acc.merge(MultiTrackChainFilter, sequenceName=seql2cbmt.name)
228
229
230 sequenceOutL2mtCB = muNames.L2CBName+"l2mtmode"
231 acc.merge(muCombRecoSequenceCfg(flags, viewName+"RoIs", "FTF", l2mtmode=True, l2CBname = sequenceOutL2mtCB ), sequenceName=seql2cbmt.name)
232
233
234
235 # for Inside-out L2SA
236 seql2iocb = seqAND("l2muFastIOFilterSequence{}".format("_probe" if is_probe_leg else ""))
237 acc.addSequence(seql2iocb)
238
239 from .MuonRecoSequences import isCosmic
240 sequenceOutL2SAIO = muNames.L2SAName+"IOmode"
241 insideoutMuonChainFilter = MuonChainFilterAlgCfg("FilterInsideOutMuonChains", ChainsToFilter = getInsideOutMuonChainNames(),
242 InputDecisions = filterInput,
243 L2MuFastContainer = sequenceOutL2SAIO, L2MuCombContainer = muNames.L2CBName+"IOmode",
244 WriteMuFast = True, WriteMuComb = True, NotGate=True)
245
246 acc.merge(insideoutMuonChainFilter, sequenceName=seql2iocb.name)
247 acc.merge(muFastRecoSequenceCfg(muonflags, viewName+"RoIs", doFullScanID=isCosmic(flags) , InsideOutMode=True), sequenceName=seql2iocb.name)
248 recoCB.mergeReco(acc)
249
250
251 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si
252 robPrefetchAlg = ROBPrefetchingAlgCfg_Si(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
253 selAccCB.mergeReco(recoCB, robPrefetchCA=robPrefetchAlg)
254
255 return (selAccCB, sequenceOut)
256
257
258@AccumulatorCache
ViewCreatorFetchFromViewROITool
Allows a Decision Object to process the current Step over an ROI which was created during a previous ...
Definition ViewCreatorFetchFromViewROITool.h:26

◆ muCombLRTAlgSequenceCfg()

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

Definition at line 298 of file MuonMenuSequences.py.

298def muCombLRTAlgSequenceCfg(flags, is_probe_leg=False):
299
300 selAcc = SelectionCA('l2muCombLRT', isProbe=is_probe_leg)
301
302 viewName="l2muCombLRT"
303 ViewCreatorCenteredOnIParticleTool=CompFactory.ViewCreatorCentredOnIParticleROITool
304
305 roiTool = ViewCreatorCenteredOnIParticleTool(RoisWriteHandleKey = recordable("HLT_Roi_L2SAMuon_LRT"),
306 RoIZedWidth=flags.Trigger.InDetTracking.muonLRT.zedHalfWidth,
307 RoIEtaWidth=flags.Trigger.InDetTracking.muonLRT.etaHalfWidth,
308 RoIPhiWidth=flags.Trigger.InDetTracking.muonLRT.phiHalfWidth,
309 UseZedPosition=False)
310 requireParentView = True
311
312 recol2cb = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView, isProbe=is_probe_leg)
313
314
315 from .MuonRecoSequences import muCombRecoSequenceCfg, muonIDFastTrackingSequenceCfg
316 sequenceOut = muNamesLRT.L2CBName
317 recol2cb.mergeReco(muCombRecoSequenceCfg(flags, viewName+"RoIs", "FTF_LRT", l2CBname = sequenceOut ))
318
319 extraLoads = []
320
321 recol2cb.mergeReco(muonIDFastTrackingSequenceCfg(flags, viewName+"RoIs" , "muonLRT", extraLoads, doLRT=True ))
322
323
324 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si
325 robPrefetchAlg = ROBPrefetchingAlgCfg_Si(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
326 selAcc.mergeReco(recol2cb, robPrefetchAlg)
327
328
329 return (selAcc, sequenceOut)
330
331
332@AccumulatorCache

◆ muCombLRTSequenceGenCfg()

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

Definition at line 333 of file MuonMenuSequences.py.

333def muCombLRTSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
334
335 (selAcc, sequenceOut) = muCombLRTAlgSequenceCfg(flags, is_probe_leg)
336
337 from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, TrigmuCombHypoToolFromDict
338 l2cbHypo = TrigmuCombHypoAlgCfg( flags,
339 name = 'TrigL2MuCBLRTHypoAlg',
340 MuonL2CBInfoFromMuCombAlg = sequenceOut,
341 RoILinkName = "l2lrtroi",
342 )
343
344 selAcc.addHypoAlgo(l2cbHypo)
345
346 l2cbSequence = MenuSequence(flags, selAcc,
347 HypoToolGen = TrigmuCombHypoToolFromDict)
348
349
350 return l2cbSequence
351
352
353@AccumulatorCache

◆ muCombOvlpRmSequenceGenCfg()

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

Definition at line 354 of file MuonMenuSequences.py.

354def muCombOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
355
356 (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "", is_probe_leg, trackingMode = trackingMode)
357
358 from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, TrigmuCombHypoToolwORFromDict
359 l2cbHypo = TrigmuCombHypoAlgCfg( flags,
360 name = 'TrigL2MuCBHypoAlg',
361 MuonL2CBInfoFromMuCombAlg = sequenceOut,
362 )
363
364 selAcc.addHypoAlgo(l2cbHypo)
365
366 l2cbSequence = MenuSequence(flags, selAcc,
367 HypoToolGen = TrigmuCombHypoToolwORFromDict)
368
369 return l2cbSequence
370
371
372@AccumulatorCache

◆ muCombSequenceGenCfg()

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

Definition at line 259 of file MuonMenuSequences.py.

259def muCombSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
260
261 (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "", is_probe_leg, trackingMode = trackingMode)
262
263 from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, TrigmuCombHypoToolFromDict
264 l2cbHypo = TrigmuCombHypoAlgCfg( flags,
265 name = 'TrigL2MuCBHypoAlg',
266 MuonL2CBInfoFromMuCombAlg = sequenceOut,
267 )
268
269 selAcc.addHypoAlgo(l2cbHypo)
270
271 l2cbSequence = MenuSequence(flags, selAcc,
272 HypoToolGen = TrigmuCombHypoToolFromDict)
273
274
275 return l2cbSequence
276
277
278@AccumulatorCache

◆ muEFCBAlgSequenceCfg()

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

EFCB seq ###.

Definition at line 448 of file MuonMenuSequences.py.

448def muEFCBAlgSequenceCfg(flags, suffix, selCAName='', is_probe_leg=False):
449
450 from .MuonRecoSequences import isCosmic
451 selAccCB = SelectionCA('EFMuCBSel_RoI'+selCAName+suffix, isProbe=is_probe_leg)
452
453 viewName="EFMuCBReco_RoI"+suffix if not isCosmic(flags) else "CosmicEFCB"
454 ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
455 #temporarily using different view names until L2 SA sequence is migrated to CA
456 roiTool = ViewCreatorTool(ROILinkName="l2cbroi")
457
458 recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg, mergeUsingFeature=True)
459
460 #By default the EFCB sequence will run both outside-in and
461 #(if zero muons are found) inside-out reconstruction
462 from TrigMuonEF.TrigMuonEFConfig import MuonFilterAlgCfg, MergeEFMuonsAlgCfg
463 from .MuonRecoSequences import muEFCBRecoSequenceCfg, muEFInsideOutRecoSequenceCfg
464
465 acc = ComponentAccumulator()
466 seqmerge = seqAND("muonCBInsideOutMergingSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
467 acc.addSequence(seqmerge)
468
469 #outside-in reco sequence
470 acc2 = ComponentAccumulator()
471 seqreco = parOR("muonEFCBandInsideOutRecoSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
472 acc2.addSequence(seqreco)
473 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
474 acc2.merge(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "RoI", suffix ), sequenceName=seqreco.name)
475 sequenceOutCB = muNames.EFCBOutInName+suffix
476
477 #Algorithm to filter events with no muons
478 acc3 = ComponentAccumulator()
479 seqfilter = seqAND("muonEFInsideOutSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
480 acc3.addSequence(seqfilter)
481 muonFilter = MuonFilterAlgCfg(flags, name="FilterZeroMuons"+suffix, MuonContainerLocation=sequenceOutCB)
482 acc3.merge(muonFilter, sequenceName=seqfilter.name)
483
484 #inside-out reco sequence - runs only if filter is passed
485 acc4 = ComponentAccumulator()
486 seqio = parOR("efmuInsideOutViewNode_RoI{}{}".format(suffix, "_probe" if is_probe_leg else ""))
487 acc4.addSequence(seqio)
488 acc4.merge(muEFInsideOutRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "RoI", suffix), sequenceName=seqio.name+suffix)
489 sequenceOutInsideOut = muNames.EFCBInOutName+suffix
490
491 acc3.merge(acc4, sequenceName=seqfilter.name)
492 acc2.merge(acc3, sequenceName=seqreco.name)
493 acc.merge(acc2, sequenceName=seqmerge.name)
494 #Merge muon containers from outside-in and inside-out reco
495 if suffix != '':
496 mergedMuonOutputLocation = recordable(muNames.EFCBName+'_'+suffix)
497 else:
498 mergedMuonOutputLocation = muNames.EFCBName
499 mergeMuons = MergeEFMuonsAlgCfg(flags, name="MergeEFMuons"+suffix, MuonCBContainerLocation=sequenceOutCB,
500 MuonInsideOutContainerLocation=sequenceOutInsideOut, MuonOutputLocation=mergedMuonOutputLocation)
501
502 acc.merge(mergeMuons, sequenceName=seqmerge.name)
503 recoCB.mergeReco(acc)
504 selAccCB.mergeReco(recoCB)
505
506 return (selAccCB, muNames.EFCBName)
507
508
509@AccumulatorCache

◆ muEFCBFSAlgSequenceCfg()

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

EF CB full scan ###.

Definition at line 740 of file MuonMenuSequences.py.

740def muEFCBFSAlgSequenceCfg(flags, is_probe_leg=False):
741
742 selAccCB = SelectionCA('EFMuCBSel_FS', isProbe=is_probe_leg)
743
744 viewName="EFMuCBReco_FS"
745 #temporarily using different view names until L2 SA sequence is migrated to CA
746 roiTool = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = "MuonCandidates_FS_ROIs")
747
748 recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg, mergeUsingFeature=True,
749 PlaceMuonInView=True, InViewMuons = "InViewMuons", InViewMuonCandidates = "MuonCandidates_FS")
750
751
752 from TrigMuonEF.TrigMuonEFConfig import MuonFilterAlgCfg, MergeEFMuonsAlgCfg
753 from .MuonRecoSequences import muEFCBRecoSequenceCfg, muEFInsideOutRecoSequenceCfg
754 #outside-in reco sequence
755 acc = ComponentAccumulator()
756 seqmerge = seqAND("muonCBInsideOutMergingSequenceEFCBFS{}".format("_probe" if is_probe_leg else ""))
757 acc.addSequence(seqmerge)
758
759 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
760 acc2 = ComponentAccumulator()
761 seqreco = parOR("muonEFCBFSInsideOutRecoSequence{}".format("_probe" if is_probe_leg else ""))
762 acc2.addSequence(seqreco)
763
764 acc2.merge(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "FS", ''), sequenceName=seqreco.name)
765 sequenceOutCB = muNamesFS.EFCBOutInName
766
767 #Alg fitltering for no muon events
768 muonFilter = MuonFilterAlgCfg(flags, name="FilterZeroMuonsEFCBFS", MuonContainerLocation = sequenceOutCB)
769
770 acc3 = ComponentAccumulator()
771 seqfilt = seqAND("muonEFCBFSInsideOutSequence{}".format("_probe" if is_probe_leg else ""))
772 acc3.addSequence(seqfilt)
773 acc3.merge(muonFilter, sequenceName=seqfilt.name)
774
775
776 #If filter passed
777 acc4 = ComponentAccumulator()
778 seqio = parOR("efmuInsideOutViewNode_FS{}".format("_probe" if is_probe_leg else ""))
779 acc4.addSequence(seqio)
780
781 muonEFInsideOutRecoAlgSequence = muEFInsideOutRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "FS", '' )
782 acc4.merge(muonEFInsideOutRecoAlgSequence, sequenceName=seqio.name)
783 acc3.merge(acc4, sequenceName=seqfilt.name)
784 acc2.merge(acc3, sequenceName=seqreco.name)
785 acc.merge(acc2, sequenceName=seqmerge.name)
786 sequenceOutInsideOut = muNamesFS.EFCBInOutName
787
788 #Merge muon containers from O-I and I-O reco
789 mergeMuons = MergeEFMuonsAlgCfg(flags, name="MergeEFCBFSMuons", MuonCBContainerLocation = sequenceOutCB,
790 MuonInsideOutContainerLocation = sequenceOutInsideOut, MuonOutputLocation = muNamesFS.EFCBName)
791 acc.merge(mergeMuons, sequenceName=seqmerge.name)
792 recoCB.mergeReco(acc)
793
794 sequenceOut = muNamesFS.EFCBName
795 selAccCB.mergeReco(recoCB)
796
797 return (selAccCB, sequenceOut)
798
799
800@AccumulatorCache

◆ muEFCBFSSequenceGenCfg()

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

Definition at line 801 of file MuonMenuSequences.py.

801def muEFCBFSSequenceGenCfg(flags, is_probe_leg=False):
802
803 (selAcc, sequenceOut) = muEFCBFSAlgSequenceCfg(flags, is_probe_leg)
804
805 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromName
806 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
807 name = 'TrigMuonEFFSCombinerHypoAlg',
808 MuonDecisions = sequenceOut)
809
810 selAcc.addHypoAlgo(efmuCBHypo)
811
812 efmuCBSequence = MenuSequence(flags, selAcc,
813 HypoToolGen = TrigMuonEFCombinerHypoToolFromName)
814
815 return efmuCBSequence
816
817

◆ muEFCBIDperfSequenceGenCfg()

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

Definition at line 586 of file MuonMenuSequences.py.

586def muEFCBIDperfSequenceGenCfg(flags, is_probe_leg=False):
587
588 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idperf', is_probe_leg)
589
590 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
591 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
592 name = 'TrigMuonEFCombinerIDperfHypoAlg',
593 IncludeSAmuons=True,
594 MuonDecisions = sequenceOut,
595 MapToPreviousDecisions=True)
596
597 selAcc.addHypoAlgo(efmuCBHypo)
598
599 efmuCBSequence = MenuSequence(flags, selAcc,
600 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
601
602 return efmuCBSequence
603
604
605@AccumulatorCache

◆ muEFCBidReuseSequenceGenCfg()

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

Definition at line 567 of file MuonMenuSequences.py.

567def muEFCBidReuseSequenceGenCfg(flags, is_probe_leg=False):
568
569 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, 'idReuse', '', is_probe_leg)
570
571 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
572 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
573 name = 'TrigMuonEFCombinerHypoAlgidReuse',
574 MuonDecisions = sequenceOut+'_idReuse',
575 MapToPreviousDecisions=True)
576
577 selAcc.addHypoAlgo(efmuCBHypo)
578
579 efmuCBSequence = MenuSequence(flags, selAcc,
580 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
581
582 return efmuCBSequence
583
584
585@AccumulatorCache

◆ muEFCBl2ioSequenceGenCfg()

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

Definition at line 529 of file MuonMenuSequences.py.

529def muEFCBl2ioSequenceGenCfg(flags, is_probe_leg=False):
530
531 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags,'IOmode', '', is_probe_leg)
532
533 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
534 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
535 name = 'TrigMuonEFCombinerHypoAlgIOmode',
536 MuonDecisions = sequenceOut+'_IOmode',
537 MapToPreviousDecisions=True)
538
539 selAcc.addHypoAlgo(efmuCBHypo)
540
541 efmuCBSequence = MenuSequence(flags, selAcc,
542 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
543
544 return efmuCBSequence
545
546
547@AccumulatorCache

◆ muEFCBl2mtSequenceGenCfg()

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

Definition at line 548 of file MuonMenuSequences.py.

548def muEFCBl2mtSequenceGenCfg(flags, is_probe_leg=False):
549
550 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags,'l2mtmode', '', is_probe_leg)
551
552 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
553 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
554 name = 'TrigMuonEFCombinerHypoAlgl2mtmode',
555 MuonDecisions = sequenceOut+'_l2mtmode',
556 MapToPreviousDecisions=True)
557
558 selAcc.addHypoAlgo(efmuCBHypo)
559
560 efmuCBSequence = MenuSequence(flags, selAcc,
561 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
562
563 return efmuCBSequence
564
565
566@AccumulatorCache

◆ muEFCBLRTAlgSequenceCfg()

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

Definition at line 623 of file MuonMenuSequences.py.

623def muEFCBLRTAlgSequenceCfg(flags, selCAName='', is_probe_leg=False):
624
625 selAccCB = SelectionCA('EFMuCBLRTSel'+selCAName, isProbe=is_probe_leg)
626
627 viewName="EFMuCBLRTReco"
628 ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
629 roiTool = ViewCreatorTool(ROILinkName="l2lrtroi")
630
631 recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, mergeUsingFeature=True, isProbe=is_probe_leg)
632
633 from .MuonRecoSequences import muEFCBRecoSequenceCfg
634
635 #outside-in reco sequence
636 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
637 recoCB.mergeReco(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "LRT", ''))
638 sequenceOut = muNamesLRT.EFCBName
639
640 selAccCB.mergeReco(recoCB)
641
642 return (selAccCB, sequenceOut)
643
644
645@AccumulatorCache

◆ muEFCBLRTIDperfSequenceGenCfg()

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

Definition at line 666 of file MuonMenuSequences.py.

666def muEFCBLRTIDperfSequenceGenCfg(flags, is_probe_leg=False):
667
668 (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, 'idperf', is_probe_leg)
669
670 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
671 efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
672 name = 'TrigMuonEFCombinerHypoAlgLRTIDPerf',
673 IncludeSAmuons=True,
674 MuonDecisions = sequenceOut,
675 MapToPreviousDecisions=True)
676
677
678 selAcc.addHypoAlgo(efmuCBLRTHypo)
679
680 efmuCBSequence = MenuSequence(flags, selAcc,
681 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
682
683 return efmuCBSequence
684
685

◆ muEFCBLRTSequenceGenCfg()

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

Definition at line 646 of file MuonMenuSequences.py.

646def muEFCBLRTSequenceGenCfg(flags, is_probe_leg=False):
647
648 (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, '', is_probe_leg)
649
650 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
651 efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
652 name = 'TrigMuonEFCombinerHypoAlgLRT',
653 MuonDecisions = sequenceOut,
654 MapToPreviousDecisions=True)
655
656
657 selAcc.addHypoAlgo(efmuCBLRTHypo)
658
659 efmuCBSequence = MenuSequence(flags, selAcc,
660 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
661
662 return efmuCBSequence
663
664
665@AccumulatorCache

◆ muEFCBSequenceGenCfg()

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

Definition at line 510 of file MuonMenuSequences.py.

510def muEFCBSequenceGenCfg(flags, is_probe_leg=False):
511
512 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', '', is_probe_leg)
513
514 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
515 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
516 name = 'TrigMuonEFCombinerHypoAlg',
517 MuonDecisions = sequenceOut,
518 MapToPreviousDecisions=True)
519
520 selAcc.addHypoAlgo(efmuCBHypo)
521
522 efmuCBSequence = MenuSequence(flags, selAcc,
523 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
524
525 return efmuCBSequence
526
527
528@AccumulatorCache

◆ muEFIDtpSequenceGenCfg()

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

Definition at line 606 of file MuonMenuSequences.py.

606def muEFIDtpSequenceGenCfg(flags, is_probe_leg=False):
607
608 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idtp', is_probe_leg)
609
610 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFIdtpHypoAlgCfg, TrigMuonEFIdtpHypoToolFromDict
611 efmuCBHypo = TrigMuonEFIdtpHypoAlgCfg( flags,
612 name = 'TrigMuonEFIdtpHypoAlg')
613
614
615 selAcc.addHypoAlgo(efmuCBHypo)
616
617 efmuCBSequence = MenuSequence(flags, selAcc,
618 HypoToolGen = TrigMuonEFIdtpHypoToolFromDict)
619
620 return efmuCBSequence
621
622

◆ muEFIsoAlgSequenceCfg()

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

efMuiso step ###

Definition at line 908 of file MuonMenuSequences.py.

908def muEFIsoAlgSequenceCfg(flags, doMSiso=False, is_probe_leg=False):
909 name = ""
910 if doMSiso:
911 name = "MS"
912
913
914 selAccIso = SelectionCA('EFMuIso'+name, isProbe=is_probe_leg)
915
916 viewName="EFMuIsoReco"+name
917 if doMSiso:
918 roisWriteHandleKey = "Roi_MuonIsoMS"
919 else:
920 roisWriteHandleKey = recordable("HLT_Roi_MuonIso")
921
922 roiTool = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = roisWriteHandleKey,
923 RoIEtaWidth=flags.Trigger.InDetTracking.muonIso.etaHalfWidth,
924 RoIPhiWidth=flags.Trigger.InDetTracking.muonIso.phiHalfWidth,
925 RoIZedWidth=flags.Trigger.InDetTracking.muonIso.zedHalfWidth)
926
927 recoIso = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg, mergeUsingFeature=True,
928 PlaceMuonInView=True, InViewMuons = "IsoViewMuons"+name, InViewMuonCandidates = "IsoMuonCandidates"+name)
929
930
931
932 from .MuonRecoSequences import efmuisoRecoSequenceCfg
933 sequenceOut = muNames.EFIsoMuonName+name
934 recoIso.mergeReco(efmuisoRecoSequenceCfg( flags, viewName+"RoIs", "IsoViewMuons"+name, doMSiso ))
935
936
937 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si
938 robPrefetchAlg = ROBPrefetchingAlgCfg_Si(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
939
940 selAccIso.mergeReco(recoIso, robPrefetchCA = robPrefetchAlg)
941
942 return (selAccIso, sequenceOut)
943
944
945@AccumulatorCache

◆ muEFIsoSequenceGenCfg()

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

Definition at line 946 of file MuonMenuSequences.py.

946def muEFIsoSequenceGenCfg(flags, is_probe_leg=False):
947
948 (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, False, is_probe_leg)
949
950 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
951 efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
952 name = 'EFMuisoHypoAlg',
953 EFMuonsName = sequenceOut)
954
955 selAcc.addHypoAlgo(efmuisoHypo)
956
957 efmuisoSequence = MenuSequence(flags, selAcc,
958 HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
959
960 return efmuisoSequence
961
962
963@AccumulatorCache

◆ muEFMSIsoSequenceGenCfg()

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

Definition at line 964 of file MuonMenuSequences.py.

964def muEFMSIsoSequenceGenCfg(flags, is_probe_leg=False):
965
966 (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, True, is_probe_leg)
967
968 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
969 efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
970 name = 'EFMuMSisoHypoAlg',
971 EFMuonsName = sequenceOut)
972
973 selAcc.addHypoAlgo(efmuisoHypo)
974
975 efmuisoSequence = MenuSequence(flags, selAcc,
976 HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
977
978 return efmuisoSequence
979
980

◆ muEFSAAlgSequenceCfg()

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

EFSA step ###.

Definition at line 395 of file MuonMenuSequences.py.

395def muEFSAAlgSequenceCfg(flags, is_probe_leg=False):
396
397 selAccMS = SelectionCA('EFMuMSSel_RoI', isProbe=is_probe_leg)
398
399 viewName="EFMuMSReco_RoI"
400 ViewCreatorFetchFromViewROITool=CompFactory.ViewCreatorFetchFromViewROITool
401 #temporarily using different view names until L2 SA sequence is migrated to CA
402 roiTool = ViewCreatorFetchFromViewROITool(RoisWriteHandleKey="HLT_Roi_L2SAMuonForEF", InViewRoIs = "forMS", ViewToFetchFrom = "L2MuFastRecoViews")
403 requireParentView = True
404
405 recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView, isProbe=is_probe_leg)
406
407
408 #Clone and replace offline flags so we can set muon trigger specific values
409 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
410 from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
411 #Run decoding again since we are using updated RoIs
412 recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=viewName+"RoIs"))
413
414 muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags, viewName+'RoIs', 'RoI' )
415 recoMS.mergeReco(muEFSARecoSequenceAcc)
416
417 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
418 prefetch=ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
419 selAccMS.mergeReco(recoMS, robPrefetchCA=prefetch)
420
421 return (selAccMS, sequenceOut)
422
423
424@AccumulatorCache

◆ muEFSAFSAlgSequenceCfg()

python.HLT.Muon.MuonMenuSequences.muEFSAFSAlgSequenceCfg ( flags)

EF SA full scan ###.

Definition at line 690 of file MuonMenuSequences.py.

690def muEFSAFSAlgSequenceCfg(flags):
691
692 selAccMS = SelectionCA('EFMuMSSel_FS')
693
694 viewName="EFMuMSReco_FS"
695 ViewCreatorFSROITool=CompFactory.ViewCreatorFSROITool
696 roiTool = ViewCreatorFSROITool(RoisWriteHandleKey="MuonFS_RoIs")
697 requireParentView = False
698
699 recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView)
700
701
702 #Clone and replace offline flags so we can set muon trigger specific values
703 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
704 from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
705 recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=recoMS.name+"RoIs"))
706
707 muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags, recoMS.name+'RoIs', 'FS' )
708 recoMS.mergeReco(muEFSARecoSequenceAcc)
709
710 selAccMS.mergeReco(recoMS)
711
712 return (selAccMS, sequenceOut)
713
714
715@AccumulatorCache
ViewCreatorFSROITool
Tool to create an output collection containing a single Full Scan ROI descriptor.
Definition ViewCreatorFSROITool.h:22

◆ muEFSAFSSequenceGenCfg()

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

Definition at line 716 of file MuonMenuSequences.py.

716def muEFSAFSSequenceGenCfg(flags, is_probe_leg=False):
717
718 (selAcc, sequenceOut) = muEFSAFSAlgSequenceCfg(flags)
719
720 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromName
721
722 efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
723 name = 'TrigMuonEFMSonlyHypo_FS',
724 MuonDecisions = sequenceOut,
725 IncludeSAmuons=True)
726
727 selAcc.addHypoAlgo(efmuMSHypo)
728
729 efmuMSSequence = MenuSequence(flags, selAcc,
730 HypoToolGen = TrigMuonEFMSonlyHypoToolFromName)
731
732
733 return efmuMSSequence
734
735

◆ muEFSASequenceGenCfg()

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

Definition at line 425 of file MuonMenuSequences.py.

425def muEFSASequenceGenCfg(flags, is_probe_leg=False):
426
427 (selAcc, sequenceOut) = muEFSAAlgSequenceCfg(flags, is_probe_leg)
428
429 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromDict
430 efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
431 name = 'TrigMuonEFMSonlyHypo_RoI',
432 MuonDecisions = sequenceOut,
433 IncludeSAmuons=True)
434
435 selAcc.addHypoAlgo(efmuMSHypo)
436
437 efmuMSSequence = MenuSequence(flags, selAcc,
438 HypoToolGen = TrigMuonEFMSonlyHypoToolFromDict)
439
440
441 return efmuMSSequence
442
443

◆ muFastAlgSequenceCfg()

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

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

Definition at line 24 of file MuonMenuSequences.py.

24def muFastAlgSequenceCfg(flags, selCAName="", is_probe_leg=False):
25
26 selAccSA = SelectionCA('L2MuFastSel'+selCAName, isProbe=is_probe_leg)
27
28 viewName="L2MuFastReco"
29
30 recoSA = InViewRecoCA(name=viewName, isProbe=is_probe_leg)
31
32
34 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
35 from .MuonRecoSequences import muFastRecoSequenceCfg, muonDecodeCfg
36 recoSA.mergeReco(muonDecodeCfg(muonflags,RoIs=viewName+'RoIs'))
37
38 extraLoads = []
39 from TriggerMenuMT.HLT.Config.ControlFlow.MenuComponentsNaming import CFNaming
40 filterInput = [ CFNaming.inputMakerOutName('IM_'+viewName) ]
41 for decision in filterInput:
42 extraLoads += [( 'xAOD::TrigCompositeContainer', 'StoreGateSvc+%s' % decision )]
43
44 from .MuonRecoSequences import isCosmic
45 acc = ComponentAccumulator()
46 seql2sa = seqAND("L2MuonSASeq{}".format("_probe" if is_probe_leg else ""))
47 acc.addSequence(seql2sa)
48 muFastRecoSeq = muFastRecoSequenceCfg( muonflags, viewName+'RoIs', doFullScanID= isCosmic(flags), extraLoads=extraLoads )
49 sequenceOut = muNames.L2SAName
50 acc.merge(muFastRecoSeq, sequenceName=seql2sa.name)
51
52
53 seqFilter = seqAND("L2MuonMTSeq{}".format("_probe" if is_probe_leg else ""))
54 acc.addSequence(seqFilter)
55 from TrigMuonEF.TrigMuonEFConfig import MuonChainFilterAlgCfg
56 MultiTrackChains = getMultiTrackChainNames()
57 MultiTrackChainFilter = MuonChainFilterAlgCfg(muonflags, "SAFilterMultiTrackChains", ChainsToFilter = MultiTrackChains,
58 InputDecisions = filterInput,
59 L2MuFastContainer = muNames.L2SAName+"l2mtmode",
60 L2MuCombContainer = muNames.L2CBName+"l2mtmode",
61 WriteMuFast = True, NotGate = True)
62
63 acc.merge(MultiTrackChainFilter, sequenceName=seqFilter.name)
64 muFastl2mtRecoSeq = muFastRecoSequenceCfg( muonflags, viewName+'RoIs', doFullScanID= isCosmic(flags), l2mtmode=True )
65 acc.merge(muFastl2mtRecoSeq, sequenceName=seqFilter.name)
66 recoSA.mergeReco(acc)
67
68 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
69 robPrefetch = ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
70
71 selAccSA.mergeReco(recoSA, robPrefetchCA=robPrefetch)
72
73
74 return (selAccSA, sequenceOut)
75
76

◆ muFastCalibAlgSequenceCfg()

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

Definition at line 77 of file MuonMenuSequences.py.

77def muFastCalibAlgSequenceCfg(flags, is_probe_leg=False):
78
79 selAccSA = SelectionCA('L2MuFastCalibSel', isProbe=is_probe_leg)
80
81 viewName="L2MuFastCalibReco"
82
83 recoSA = InViewRecoCA(name=viewName, isProbe=is_probe_leg)
84
85
87 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
88 from .MuonRecoSequences import muFastRecoSequenceCfg, muonDecodeCfg
89 recoSA.mergeReco(muonDecodeCfg(muonflags,RoIs=viewName+'RoIs'))
90
91 from .MuonRecoSequences import isCosmic
92 muFastRecoSeq = muFastRecoSequenceCfg( muonflags, viewName+'RoIs', doFullScanID= isCosmic(flags), calib=True )
93 sequenceOut = muNames.L2SAName+"Calib"
94 recoSA.mergeReco(muFastRecoSeq)
95
96
97 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
98 robPrefetchAlg = ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
99 selAccSA.mergeReco(recoSA, robPrefetchCA=robPrefetchAlg)
100
101 return (selAccSA, sequenceOut)
102
103
104@AccumulatorCache

◆ muFastCalibSequenceGenCfg()

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

Definition at line 124 of file MuonMenuSequences.py.

124def muFastCalibSequenceGenCfg(flags, is_probe_leg=False):
125
126 (selAcc, sequenceOut) = muFastCalibAlgSequenceCfg(flags, is_probe_leg)
127
128 from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
129 l2saHypo = TrigMufastHypoAlgCfg( flags,
130 name = 'TrigL2MufastCalibHypoAlg',
131 MuonL2SAInfoFromMuFastAlg = sequenceOut)
132
133 selAcc.addHypoAlgo(l2saHypo)
134
135 l2saSequence = MenuSequence(flags, selAcc,
136 HypoToolGen = TrigMufastHypoToolFromDict)
137
138
139 return l2saSequence
140
141
142@AccumulatorCache

◆ muFastSequenceGenCfg()

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

Definition at line 105 of file MuonMenuSequences.py.

105def muFastSequenceGenCfg(flags, is_probe_leg=False):
106
107 (selAcc, sequenceOut) = muFastAlgSequenceCfg(flags, "", is_probe_leg)
108
109 from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
110 l2saHypo = TrigMufastHypoAlgCfg( flags,
111 name = 'TrigL2MufastHypoAlg',
112 MuonL2SAInfoFromMuFastAlg = sequenceOut)
113
114 selAcc.addHypoAlgo(l2saHypo)
115
116 l2saSequence = MenuSequence(flags, selAcc,
117 HypoToolGen = TrigMufastHypoToolFromDict)
118
119
120 return l2saSequence
121
122
123@AccumulatorCache

◆ mul2IOOvlpRmSequenceGenCfg()

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

Definition at line 279 of file MuonMenuSequences.py.

279def mul2IOOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
280
281
282 (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "IO", is_probe_leg, trackingMode = trackingMode)
283
284 from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, Trigl2IOHypoToolwORFromDict
285 l2cbHypo = TrigmuCombHypoAlgCfg( flags,
286 name = 'TrigL2MuCBIOHypoAlg',
287 MuonL2CBInfoFromMuCombAlg = sequenceOut+"IOmode",
288 )
289
290 selAcc.addHypoAlgo(l2cbHypo)
291
292 l2cbSequence = MenuSequence(flags, selAcc,
293 HypoToolGen = Trigl2IOHypoToolwORFromDict)
294
295 return l2cbSequence
296
297

◆ mul2mtCBOvlpRmSequenceGenCfg()

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

Definition at line 373 of file MuonMenuSequences.py.

373def mul2mtCBOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
374
375 (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "mt", is_probe_leg, trackingMode = trackingMode)
376
377 from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, Trigl2mtCBHypoToolwORFromDict
378 l2cbHypo = TrigmuCombHypoAlgCfg( flags,
379 name = 'TrigL2mtMuCBHypoAlg',
380 MuonL2CBInfoFromMuCombAlg = sequenceOut+"l2mtmode",
381 )
382
383 selAcc.addHypoAlgo(l2cbHypo)
384
385 l2cbSequence = MenuSequence(flags, selAcc,
386 HypoToolGen = Trigl2mtCBHypoToolwORFromDict)
387
388 return l2cbSequence
389
390

◆ mul2mtSAOvlpRmSequenceGenCfg()

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

Definition at line 143 of file MuonMenuSequences.py.

143def mul2mtSAOvlpRmSequenceGenCfg(flags, is_probe_leg=False):
144
145 (selAcc, sequenceOut) = muFastAlgSequenceCfg(flags, "mt", is_probe_leg)
146
147 from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
148 l2saHypo = TrigMufastHypoAlgCfg( flags,
149 name = 'TrigL2mtMufastHypoAlg',
150 MuonL2SAInfoFromMuFastAlg = muNames.L2SAName+"l2mtmode")
151
152 selAcc.addHypoAlgo(l2saHypo)
153
154 l2saSequence = MenuSequence(flags, selAcc,
155 HypoToolGen = TrigMufastHypoToolFromDict)
156
157
158 return l2saSequence
159
160
161
162#-----------------------------------------------------#

◆ muRoiClusterSequenceGenCfg()

python.HLT.Muon.MuonMenuSequences.muRoiClusterSequenceGenCfg ( flags)

Muon RoI Cluster Trigger for MS LLP Searches ##.

Definition at line 985 of file MuonMenuSequences.py.

985def muRoiClusterSequenceGenCfg(flags):
986
987 from TrigLongLivedParticles.TrigLongLivedParticlesConfig import MuonClusterConfig
988 from TrigLongLivedParticlesHypo.TrigLongLivedParticlesHypoConfig import MuonClusterHypoAlgConfig, TrigLongLivedParticlesHypoToolFromDict
989
990 selAcc = SelectionCA('muRoIClusterSel')
991
992 viewName="MuRoIClusReco"
993 viewcreator = CompFactory.ViewCreatorInitialROITool
994 roiTool = viewcreator()
995
996 recoRoICluster = InEventRecoCA(name=viewName, RoITool = roiTool, mergeUsingFeature = False, RoIs = 'HLT_muVtxCluster_RoIs')
997 recoRoICluster.mergeReco(MuonClusterConfig(flags, 'muvtxMuonCluster'))
998 selAcc.mergeReco(recoRoICluster)
999
1000
1001 hypoAlg = MuonClusterHypoAlgConfig( flags,
1002 name = 'MuRoiClusterHypoAlg')
1003
1004 selAcc.addHypoAlgo(hypoAlg)
1005
1006 muRoIClusterSequence = MenuSequence(flags, selAcc,
1007 HypoToolGen = TrigLongLivedParticlesHypoToolFromDict)
1008
1009 return muRoIClusterSequence
1010
1011
1012

Variable Documentation

◆ log

python.HLT.Muon.MuonMenuSequences.log = logging.getLogger(__name__)

Definition at line 12 of file MuonMenuSequences.py.

◆ muNames

python.HLT.Muon.MuonMenuSequences.muNames = muonNames().getNames('RoI')

Definition at line 16 of file MuonMenuSequences.py.

◆ muNamesFS

python.HLT.Muon.MuonMenuSequences.muNamesFS = muonNames().getNames('FS')

Definition at line 18 of file MuonMenuSequences.py.

◆ muNamesLRT

python.HLT.Muon.MuonMenuSequences.muNamesLRT = muonNames().getNames('LRT')

Definition at line 17 of file MuonMenuSequences.py.

Generated on for ATLAS Offline Software by doxygen 1.14.0