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

Functions

 muFastAlgSequenceCfg (flags, suffix="", useNewFast=False, is_probe_leg=False)
 ************* Step1 ************* ### --------------------------------------------------—#
 muFastCalibAlgSequenceCfg (flags, is_probe_leg=False)
 muFastSequenceGenCfg (flags, useNewFast=False, 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, suffix="", is_probe_leg=False, useBucketFilter=False, useNewFast=False)
 EFSA step ###.
 muEFSASequenceGenCfg (flags, is_probe_leg=False, useBucketFilter=False, useNewFast=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, suffix="", useBucketFilter=False)
 EF SA full scan ###.
 muEFSAFSSequenceGenCfg (flags, useBucketFilter=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')
 muNamesFS = muonNames().getNames('FS')
 muNamesLRT = muonNames().getNames('LRT')

Function Documentation

◆ efLateMuAlgSequenceCfg()

efLateMuAlgSequenceCfg ( flags,
is_probe_leg = False )

Definition at line 896 of file MuonMenuSequences.py.

896def efLateMuAlgSequenceCfg(flags, is_probe_leg=False):
897
898 from .MuonRecoSequences import muEFInsideOutRecoSequenceCfg, muonDecodeCfg, muonIDFastTrackingSequenceCfg
899 selAcc = SelectionCA('EFLateMuAlg', isProbe=is_probe_leg)
900
901 viewName = "EFLateMuReco"
902 viewcreator = CompFactory.ViewCreatorNamedROITool
903 roiTool = viewcreator(ROILinkName="feature")
904
905 recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView=True, mergeUsingFeature=True, isProbe=is_probe_leg)
906
907
908 #Clone and replace offline flags so we can set muon trigger specific values
909 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
910 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
911 #decode data in these RoIs
912 recoLateMu.mergeReco(muonDecodeCfg(muonflags,RoIs=recoLateMu.name+"RoIs"))
913 #ID fast tracking
914 recoLateMu.mergeReco(muonIDFastTrackingSequenceCfg(flags, recoLateMu.name+"RoIs","muonLate" ))
915 #inside-out reco sequence
916 recoLateMu.mergeReco(muEFInsideOutRecoSequenceCfg(muonflagsCB, recoLateMu.name+"RoIs", "LateMu", ''))
917 sequenceOut = muNames.EFCBInOutName+'_Late'
918
919 selAcc.mergeReco(recoLateMu)
920
921 return (selAcc, sequenceOut)
922
923
924@AccumulatorCache

◆ efLateMuRoIAlgSequenceCfg()

efLateMuRoIAlgSequenceCfg ( flags,
is_probe_leg = False )

Definition at line 857 of file MuonMenuSequences.py.

857def efLateMuRoIAlgSequenceCfg(flags, is_probe_leg=False):
858
859 selAcc = SelectionCA('EFLateMuSel', isProbe=is_probe_leg)
860
861 viewName = "EFLateMuRoIReco"
862 viewcreator = CompFactory.ViewCreatorInitialROITool
863 roiTool = viewcreator()
864
865 recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg)
866
867 from .MuonRecoSequences import efLateMuRoISequenceCfg
868
869 #Get Late Muon RoIs
870 efLateMuRoIAcc, sequenceOut = efLateMuRoISequenceCfg(flags)
871 recoLateMu.mergeReco(efLateMuRoIAcc)
872
873 selAcc.mergeReco(recoLateMu)
874 return (selAcc, sequenceOut)
875
876
877@AccumulatorCache

◆ efLateMuRoISequenceGenCfg()

efLateMuRoISequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 878 of file MuonMenuSequences.py.

878def efLateMuRoISequenceGenCfg(flags, is_probe_leg=False):
879
880 (selAcc, sequenceOut) = efLateMuRoIAlgSequenceCfg(flags, is_probe_leg)
881
882 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonLateMuRoIHypoAlgCfg, TrigMuonLateMuRoIHypoToolFromDict
883 latemuHypo = TrigMuonLateMuRoIHypoAlgCfg( flags,
884 name = 'TrigMuonLateMuRoIHypoAlg',
885 LateRoIs = sequenceOut)
886
887 selAcc.addHypoAlgo(latemuHypo)
888
889 latemuRoISequence = MenuSequence(flags, selAcc,
890 HypoToolGen = TrigMuonLateMuRoIHypoToolFromDict)
891
892
893 return latemuRoISequence
894
895

◆ efLateMuSequenceGenCfg()

efLateMuSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 925 of file MuonMenuSequences.py.

