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, 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)
 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 875 of file MuonMenuSequences.py.

875def efLateMuAlgSequenceCfg(flags, is_probe_leg=False):
876
877 from .MuonRecoSequences import muEFInsideOutRecoSequenceCfg, muonDecodeCfg, muonIDFastTrackingSequenceCfg
878 selAcc = SelectionCA('EFLateMuAlg', isProbe=is_probe_leg)
879
880 viewName = "EFLateMuReco"
881 viewcreator = CompFactory.ViewCreatorNamedROITool
882 roiTool = viewcreator(ROILinkName="feature")
883
884 recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView=True, mergeUsingFeature=True, isProbe=is_probe_leg)
885
886
887 #Clone and replace offline flags so we can set muon trigger specific values
888 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
889 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
890 #decode data in these RoIs
891 recoLateMu.mergeReco(muonDecodeCfg(muonflags,RoIs=recoLateMu.name+"RoIs"))
892 #ID fast tracking
893 recoLateMu.mergeReco(muonIDFastTrackingSequenceCfg(flags, recoLateMu.name+"RoIs","muonLate" ))
894 #inside-out reco sequence
895 recoLateMu.mergeReco(muEFInsideOutRecoSequenceCfg(muonflagsCB, recoLateMu.name+"RoIs", "LateMu", ''))
896 sequenceOut = muNames.EFCBInOutName+'_Late'
897
898
899 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
900 robPrefetchAlg = ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName)
901 selAcc.mergeReco(recoLateMu, robPrefetchCA = robPrefetchAlg)
902
903 return (selAcc, sequenceOut)
904
905
906@AccumulatorCache

◆ efLateMuRoIAlgSequenceCfg()

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

Definition at line 836 of file MuonMenuSequences.py.

836def efLateMuRoIAlgSequenceCfg(flags, is_probe_leg=False):
837
838 selAcc = SelectionCA('EFLateMuSel', isProbe=is_probe_leg)
839
840 viewName = "EFLateMuRoIReco"
841 viewcreator = CompFactory.ViewCreatorInitialROITool
842 roiTool = viewcreator()
843
844 recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg)
845
846 from .MuonRecoSequences import efLateMuRoISequenceCfg
847
848 #Get Late Muon RoIs
849 efLateMuRoIAcc, sequenceOut = efLateMuRoISequenceCfg(flags)
850 recoLateMu.mergeReco(efLateMuRoIAcc)
851
852 selAcc.mergeReco(recoLateMu)
853 return (selAcc, sequenceOut)
854
855
856@AccumulatorCache

◆ efLateMuRoISequenceGenCfg()

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

Definition at line 857 of file MuonMenuSequences.py.

857def efLateMuRoISequenceGenCfg(flags, is_probe_leg=False):
858
859 (selAcc, sequenceOut) = efLateMuRoIAlgSequenceCfg(flags, is_probe_leg)
860
861 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonLateMuRoIHypoAlgCfg, TrigMuonLateMuRoIHypoToolFromDict
862 latemuHypo = TrigMuonLateMuRoIHypoAlgCfg( flags,
863 name = 'TrigMuonLateMuRoIHypoAlg',
864 LateRoIs = sequenceOut)
865
866 selAcc.addHypoAlgo(latemuHypo)
867
868 latemuRoISequence = MenuSequence(flags, selAcc,
869 HypoToolGen = TrigMuonLateMuRoIHypoToolFromDict)
870
871
872 return latemuRoISequence
873
874

◆ efLateMuSequenceGenCfg()

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

Definition at line 907 of file MuonMenuSequences.py.

907def efLateMuSequenceGenCfg(flags, is_probe_leg=False):
908
909 (selAcc, sequenceOut) = efLateMuAlgSequenceCfg(flags, is_probe_leg=False)
910
911 # setup EFCB hypo
912 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg
913 trigMuonEFLateHypo = TrigMuonEFHypoAlgCfg( "TrigMuonEFCombinerLateMuHypoAlg", MuonDecisions = sequenceOut )
914
915 selAcc.addHypoAlgo(trigMuonEFLateHypo)
916 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFCombinerHypoToolFromDict
917
918 return MenuSequence(flags, selAcc,
919 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict )
920
921
922