925def efLateMuSequenceGenCfg(flags, is_probe_leg=False):
926
927 (selAcc, sequenceOut) = efLateMuAlgSequenceCfg(flags, is_probe_leg=False)
928
929 # setup EFCB hypo
930 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg
931 trigMuonEFLateHypo = TrigMuonEFHypoAlgCfg( "TrigMuonEFCombinerLateMuHypoAlg", MuonDecisions = sequenceOut )
932
933 selAcc.addHypoAlgo(trigMuonEFLateHypo)
934 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFCombinerHypoToolFromDict
935
936 return MenuSequence(flags, selAcc,
937 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict )
938
939
940

◆ getBphysChainNames()

getBphysChainNames ( )

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

Definition at line 1048 of file MuonMenuSequences.py.

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

◆ getInsideOutMuonChainNames()

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

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

◆ getMultiTrackChainNames()

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

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

◆ muCombAlgSequenceCfg()

muCombAlgSequenceCfg ( flags,
selCAName = "",
is_probe_leg = False,
trackingMode = "FTF" )

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

Definition at line 176 of file MuonMenuSequences.py.

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

muCombLRTAlgSequenceCfg ( flags,
is_probe_leg = False )

Definition at line 305 of file MuonMenuSequences.py.

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

◆ muCombLRTSequenceGenCfg()

muCombLRTSequenceGenCfg ( flags,
is_probe_leg = False,
trackingMode = "FTF" )

Definition at line 336 of file MuonMenuSequences.py.

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

◆ muCombOvlpRmSequenceGenCfg()

muCombOvlpRmSequenceGenCfg ( flags,
is_probe_leg = False,
trackingMode = "FTF" )

Definition at line 357 of file MuonMenuSequences.py.

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

◆ muCombSequenceGenCfg()

muCombSequenceGenCfg ( flags,
is_probe_leg = False,
trackingMode = "FTF" )

Definition at line 266 of file MuonMenuSequences.py.

266def muCombSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
267
268 (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "", is_probe_leg, trackingMode = trackingMode)
269
270 from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, TrigmuCombHypoToolFromDict
271 l2cbHypo = TrigmuCombHypoAlgCfg( flags,
272 name = 'TrigL2MuCBHypoAlg',
273 MuonL2CBInfoFromMuCombAlg = sequenceOut,
274 )
275
276 selAcc.addHypoAlgo(l2cbHypo)
277
278 l2cbSequence = MenuSequence(flags, selAcc,
279 HypoToolGen = TrigmuCombHypoToolFromDict)
280
281
282 return l2cbSequence
283
284
285@AccumulatorCache

◆ muEFCBAlgSequenceCfg()

muEFCBAlgSequenceCfg ( flags,
suffix,
selCAName = '',
is_probe_leg = False )

EFCB seq ###.

Definition at line 476 of file MuonMenuSequences.py.

476def muEFCBAlgSequenceCfg(flags, suffix, selCAName='', is_probe_leg=False):
477
478 from .MuonRecoSequences import isCosmic
479 selAccCB = SelectionCA('EFMuCBSel_RoI'+selCAName+suffix, isProbe=is_probe_leg)
480
481 viewName="EFMuCBReco_RoI"+suffix if not isCosmic(flags) else "CosmicEFCB"
482 ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
483 #temporarily using different view names until L2 SA sequence is migrated to CA
484 roiTool = ViewCreatorTool(ROILinkName="l2cbroi")
485
486 recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg, mergeUsingFeature=True)
487
488 #By default the EFCB sequence will run both outside-in and
489 #(if zero muons are found) inside-out reconstruction
490 from TrigMuonEF.TrigMuonEFConfig import MuonFilterAlgCfg, MergeEFMuonsAlgCfg
491 from .MuonRecoSequences import muEFCBRecoSequenceCfg, muEFInsideOutRecoSequenceCfg
492
493 acc = ComponentAccumulator()
494 seqmerge = seqAND("muonCBInsideOutMergingSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
495 acc.addSequence(seqmerge)
496
497 #outside-in reco sequence
498 acc2 = ComponentAccumulator()
499 seqreco = parOR("muonEFCBandInsideOutRecoSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
500 acc2.addSequence(seqreco)
501 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
502 acc2.merge(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "RoI", suffix ), sequenceName=seqreco.name)
503 sequenceOutCB = muNames.EFCBOutInName+suffix
504
505 #Algorithm to filter events with no muons
506 acc3 = ComponentAccumulator()
507 seqfilter = seqAND("muonEFInsideOutSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
508 acc3.addSequence(seqfilter)
509 muonFilter = MuonFilterAlgCfg(flags, name="FilterZeroMuons"+suffix, MuonContainerLocation=sequenceOutCB)
510 acc3.merge(muonFilter, sequenceName=seqfilter.name)
511
512 #inside-out reco sequence - runs only if filter is passed
513 acc4 = ComponentAccumulator()
514 seqio = parOR("efmuInsideOutViewNode_RoI{}{}".format(suffix, "_probe" if is_probe_leg else ""))
515 acc4.addSequence(seqio)
516 acc4.merge(muEFInsideOutRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "RoI", suffix), sequenceName=seqio.name+suffix)
517 sequenceOutInsideOut = muNames.EFCBInOutName+suffix
518
519 acc3.merge(acc4, sequenceName=seqfilter.name)
520 acc2.merge(acc3, sequenceName=seqreco.name)
521 acc.merge(acc2, sequenceName=seqmerge.name)
522 #Merge muon containers from outside-in and inside-out reco
523 if suffix != '':
524 mergedMuonOutputLocation = recordable(muNames.EFCBName+'_'+suffix)
525 else:
526 mergedMuonOutputLocation = muNames.EFCBName
527 mergeMuons = MergeEFMuonsAlgCfg(flags, name="MergeEFMuons"+suffix, MuonCBContainerLocation=sequenceOutCB,
528 MuonInsideOutContainerLocation=sequenceOutInsideOut, MuonOutputLocation=mergedMuonOutputLocation)
529
530 acc.merge(mergeMuons, sequenceName=seqmerge.name)
531 recoCB.mergeReco(acc)
532 selAccCB.mergeReco(recoCB)
533
534 return (selAccCB, muNames.EFCBName)
535
536
537@AccumulatorCache

◆ muEFCBFSAlgSequenceCfg()

muEFCBFSAlgSequenceCfg ( flags,
is_probe_leg = False )

EF CB full scan ###.

Definition at line 779 of file MuonMenuSequences.py.

779def muEFCBFSAlgSequenceCfg(flags, is_probe_leg=False):
780
781 selAccCB = SelectionCA('EFMuCBSel_FS', isProbe=is_probe_leg)
782
783 viewName="EFMuCBReco_FS"
784 #temporarily using different view names until L2 SA sequence is migrated to CA
785 roiTool = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = "MuonCandidates_FS_ROIs")
786
787 recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg, mergeUsingFeature=True,
788 PlaceMuonInView=True, InViewMuons = "InViewMuons", InViewMuonCandidates = "MuonCandidates_FS")
789
790
791 from TrigMuonEF.TrigMuonEFConfig import MuonFilterAlgCfg, MergeEFMuonsAlgCfg
792 from .MuonRecoSequences import muEFCBRecoSequenceCfg, muEFInsideOutRecoSequenceCfg
793 #outside-in reco sequence
794 acc = ComponentAccumulator()
795 seqmerge = seqAND("muonCBInsideOutMergingSequenceEFCBFS{}".format("_probe" if is_probe_leg else ""))
796 acc.addSequence(seqmerge)
797
798 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
799 acc2 = ComponentAccumulator()
800 seqreco = parOR("muonEFCBFSInsideOutRecoSequence{}".format("_probe" if is_probe_leg else ""))
801 acc2.addSequence(seqreco)
802
803 acc2.merge(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "FS", ''), sequenceName=seqreco.name)
804 sequenceOutCB = muNamesFS.EFCBOutInName
805
806 #Alg fitltering for no muon events
807 muonFilter = MuonFilterAlgCfg(flags, name="FilterZeroMuonsEFCBFS", MuonContainerLocation = sequenceOutCB)
808
809 acc3 = ComponentAccumulator()
810 seqfilt = seqAND("muonEFCBFSInsideOutSequence{}".format("_probe" if is_probe_leg else ""))
811 acc3.addSequence(seqfilt)
812 acc3.merge(muonFilter, sequenceName=seqfilt.name)
813
814
815 #If filter passed
816 acc4 = ComponentAccumulator()
817 seqio = parOR("efmuInsideOutViewNode_FS{}".format("_probe" if is_probe_leg else ""))
818 acc4.addSequence(seqio)
819
820 muonEFInsideOutRecoAlgSequence = muEFInsideOutRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "FS", '' )
821 acc4.merge(muonEFInsideOutRecoAlgSequence, sequenceName=seqio.name)
822 acc3.merge(acc4, sequenceName=seqfilt.name)
823 acc2.merge(acc3, sequenceName=seqreco.name)
824 acc.merge(acc2, sequenceName=seqmerge.name)
825 sequenceOutInsideOut = muNamesFS.EFCBInOutName
826
827 #Merge muon containers from O-I and I-O reco
828 mergeMuons = MergeEFMuonsAlgCfg(flags, name="MergeEFCBFSMuons", MuonCBContainerLocation = sequenceOutCB,
829 MuonInsideOutContainerLocation = sequenceOutInsideOut, MuonOutputLocation = muNamesFS.EFCBName)
830 acc.merge(mergeMuons, sequenceName=seqmerge.name)
831 recoCB.mergeReco(acc)
832
833 sequenceOut = muNamesFS.EFCBName
834 selAccCB.mergeReco(recoCB)
835
836 return (selAccCB, sequenceOut)
837
838
839@AccumulatorCache

◆ muEFCBFSSequenceGenCfg()

muEFCBFSSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 840 of file MuonMenuSequences.py.

840def muEFCBFSSequenceGenCfg(flags, is_probe_leg=False):
841
842 (selAcc, sequenceOut) = muEFCBFSAlgSequenceCfg(flags, is_probe_leg)
843
844 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromName
845 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
846 name = 'TrigMuonEFFSCombinerHypoAlg',
847 MuonDecisions = sequenceOut)
848
849 selAcc.addHypoAlgo(efmuCBHypo)
850
851 efmuCBSequence = MenuSequence(flags, selAcc,
852 HypoToolGen = TrigMuonEFCombinerHypoToolFromName)
853
854 return efmuCBSequence
855
856

◆ muEFCBIDperfSequenceGenCfg()

muEFCBIDperfSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 614 of file MuonMenuSequences.py.

614def muEFCBIDperfSequenceGenCfg(flags, is_probe_leg=False):
615
616 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idperf', is_probe_leg)
617
618 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
619 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
620 name = 'TrigMuonEFCombinerIDperfHypoAlg',
621 IncludeSAmuons=True,
622 MuonDecisions = sequenceOut,
623 MapToPreviousDecisions=True)
624
625 selAcc.addHypoAlgo(efmuCBHypo)
626
627 efmuCBSequence = MenuSequence(flags, selAcc,
628 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
629
630 return efmuCBSequence
631
632
633@AccumulatorCache

◆ muEFCBidReuseSequenceGenCfg()

muEFCBidReuseSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 595 of file MuonMenuSequences.py.

595def muEFCBidReuseSequenceGenCfg(flags, is_probe_leg=False):
596
597 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, 'idReuse', '', is_probe_leg)
598
599 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
600 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
601 name = 'TrigMuonEFCombinerHypoAlgidReuse',
602 MuonDecisions = sequenceOut+'_idReuse',
603 MapToPreviousDecisions=True)
604
605 selAcc.addHypoAlgo(efmuCBHypo)
606
607 efmuCBSequence = MenuSequence(flags, selAcc,
608 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
609
610 return efmuCBSequence
611
612
613@AccumulatorCache

◆ muEFCBl2ioSequenceGenCfg()

muEFCBl2ioSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 557 of file MuonMenuSequences.py.

557def muEFCBl2ioSequenceGenCfg(flags, is_probe_leg=False):
558
559 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags,'IOmode', '', is_probe_leg)
560
561 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
562 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
563 name = 'TrigMuonEFCombinerHypoAlgIOmode',
564 MuonDecisions = sequenceOut+'_IOmode',
565 MapToPreviousDecisions=True)
566
567 selAcc.addHypoAlgo(efmuCBHypo)
568
569 efmuCBSequence = MenuSequence(flags, selAcc,
570 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
571
572 return efmuCBSequence
573
574
575@AccumulatorCache

◆ muEFCBl2mtSequenceGenCfg()

muEFCBl2mtSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 576 of file MuonMenuSequences.py.

576def muEFCBl2mtSequenceGenCfg(flags, is_probe_leg=False):
577
578 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags,'l2mtmode', '', is_probe_leg)
579
580 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
581 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
582 name = 'TrigMuonEFCombinerHypoAlgl2mtmode',
583 MuonDecisions = sequenceOut+'_l2mtmode',
584 MapToPreviousDecisions=True)
585
586 selAcc.addHypoAlgo(efmuCBHypo)
587
588 efmuCBSequence = MenuSequence(flags, selAcc,
589 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
590
591 return efmuCBSequence
592
593
594@AccumulatorCache

◆ muEFCBLRTAlgSequenceCfg()

muEFCBLRTAlgSequenceCfg ( flags,
selCAName = '',
is_probe_leg = False )

Definition at line 654 of file MuonMenuSequences.py.

654def muEFCBLRTAlgSequenceCfg(flags, selCAName='', is_probe_leg=False):
655
656 selAccCB = SelectionCA('EFMuCBLRTSel'+selCAName, isProbe=is_probe_leg)
657
658 viewName="EFMuCBLRTReco"
659 ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
660 roiTool = ViewCreatorTool(ROILinkName="l2lrtroi")
661
662 recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, mergeUsingFeature=True, isProbe=is_probe_leg)
663
664 from .MuonRecoSequences import muEFCBRecoSequenceCfg
665
666 #outside-in reco sequence
667 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
668 recoCB.mergeReco(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "LRT", ''))
669 sequenceOut = muNamesLRT.EFCBName
670
671 selAccCB.mergeReco(recoCB)
672
673 return (selAccCB, sequenceOut)
674
675
676@AccumulatorCache

◆ muEFCBLRTIDperfSequenceGenCfg()

muEFCBLRTIDperfSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 697 of file MuonMenuSequences.py.