◆ getBphysChainNames()

python.HLT.Muon.MuonMenuSequences.getBphysChainNames ( )

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

Definition at line 1037 of file MuonMenuSequences.py.

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

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

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

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

1060def getMultiTrackChainNames():
1061 from ..Config.GenerateMenuMT import GenerateMenuMT
1062 menu = GenerateMenuMT() # get menu singleton
1063 chains = [chain.name for chain in menu.chainsInMenu['Muon'] if "l2mt" in chain.name]
1064 chains += [chain.name for chain in menu.chainsInMenu['Bphysics'] if "l2mt" in chain.name]
1065 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 466 of file MuonMenuSequences.py.

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

◆ muEFCBFSAlgSequenceCfg()

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

EF CB full scan ###.

Definition at line 758 of file MuonMenuSequences.py.

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

◆ muEFCBFSSequenceGenCfg()

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

Definition at line 819 of file MuonMenuSequences.py.

819def muEFCBFSSequenceGenCfg(flags, is_probe_leg=False):
820
821 (selAcc, sequenceOut) = muEFCBFSAlgSequenceCfg(flags, is_probe_leg)
822
823 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromName
824 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
825 name = 'TrigMuonEFFSCombinerHypoAlg',
826 MuonDecisions = sequenceOut)
827
828 selAcc.addHypoAlgo(efmuCBHypo)
829
830 efmuCBSequence = MenuSequence(flags, selAcc,
831 HypoToolGen = TrigMuonEFCombinerHypoToolFromName)
832
833 return efmuCBSequence
834
835

◆ muEFCBIDperfSequenceGenCfg()

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

Definition at line 604 of file MuonMenuSequences.py.

604def muEFCBIDperfSequenceGenCfg(flags, is_probe_leg=False):
605
606 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idperf', is_probe_leg)
607
608 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
609 efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
610 name = 'TrigMuonEFCombinerIDperfHypoAlg',
611 IncludeSAmuons=True,
612 MuonDecisions = sequenceOut,
613 MapToPreviousDecisions=True)
614
615 selAcc.addHypoAlgo(efmuCBHypo)
616
617 efmuCBSequence = MenuSequence(flags, selAcc,
618 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
619
620 return efmuCBSequence
621
622
623@AccumulatorCache

◆ muEFCBidReuseSequenceGenCfg()

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

Definition at line 585 of file MuonMenuSequences.py.

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

◆ muEFCBl2ioSequenceGenCfg()

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

Definition at line 547 of file MuonMenuSequences.py.

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

◆ muEFCBl2mtSequenceGenCfg()

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

Definition at line 566 of file MuonMenuSequences.py.

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

◆ muEFCBLRTAlgSequenceCfg()

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

Definition at line 641 of file MuonMenuSequences.py.

641def muEFCBLRTAlgSequenceCfg(flags, selCAName='', is_probe_leg=False):
642
643 selAccCB = SelectionCA('EFMuCBLRTSel'+selCAName, isProbe=is_probe_leg)
644
645 viewName="EFMuCBLRTReco"
646 ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
647 roiTool = ViewCreatorTool(ROILinkName="l2lrtroi")
648
649 recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, mergeUsingFeature=True, isProbe=is_probe_leg)
650
651 from .MuonRecoSequences import muEFCBRecoSequenceCfg
652
653 #outside-in reco sequence
654 muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
655 recoCB.mergeReco(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "LRT", ''))
656 sequenceOut = muNamesLRT.EFCBName
657
658 selAccCB.mergeReco(recoCB)
659
660 return (selAccCB, sequenceOut)
661
662
663@AccumulatorCache

◆ muEFCBLRTIDperfSequenceGenCfg()

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

Definition at line 684 of file MuonMenuSequences.py.