697def muEFCBLRTIDperfSequenceGenCfg(flags, is_probe_leg=False):
698
699 (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, 'idperf', is_probe_leg)
700
701 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
702 efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
703 name = 'TrigMuonEFCombinerHypoAlgLRTIDPerf',
704 IncludeSAmuons=True,
705 MuonDecisions = sequenceOut,
706 MapToPreviousDecisions=True)
707
708
709 selAcc.addHypoAlgo(efmuCBLRTHypo)
710
711 efmuCBSequence = MenuSequence(flags, selAcc,
712 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
713
714 return efmuCBSequence
715
716

◆ muEFCBLRTSequenceGenCfg()

muEFCBLRTSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 677 of file MuonMenuSequences.py.

677def muEFCBLRTSequenceGenCfg(flags, is_probe_leg=False):
678
679 (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, '', is_probe_leg)
680
681 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
682 efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
683 name = 'TrigMuonEFCombinerHypoAlgLRT',
684 MuonDecisions = sequenceOut,
685 MapToPreviousDecisions=True)
686
687
688 selAcc.addHypoAlgo(efmuCBLRTHypo)
689
690 efmuCBSequence = MenuSequence(flags, selAcc,
691 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
692
693 return efmuCBSequence
694
695
696@AccumulatorCache

◆ muEFCBSequenceGenCfg()

muEFCBSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 538 of file MuonMenuSequences.py.

538def muEFCBSequenceGenCfg(flags, is_probe_leg=False):
539
540 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', '', is_probe_leg)
541
542 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
543 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
544 name = 'TrigMuonEFCombinerHypoAlg',
545 MuonDecisions = sequenceOut,
546 MapToPreviousDecisions=True)
547
548 selAcc.addHypoAlgo(efmuCBHypo)
549
550 efmuCBSequence = MenuSequence(flags, selAcc,
551 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
552
553 return efmuCBSequence
554
555
556@AccumulatorCache

◆ muEFIDtpSequenceGenCfg()

muEFIDtpSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 634 of file MuonMenuSequences.py.

634def muEFIDtpSequenceGenCfg(flags, is_probe_leg=False):
635
636 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idtp', is_probe_leg)
637
638 isPhaseIIMuon = flags.Trigger.Offline.SA.Muon.scheduleActsReco and flags.Trigger.Offline.SA.Muon.usePhaseIIGeoSetup
639
640 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFIdtpHypoAlgCfg, TrigMuonEFIdtpHypoToolFromDict
641 efmuCBHypo = TrigMuonEFIdtpHypoAlgCfg( flags,
642 name = 'TrigMuonEFIdtpHypoAlg',
643 IsPhIIMuon = isPhaseIIMuon)
644
645
646 selAcc.addHypoAlgo(efmuCBHypo)
647
648 efmuCBSequence = MenuSequence(flags, selAcc,
649 HypoToolGen = TrigMuonEFIdtpHypoToolFromDict)
650
651 return efmuCBSequence
652
653

◆ muEFIsoAlgSequenceCfg()

muEFIsoAlgSequenceCfg ( flags,
doMSiso = False,
is_probe_leg = False )

efMuiso step ###

Definition at line 944 of file MuonMenuSequences.py.

944def muEFIsoAlgSequenceCfg(flags, doMSiso=False, is_probe_leg=False):
945 name = ""
946 if doMSiso:
947 name = "MS"
948
949
950 selAccIso = SelectionCA('EFMuIso'+name, isProbe=is_probe_leg)
951
952 viewName="EFMuIsoReco"+name
953 roisWriteHandleKey = 'Roi_MuonIsoMS' if doMSiso else recordable('HLT_Roi_MuonIso')
954
955 roiTool = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = roisWriteHandleKey,
956 RoIEtaWidth=flags.Trigger.InDetTracking.muonIso.etaHalfWidth,
957 RoIPhiWidth=flags.Trigger.InDetTracking.muonIso.phiHalfWidth,
958 RoIZedWidth=flags.Trigger.InDetTracking.muonIso.zedHalfWidth)
959
960 recoIso = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg, mergeUsingFeature=True,
961 PlaceMuonInView=True, InViewMuons = "IsoViewMuons"+name, InViewMuonCandidates = "IsoMuonCandidates"+name)
962
963
964
965 from .MuonRecoSequences import efmuisoRecoSequenceCfg
966 sequenceOut = muNames.EFIsoMuonName+name
967 recoIso.mergeReco(efmuisoRecoSequenceCfg( flags, viewName+"RoIs", "IsoViewMuons"+name, doMSiso ))
968
969 selAccIso.mergeReco(recoIso)
970
971 return (selAccIso, sequenceOut)
972
973
974@AccumulatorCache

◆ muEFIsoSequenceGenCfg()

muEFIsoSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 975 of file MuonMenuSequences.py.

975def muEFIsoSequenceGenCfg(flags, is_probe_leg=False):
976
977 (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, False, is_probe_leg)
978
979 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
980 efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
981 name = 'EFMuisoHypoAlg',
982 EFMuonsName = sequenceOut)
983
984 selAcc.addHypoAlgo(efmuisoHypo)
985
986 efmuisoSequence = MenuSequence(flags, selAcc,
987 HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
988
989 return efmuisoSequence
990
991
992@AccumulatorCache

◆ muEFMSIsoSequenceGenCfg()

muEFMSIsoSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 993 of file MuonMenuSequences.py.

993def muEFMSIsoSequenceGenCfg(flags, is_probe_leg=False):
994
995 (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, True, is_probe_leg)
996
997 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
998 efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
999 name = 'EFMuMSisoHypoAlg',
1000 EFMuonsName = sequenceOut)
1001
1002 selAcc.addHypoAlgo(efmuisoHypo)
1003
1004 efmuisoSequence = MenuSequence(flags, selAcc,
1005 HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
1006
1007 return efmuisoSequence
1008
1009

◆ muEFSAAlgSequenceCfg()

muEFSAAlgSequenceCfg ( flags,
suffix = "",
is_probe_leg = False,
useBucketFilter = False,
useNewFast = False )

EFSA step ###.

Definition at line 398 of file MuonMenuSequences.py.

398def muEFSAAlgSequenceCfg(flags, suffix="", is_probe_leg=False, useBucketFilter=False, useNewFast=False):
399
400 selAccMS = SelectionCA(f'EFMuMSSel_RoI{suffix}', isProbe=is_probe_leg)
401
402 viewName=f"EFMuMSReco_RoI{suffix}"
403 if useNewFast:
404 recoMS = InViewRecoCA(name=viewName, isProbe=is_probe_leg)
405 else:
406 #temporarily using different view names until L2 SA sequence is migrated to CA
407 roiTool = CompFactory.ViewCreatorFetchFromViewROITool(RoisWriteHandleKey=f"HLT_Roi_L2SAMuonForEF{suffix}",
408 InViewRoIs = "forMS",
409 ViewToFetchFrom = "L2MuFastRecoViews")
410 recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg)
411
412 #Clone and replace offline flags so we can set muon trigger specific values
413 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
414
415 truthAlgs = ComponentAccumulator()
416 if muonflags.Muon.setupTruthAlgorithms:
417 loadFromSG = [( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MDT_SDO' ),
418 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MM_SDO' ),
419 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+RPC_SDO' ),
420 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+TGC_SDO' ),
421 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+sTGC_SDO' )]
422 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
423 truthAlgs.merge(SGInputLoaderCfg(muonflags, loadFromSG))
424
425 from xAODTruthCnv.xAODTruthCnvConfig import GEN_AOD2xAODCfg
426 truthAlgs.merge(GEN_AOD2xAODCfg(muonflags))
427 from MuonTruthAlgsR4.MuonTruthAlgsConfig import MuonTruthObjCreatorsCfg
428 truthAlgs.merge(MuonTruthObjCreatorsCfg(muonflags, useSDO=True))
429
430 from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
431 #Run decoding again since we are using updated RoIs
432 recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=viewName+"RoIs"))
433
434 muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags, RoIs = viewName+'RoIs',
435 suffix = f'RoI{suffix}',
436 useBucketFilter=useBucketFilter)
437 recoMS.mergeReco(muEFSARecoSequenceAcc)
438
439 selAccMS.mergeReco(recoMS, upSequenceCA=truthAlgs)
440
441 return (selAccMS, sequenceOut)
442
443
444@AccumulatorCache

◆ muEFSAFSAlgSequenceCfg()

muEFSAFSAlgSequenceCfg ( flags,
suffix = "",
useBucketFilter = False )

EF SA full scan ###.

Definition at line 721 of file MuonMenuSequences.py.

721def muEFSAFSAlgSequenceCfg(flags, suffix="", useBucketFilter=False):
722
723 selAccMS = SelectionCA(f'EFMuMSSel_FS{suffix}')
724
725 viewName=f"EFMuMSReco_FS{suffix}"
726 ViewCreatorFSROITool=CompFactory.ViewCreatorFSROITool
727 roiTool = ViewCreatorFSROITool(RoisWriteHandleKey="MuonFS_RoIs")
728 requireParentView = False
729
730 recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView)
731
732
733 #Clone and replace offline flags so we can set muon trigger specific values
734 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
735 from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
736 recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=recoMS.name+"RoIs"))
737
738 muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags,
739 RoIs=recoMS.name+'RoIs',
740 suffix=f'FS{suffix}',
741 useBucketFilter=useBucketFilter)
742 recoMS.mergeReco(muEFSARecoSequenceAcc)
743
744 selAccMS.mergeReco(recoMS)
745
746 return (selAccMS, sequenceOut)
747
748
749@AccumulatorCache
ViewCreatorFSROITool
Tool to create an output collection containing a single Full Scan ROI descriptor.
Definition ViewCreatorFSROITool.h:22