684def muEFCBLRTIDperfSequenceGenCfg(flags, is_probe_leg=False):
685
686 (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, 'idperf', is_probe_leg)
687
688 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
689 efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
690 name = 'TrigMuonEFCombinerHypoAlgLRTIDPerf',
691 IncludeSAmuons=True,
692 MuonDecisions = sequenceOut,
693 MapToPreviousDecisions=True)
694
695
696 selAcc.addHypoAlgo(efmuCBLRTHypo)
697
698 efmuCBSequence = MenuSequence(flags, selAcc,
699 HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
700
701 return efmuCBSequence
702
703

◆ muEFCBLRTSequenceGenCfg()

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

Definition at line 664 of file MuonMenuSequences.py.

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

◆ muEFCBSequenceGenCfg()

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

Definition at line 528 of file MuonMenuSequences.py.

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

◆ muEFIDtpSequenceGenCfg()

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

Definition at line 624 of file MuonMenuSequences.py.

624def muEFIDtpSequenceGenCfg(flags, is_probe_leg=False):
625
626 (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idtp', is_probe_leg)
627
628 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFIdtpHypoAlgCfg, TrigMuonEFIdtpHypoToolFromDict
629 efmuCBHypo = TrigMuonEFIdtpHypoAlgCfg( flags,
630 name = 'TrigMuonEFIdtpHypoAlg')
631
632
633 selAcc.addHypoAlgo(efmuCBHypo)
634
635 efmuCBSequence = MenuSequence(flags, selAcc,
636 HypoToolGen = TrigMuonEFIdtpHypoToolFromDict)
637
638 return efmuCBSequence
639
640

◆ muEFIsoAlgSequenceCfg()

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

efMuiso step ###

Definition at line 926 of file MuonMenuSequences.py.

926def muEFIsoAlgSequenceCfg(flags, doMSiso=False, is_probe_leg=False):
927 name = ""
928 if doMSiso:
929 name = "MS"
930
931
932 selAccIso = SelectionCA('EFMuIso'+name, isProbe=is_probe_leg)
933
934 viewName="EFMuIsoReco"+name
935 if doMSiso:
936 roisWriteHandleKey = "Roi_MuonIsoMS"
937 else:
938 roisWriteHandleKey = recordable("HLT_Roi_MuonIso")
939
940 roiTool = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = roisWriteHandleKey,
941 RoIEtaWidth=flags.Trigger.InDetTracking.muonIso.etaHalfWidth,
942 RoIPhiWidth=flags.Trigger.InDetTracking.muonIso.phiHalfWidth,
943 RoIZedWidth=flags.Trigger.InDetTracking.muonIso.zedHalfWidth)
944
945 recoIso = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg, mergeUsingFeature=True,
946 PlaceMuonInView=True, InViewMuons = "IsoViewMuons"+name, InViewMuonCandidates = "IsoMuonCandidates"+name)
947
948
949
950 from .MuonRecoSequences import efmuisoRecoSequenceCfg
951 sequenceOut = muNames.EFIsoMuonName+name
952 recoIso.mergeReco(efmuisoRecoSequenceCfg( flags, viewName+"RoIs", "IsoViewMuons"+name, doMSiso ))
953
954
955 from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si
956 robPrefetchAlg = ROBPrefetchingAlgCfg_Si(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
957
958 selAccIso.mergeReco(recoIso, robPrefetchCA = robPrefetchAlg)
959
960 return (selAccIso, sequenceOut)
961
962
963@AccumulatorCache

◆ muEFIsoSequenceGenCfg()

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

Definition at line 964 of file MuonMenuSequences.py.

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

◆ muEFMSIsoSequenceGenCfg()

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

Definition at line 982 of file MuonMenuSequences.py.

982def muEFMSIsoSequenceGenCfg(flags, is_probe_leg=False):
983
984 (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, True, is_probe_leg)
985
986 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
987 efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
988 name = 'EFMuMSisoHypoAlg',
989 EFMuonsName = sequenceOut)
990
991 selAcc.addHypoAlgo(efmuisoHypo)
992
993 efmuisoSequence = MenuSequence(flags, selAcc,
994 HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
995
996 return efmuisoSequence
997
998

◆ muEFSAAlgSequenceCfg()

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

EFSA step ###.

Definition at line 395 of file MuonMenuSequences.py.

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

◆ muEFSAFSAlgSequenceCfg()

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

EF SA full scan ###.

Definition at line 708 of file MuonMenuSequences.py.

708def muEFSAFSAlgSequenceCfg(flags):
709
710 selAccMS = SelectionCA('EFMuMSSel_FS')
711
712 viewName="EFMuMSReco_FS"
713 ViewCreatorFSROITool=CompFactory.ViewCreatorFSROITool
714 roiTool = ViewCreatorFSROITool(RoisWriteHandleKey="MuonFS_RoIs")
715 requireParentView = False
716
717 recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView)
718
719
720 #Clone and replace offline flags so we can set muon trigger specific values
721 muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
722 from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
723 recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=recoMS.name+"RoIs"))
724
725 muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags, recoMS.name+'RoIs', 'FS' )
726 recoMS.mergeReco(muEFSARecoSequenceAcc)
727
728 selAccMS.mergeReco(recoMS)
729
730 return (selAccMS, sequenceOut)
731
732
733@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 734 of file MuonMenuSequences.py.