◆ muEFSAFSSequenceGenCfg()

muEFSAFSSequenceGenCfg ( flags,
useBucketFilter = False )

Definition at line 750 of file MuonMenuSequences.py.

750def muEFSAFSSequenceGenCfg(flags, useBucketFilter=False):
751
752 if flags.Trigger.Offline.SA.Muon.scheduleActsReco and flags.Trigger.Offline.SA.Muon.usePhaseIIGeoSetup:
753 suffix = f'PhII{"_mlbkt" if useBucketFilter else ""}'
754 else:
755 suffix=""
756
757 (selAcc, sequenceOut) = muEFSAFSAlgSequenceCfg(flags, suffix=suffix, useBucketFilter=useBucketFilter)
758
759 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromName
760
761 efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
762 name = f'TrigMuonEFMSonlyHypo_FS{suffix}',
763 MuonDecisions = sequenceOut,
764 IncludeSAmuons=True)
765
766 selAcc.addHypoAlgo(efmuMSHypo)
767
768 efmuMSSequence = MenuSequence(flags, selAcc,
769 HypoToolGen = TrigMuonEFMSonlyHypoToolFromName)
770
771
772 return efmuMSSequence
773
774

◆ muEFSASequenceGenCfg()

muEFSASequenceGenCfg ( flags,
is_probe_leg = False,
useBucketFilter = False,
useNewFast = False )

Definition at line 445 of file MuonMenuSequences.py.

445def muEFSASequenceGenCfg(flags, is_probe_leg=False, useBucketFilter=False, useNewFast=False):
446
447 if flags.Trigger.Offline.SA.Muon.scheduleActsReco and flags.Trigger.Offline.SA.Muon.usePhaseIIGeoSetup:
448 suffix = f'PhII{"_newFast" if useNewFast else ""}{"_mlbkt" if useBucketFilter else ""}'
449 else:
450 suffix=""
451
452 (selAcc, sequenceOut) = muEFSAAlgSequenceCfg(flags, suffix=suffix,
453 is_probe_leg=is_probe_leg,
454 useBucketFilter=useBucketFilter,
455 useNewFast=useNewFast)
456
457 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromDict
458 efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
459 name = f'TrigMuonEFMSonlyHypo_RoI{suffix}',
460 MuonDecisions = sequenceOut,
461 IncludeSAmuons=True)
462
463 selAcc.addHypoAlgo(efmuMSHypo)
464
465 efmuMSSequence = MenuSequence(flags, selAcc,
466 HypoToolGen = TrigMuonEFMSonlyHypoToolFromDict)
467
468
469 return efmuMSSequence
470
471

◆ muFastAlgSequenceCfg()

muFastAlgSequenceCfg ( flags,
suffix = "",
useNewFast = False,
is_probe_leg = False )

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

Definition at line 22 of file MuonMenuSequences.py.

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

◆ muFastCalibAlgSequenceCfg()

muFastCalibAlgSequenceCfg ( flags,
is_probe_leg = False )

Definition at line 81 of file MuonMenuSequences.py.

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

◆ muFastCalibSequenceGenCfg()

muFastCalibSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 134 of file MuonMenuSequences.py.

134def muFastCalibSequenceGenCfg(flags, is_probe_leg=False):
135
136 (selAcc, sequenceOut) = muFastCalibAlgSequenceCfg(flags, is_probe_leg=is_probe_leg)
137
138 from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
139 l2saHypo = TrigMufastHypoAlgCfg( flags,
140 name = 'TrigL2MufastCalibHypoAlg',
141 MuonL2SAInfoFromMuFastAlg = sequenceOut)
142
143 selAcc.addHypoAlgo(l2saHypo)
144
145 l2saSequence = MenuSequence(flags, selAcc,
146 HypoToolGen = TrigMufastHypoToolFromDict)
147
148
149 return l2saSequence
150
151
152@AccumulatorCache

◆ muFastSequenceGenCfg()

muFastSequenceGenCfg ( flags,
useNewFast = False,
is_probe_leg = False )

Definition at line 106 of file MuonMenuSequences.py.

106def muFastSequenceGenCfg(flags, useNewFast=False, is_probe_leg=False):
107
108 (selAcc, sequenceOut) = muFastAlgSequenceCfg(flags, suffix="", useNewFast=useNewFast, is_probe_leg=is_probe_leg)
109
110 if useNewFast:
111 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFFastRecoSAHypoToolFromDict
112 l2saHypo = TrigMuonEFHypoAlgCfg( flags,
113 name = 'TrigEFMufastHypoAlg_RoI',
114 MuonDecisions = sequenceOut,
115 IncludeSAmuons=True)
116 HypoToolGen = TrigMuonEFFastRecoSAHypoToolFromDict
117
118 else:
119 from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
120 l2saHypo = TrigMufastHypoAlgCfg( flags,
121 name = 'TrigL2MufastHypoAlg',
122 MuonL2SAInfoFromMuFastAlg = sequenceOut)
123 HypoToolGen = TrigMufastHypoToolFromDict
124
125 selAcc.addHypoAlgo(l2saHypo)
126
127 l2saSequence = MenuSequence(flags, selAcc,
128 HypoToolGen = HypoToolGen)
129
130 return l2saSequence
131
132
133@AccumulatorCache