734def muEFSAFSSequenceGenCfg(flags, is_probe_leg=False):
735
736 (selAcc, sequenceOut) = muEFSAFSAlgSequenceCfg(flags)
737
738 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromName
739
740 efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
741 name = 'TrigMuonEFMSonlyHypo_FS',
742 MuonDecisions = sequenceOut,
743 IncludeSAmuons=True)
744
745 selAcc.addHypoAlgo(efmuMSHypo)
746
747 efmuMSSequence = MenuSequence(flags, selAcc,
748 HypoToolGen = TrigMuonEFMSonlyHypoToolFromName)
749
750
751 return efmuMSSequence
752
753

◆ muEFSASequenceGenCfg()

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

Definition at line 442 of file MuonMenuSequences.py.

442def muEFSASequenceGenCfg(flags, is_probe_leg=False, useBucketFilter=False, useNewFast=False):
443
444 (selAcc, sequenceOut) = muEFSAAlgSequenceCfg(flags, is_probe_leg, useBucketFilter=useBucketFilter, useNewFast=useNewFast)
445
446 from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromDict
447 suffix = f'{"_newFast" if useNewFast else ""}{"_mlbkt" if useBucketFilter else ""}'
448 efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
449 name = f'TrigMuonEFMSonlyHypo_RoI{suffix}',
450 MuonDecisions = sequenceOut,
451 IncludeSAmuons=True)
452
453 selAcc.addHypoAlgo(efmuMSHypo)
454
455 efmuMSSequence = MenuSequence(flags, selAcc,
456 HypoToolGen = TrigMuonEFMSonlyHypoToolFromDict)
457
458
459 return efmuMSSequence
460
461

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

1003def muRoiClusterSequenceGenCfg(flags):
1004
1005 from TrigLongLivedParticles.TrigLongLivedParticlesConfig import MuonClusterConfig
1006 from TrigLongLivedParticlesHypo.TrigLongLivedParticlesHypoConfig import MuonClusterHypoAlgConfig, TrigLongLivedParticlesHypoToolFromDict
1007
1008 selAcc = SelectionCA('muRoIClusterSel')
1009
1010 viewName="MuRoIClusReco"
1011 viewcreator = CompFactory.ViewCreatorInitialROITool
1012 roiTool = viewcreator()
1013
1014 recoRoICluster = InEventRecoCA(name=viewName, RoITool = roiTool, mergeUsingFeature = False, RoIs = 'HLT_muVtxCluster_RoIs')
1015 recoRoICluster.mergeReco(MuonClusterConfig(flags, 'muvtxMuonCluster'))
1016 selAcc.mergeReco(recoRoICluster)
1017
1018
1019 hypoAlg = MuonClusterHypoAlgConfig( flags,
1020 name = 'MuRoiClusterHypoAlg')
1021
1022 selAcc.addHypoAlgo(hypoAlg)
1023
1024 muRoIClusterSequence = MenuSequence(flags, selAcc,
1025 HypoToolGen = TrigLongLivedParticlesHypoToolFromDict)
1026
1027 return muRoIClusterSequence
1028
1029
1030

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.16.1