◆ mul2IOOvlpRmSequenceGenCfg()

mul2IOOvlpRmSequenceGenCfg ( flags,
is_probe_leg = False,
trackingMode = "FTF" )

Definition at line 286 of file MuonMenuSequences.py.

286def mul2IOOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode = "FTF"):
287
288
289 (selAcc, sequenceOut) = muCombAlgSequenceCfg(flags, "IO", is_probe_leg, trackingMode = trackingMode)
290
291 from TrigMuonHypo.TrigMuonHypoConfig import TrigmuCombHypoAlgCfg, Trigl2IOHypoToolwORFromDict
292 l2cbHypo = TrigmuCombHypoAlgCfg( flags,
293 name = 'TrigL2MuCBIOHypoAlg',
294 MuonL2CBInfoFromMuCombAlg = sequenceOut+"IOmode",
295 )
296
297 selAcc.addHypoAlgo(l2cbHypo)
298
299 l2cbSequence = MenuSequence(flags, selAcc,
300 HypoToolGen = Trigl2IOHypoToolwORFromDict)
301
302 return l2cbSequence
303
304

◆ mul2mtCBOvlpRmSequenceGenCfg()

mul2mtCBOvlpRmSequenceGenCfg ( flags,
is_probe_leg = False,
trackingMode = "FTF" )

Definition at line 376 of file MuonMenuSequences.py.

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

◆ mul2mtSAOvlpRmSequenceGenCfg()

mul2mtSAOvlpRmSequenceGenCfg ( flags,
is_probe_leg = False )

Definition at line 153 of file MuonMenuSequences.py.

153def mul2mtSAOvlpRmSequenceGenCfg(flags, is_probe_leg=False):
154
155 (selAcc, sequenceOut) = muFastAlgSequenceCfg(flags, suffix="mt", is_probe_leg=is_probe_leg)
156
157 from TrigMuonHypo.TrigMuonHypoConfig import TrigMufastHypoAlgCfg, TrigMufastHypoToolFromDict
158 l2saHypo = TrigMufastHypoAlgCfg( flags,
159 name = 'TrigL2mtMufastHypoAlg',
160 MuonL2SAInfoFromMuFastAlg = muNames.L2SAName+"l2mtmode")
161
162 selAcc.addHypoAlgo(l2saHypo)
163
164 l2saSequence = MenuSequence(flags, selAcc,
165 HypoToolGen = TrigMufastHypoToolFromDict)
166
167
168 return l2saSequence
169
170
171
172#-----------------------------------------------------#

◆ muRoiClusterSequenceGenCfg()

muRoiClusterSequenceGenCfg ( flags)

Muon RoI Cluster Trigger for MS LLP Searches ##.

Definition at line 1014 of file MuonMenuSequences.py.

1014def muRoiClusterSequenceGenCfg(flags):
1015
1016 from TrigLongLivedParticles.TrigLongLivedParticlesConfig import MuonClusterConfig
1017 from TrigLongLivedParticlesHypo.TrigLongLivedParticlesHypoConfig import MuonClusterHypoAlgConfig, TrigLongLivedParticlesHypoToolFromDict
1018
1019 selAcc = SelectionCA('muRoIClusterSel')
1020
1021 viewName="MuRoIClusReco"
1022 viewcreator = CompFactory.ViewCreatorInitialROITool
1023 roiTool = viewcreator()
1024
1025 recoRoICluster = InEventRecoCA(name=viewName, RoITool = roiTool, mergeUsingFeature = False, RoIs = 'HLT_muVtxCluster_RoIs')
1026 recoRoICluster.mergeReco(MuonClusterConfig(flags, 'muvtxMuonCluster'))
1027 selAcc.mergeReco(recoRoICluster)
1028
1029
1030 hypoAlg = MuonClusterHypoAlgConfig( flags,
1031 name = 'MuRoiClusterHypoAlg')
1032
1033 selAcc.addHypoAlgo(hypoAlg)
1034
1035 muRoIClusterSequence = MenuSequence(flags, selAcc,
1036 HypoToolGen = TrigLongLivedParticlesHypoToolFromDict)
1037
1038 return muRoIClusterSequence
1039
1040
1041

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

◆ muNamesFS

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

Definition at line 16 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.17.0