ATLAS Offline Software
MuonMenuSequences.py
Go to the documentation of this file.
1 #
2 # Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 #
4 
5 from ..Config.MenuComponents import MenuSequence, SelectionCA, InViewRecoCA, InEventRecoCA
6 
7 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
8 from AthenaConfiguration.AccumulatorCache import AccumulatorCache
9 from AthenaCommon.CFElements import parOR, seqAND
10 from AthenaCommon.Logging import logging
11 from AthenaConfiguration.ComponentFactory import CompFactory
12 log = logging.getLogger(__name__)
13 
14 #muon container names (for RoI based sequences)
15 from .MuonRecoSequences import muonNames
16 muNames = muonNames().getNames('RoI')
17 muNamesLRT = muonNames().getNames('LRT')
18 muNamesFS = muonNames().getNames('FS')
19 from TrigEDMConfig.TriggerEDM import recordable
20 
21 #-----------------------------------------------------#
22 
24 def 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 
77 def 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
105 def 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
124 def 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
143 def 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 #-----------------------------------------------------#
163 
165 
166 def 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
259 def 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
279 def 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 
298 def 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
333 def 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
354 def 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
373 def 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 
391 
394 
395 def muEFSAAlgSequenceCfg(flags, is_probe_leg=False):
396 
397  selAccMS = SelectionCA('EFMuMSSel_RoI', isProbe=is_probe_leg)
398 
399  viewName="EFMuMSReco_RoI"
400  ViewCreatorFetchFromViewROITool=CompFactory.ViewCreatorFetchFromViewROITool
401  #temporarily using different view names until L2 SA sequence is migrated to CA
402  roiTool = ViewCreatorFetchFromViewROITool(RoisWriteHandleKey="HLT_Roi_L2SAMuonForEF", InViewRoIs = "forMS", ViewToFetchFrom = "L2MuFastRecoViews")
403  requireParentView = True
404 
405  recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView, isProbe=is_probe_leg)
406 
407 
408  #Clone and replace offline flags so we can set muon trigger specific values
409  muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
410  from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
411  #Run decoding again since we are using updated RoIs
412  recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=viewName+"RoIs"))
413 
414  muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags, viewName+'RoIs', 'RoI' )
415  recoMS.mergeReco(muEFSARecoSequenceAcc)
416 
417  from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
418  prefetch=ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
419  selAccMS.mergeReco(recoMS, robPrefetchCA=prefetch)
420 
421  return (selAccMS, sequenceOut)
422 
423 
424 @AccumulatorCache
425 def muEFSASequenceGenCfg(flags, is_probe_leg=False):
426 
427  (selAcc, sequenceOut) = muEFSAAlgSequenceCfg(flags, is_probe_leg)
428 
429  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromDict
430  efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
431  name = 'TrigMuonEFMSonlyHypo_RoI',
432  MuonDecisions = sequenceOut,
433  IncludeSAmuons=True)
434 
435  selAcc.addHypoAlgo(efmuMSHypo)
436 
437  efmuMSSequence = MenuSequence(flags, selAcc,
438  HypoToolGen = TrigMuonEFMSonlyHypoToolFromDict)
439 
440 
441  return efmuMSSequence
442 
443 
444 
447 
448 def muEFCBAlgSequenceCfg(flags, suffix, selCAName='', is_probe_leg=False):
449 
450  from .MuonRecoSequences import isCosmic
451  selAccCB = SelectionCA('EFMuCBSel_RoI'+selCAName+suffix, isProbe=is_probe_leg)
452 
453  viewName="EFMuCBReco_RoI"+suffix if not isCosmic(flags) else "CosmicEFCB"
454  ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
455  #temporarily using different view names until L2 SA sequence is migrated to CA
456  roiTool = ViewCreatorTool(ROILinkName="l2cbroi")
457 
458  recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg, mergeUsingFeature=True)
459 
460  #By default the EFCB sequence will run both outside-in and
461  #(if zero muons are found) inside-out reconstruction
462  from TrigMuonEF.TrigMuonEFConfig import MuonFilterAlgCfg, MergeEFMuonsAlgCfg
463  from .MuonRecoSequences import muEFCBRecoSequenceCfg, muEFInsideOutRecoSequenceCfg
464 
465  acc = ComponentAccumulator()
466  seqmerge = seqAND("muonCBInsideOutMergingSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
467  acc.addSequence(seqmerge)
468 
469  #outside-in reco sequence
470  acc2 = ComponentAccumulator()
471  seqreco = parOR("muonEFCBandInsideOutRecoSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
472  acc2.addSequence(seqreco)
473  muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
474  acc2.merge(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "RoI", suffix ), sequenceName=seqreco.name)
475  sequenceOutCB = muNames.EFCBOutInName+suffix
476 
477  #Algorithm to filter events with no muons
478  acc3 = ComponentAccumulator()
479  seqfilter = seqAND("muonEFInsideOutSequence{}{}".format(suffix, "_probe" if is_probe_leg else ""))
480  acc3.addSequence(seqfilter)
481  muonFilter = MuonFilterAlgCfg(flags, name="FilterZeroMuons"+suffix, MuonContainerLocation=sequenceOutCB)
482  acc3.merge(muonFilter, sequenceName=seqfilter.name)
483 
484  #inside-out reco sequence - runs only if filter is passed
485  acc4 = ComponentAccumulator()
486  seqio = parOR("efmuInsideOutViewNode_RoI{}{}".format(suffix, "_probe" if is_probe_leg else ""))
487  acc4.addSequence(seqio)
488  acc4.merge(muEFInsideOutRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "RoI", suffix), sequenceName=seqio.name+suffix)
489  sequenceOutInsideOut = muNames.EFCBInOutName+suffix
490 
491  acc3.merge(acc4, sequenceName=seqfilter.name)
492  acc2.merge(acc3, sequenceName=seqreco.name)
493  acc.merge(acc2, sequenceName=seqmerge.name)
494  #Merge muon containers from outside-in and inside-out reco
495  if suffix != '':
496  mergedMuonOutputLocation = recordable(muNames.EFCBName+'_'+suffix)
497  else:
498  mergedMuonOutputLocation = muNames.EFCBName
499  mergeMuons = MergeEFMuonsAlgCfg(flags, name="MergeEFMuons"+suffix, MuonCBContainerLocation=sequenceOutCB,
500  MuonInsideOutContainerLocation=sequenceOutInsideOut, MuonOutputLocation=mergedMuonOutputLocation)
501 
502  acc.merge(mergeMuons, sequenceName=seqmerge.name)
503  recoCB.mergeReco(acc)
504  selAccCB.mergeReco(recoCB)
505 
506  return (selAccCB, muNames.EFCBName)
507 
508 
509 @AccumulatorCache
510 def muEFCBSequenceGenCfg(flags, is_probe_leg=False):
511 
512  (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', '', is_probe_leg)
513 
514  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
515  efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
516  name = 'TrigMuonEFCombinerHypoAlg',
517  MuonDecisions = sequenceOut,
518  MapToPreviousDecisions=True)
519 
520  selAcc.addHypoAlgo(efmuCBHypo)
521 
522  efmuCBSequence = MenuSequence(flags, selAcc,
523  HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
524 
525  return efmuCBSequence
526 
527 
528 @AccumulatorCache
529 def muEFCBl2ioSequenceGenCfg(flags, is_probe_leg=False):
530 
531  (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags,'IOmode', '', is_probe_leg)
532 
533  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
534  efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
535  name = 'TrigMuonEFCombinerHypoAlgIOmode',
536  MuonDecisions = sequenceOut+'_IOmode',
537  MapToPreviousDecisions=True)
538 
539  selAcc.addHypoAlgo(efmuCBHypo)
540 
541  efmuCBSequence = MenuSequence(flags, selAcc,
542  HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
543 
544  return efmuCBSequence
545 
546 
547 @AccumulatorCache
548 def muEFCBl2mtSequenceGenCfg(flags, is_probe_leg=False):
549 
550  (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags,'l2mtmode', '', is_probe_leg)
551 
552  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
553  efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
554  name = 'TrigMuonEFCombinerHypoAlgl2mtmode',
555  MuonDecisions = sequenceOut+'_l2mtmode',
556  MapToPreviousDecisions=True)
557 
558  selAcc.addHypoAlgo(efmuCBHypo)
559 
560  efmuCBSequence = MenuSequence(flags, selAcc,
561  HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
562 
563  return efmuCBSequence
564 
565 
566 @AccumulatorCache
567 def muEFCBidReuseSequenceGenCfg(flags, is_probe_leg=False):
568 
569  (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, 'idReuse', '', is_probe_leg)
570 
571  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
572  efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
573  name = 'TrigMuonEFCombinerHypoAlgidReuse',
574  MuonDecisions = sequenceOut+'_idReuse',
575  MapToPreviousDecisions=True)
576 
577  selAcc.addHypoAlgo(efmuCBHypo)
578 
579  efmuCBSequence = MenuSequence(flags, selAcc,
580  HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
581 
582  return efmuCBSequence
583 
584 
585 @AccumulatorCache
586 def muEFCBIDperfSequenceGenCfg(flags, is_probe_leg=False):
587 
588  (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idperf', is_probe_leg)
589 
590  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
591  efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
592  name = 'TrigMuonEFCombinerIDperfHypoAlg',
593  IncludeSAmuons=True,
594  MuonDecisions = sequenceOut,
595  MapToPreviousDecisions=True)
596 
597  selAcc.addHypoAlgo(efmuCBHypo)
598 
599  efmuCBSequence = MenuSequence(flags, selAcc,
600  HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
601 
602  return efmuCBSequence
603 
604 
605 @AccumulatorCache
606 def muEFIDtpSequenceGenCfg(flags, is_probe_leg=False):
607 
608  (selAcc, sequenceOut) = muEFCBAlgSequenceCfg(flags, '', 'idtp', is_probe_leg)
609 
610  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFIdtpHypoAlgCfg, TrigMuonEFIdtpHypoToolFromDict
611  efmuCBHypo = TrigMuonEFIdtpHypoAlgCfg( flags,
612  name = 'TrigMuonEFIdtpHypoAlg')
613 
614 
615  selAcc.addHypoAlgo(efmuCBHypo)
616 
617  efmuCBSequence = MenuSequence(flags, selAcc,
618  HypoToolGen = TrigMuonEFIdtpHypoToolFromDict)
619 
620  return efmuCBSequence
621 
622 
623 def muEFCBLRTAlgSequenceCfg(flags, selCAName='', is_probe_leg=False):
624 
625  selAccCB = SelectionCA('EFMuCBLRTSel'+selCAName, isProbe=is_probe_leg)
626 
627  viewName="EFMuCBLRTReco"
628  ViewCreatorTool=CompFactory.ViewCreatorNamedROITool
629  roiTool = ViewCreatorTool(ROILinkName="l2lrtroi")
630 
631  recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, mergeUsingFeature=True, isProbe=is_probe_leg)
632 
633  from .MuonRecoSequences import muEFCBRecoSequenceCfg
634 
635  #outside-in reco sequence
636  muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
637  recoCB.mergeReco(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "LRT", ''))
638  sequenceOut = muNamesLRT.EFCBName
639 
640  selAccCB.mergeReco(recoCB)
641 
642  return (selAccCB, sequenceOut)
643 
644 
645 @AccumulatorCache
646 def muEFCBLRTSequenceGenCfg(flags, is_probe_leg=False):
647 
648  (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, '', is_probe_leg)
649 
650  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
651  efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
652  name = 'TrigMuonEFCombinerHypoAlgLRT',
653  MuonDecisions = sequenceOut,
654  MapToPreviousDecisions=True)
655 
656 
657  selAcc.addHypoAlgo(efmuCBLRTHypo)
658 
659  efmuCBSequence = MenuSequence(flags, selAcc,
660  HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
661 
662  return efmuCBSequence
663 
664 
665 @AccumulatorCache
666 def muEFCBLRTIDperfSequenceGenCfg(flags, is_probe_leg=False):
667 
668  (selAcc, sequenceOut) = muEFCBLRTAlgSequenceCfg(flags, 'idperf', is_probe_leg)
669 
670  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromDict
671  efmuCBLRTHypo = TrigMuonEFHypoAlgCfg( flags,
672  name = 'TrigMuonEFCombinerHypoAlgLRTIDPerf',
673  IncludeSAmuons=True,
674  MuonDecisions = sequenceOut,
675  MapToPreviousDecisions=True)
676 
677 
678  selAcc.addHypoAlgo(efmuCBLRTHypo)
679 
680  efmuCBSequence = MenuSequence(flags, selAcc,
681  HypoToolGen = TrigMuonEFCombinerHypoToolFromDict)
682 
683  return efmuCBSequence
684 
685 
686 
689 
691 
692  selAccMS = SelectionCA('EFMuMSSel_FS')
693 
694  viewName="EFMuMSReco_FS"
695  ViewCreatorFSROITool=CompFactory.ViewCreatorFSROITool
696  roiTool = ViewCreatorFSROITool(RoisWriteHandleKey="MuonFS_RoIs")
697  requireParentView = False
698 
699  recoMS = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = requireParentView)
700 
701 
702  #Clone and replace offline flags so we can set muon trigger specific values
703  muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
704  from .MuonRecoSequences import muEFSARecoSequenceCfg, muonDecodeCfg
705  recoMS.mergeReco(muonDecodeCfg(muonflags,RoIs=recoMS.name+"RoIs"))
706 
707  muEFSARecoSequenceAcc, sequenceOut = muEFSARecoSequenceCfg(muonflags, recoMS.name+'RoIs', 'FS' )
708  recoMS.mergeReco(muEFSARecoSequenceAcc)
709 
710  selAccMS.mergeReco(recoMS)
711 
712  return (selAccMS, sequenceOut)
713 
714 
715 @AccumulatorCache
716 def muEFSAFSSequenceGenCfg(flags, is_probe_leg=False):
717 
718  (selAcc, sequenceOut) = muEFSAFSAlgSequenceCfg(flags)
719 
720  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFMSonlyHypoToolFromName
721 
722  efmuMSHypo = TrigMuonEFHypoAlgCfg( flags,
723  name = 'TrigMuonEFMSonlyHypo_FS',
724  MuonDecisions = sequenceOut,
725  IncludeSAmuons=True)
726 
727  selAcc.addHypoAlgo(efmuMSHypo)
728 
729  efmuMSSequence = MenuSequence(flags, selAcc,
730  HypoToolGen = TrigMuonEFMSonlyHypoToolFromName)
731 
732 
733  return efmuMSSequence
734 
735 
736 
739 
740 def muEFCBFSAlgSequenceCfg(flags, is_probe_leg=False):
741 
742  selAccCB = SelectionCA('EFMuCBSel_FS', isProbe=is_probe_leg)
743 
744  viewName="EFMuCBReco_FS"
745  #temporarily using different view names until L2 SA sequence is migrated to CA
746  roiTool = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = "MuonCandidates_FS_ROIs")
747 
748  recoCB = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView = True, isProbe=is_probe_leg, mergeUsingFeature=True,
749  PlaceMuonInView=True, InViewMuons = "InViewMuons", InViewMuonCandidates = "MuonCandidates_FS")
750 
751 
752  from TrigMuonEF.TrigMuonEFConfig import MuonFilterAlgCfg, MergeEFMuonsAlgCfg
753  from .MuonRecoSequences import muEFCBRecoSequenceCfg, muEFInsideOutRecoSequenceCfg
754  #outside-in reco sequence
755  acc = ComponentAccumulator()
756  seqmerge = seqAND("muonCBInsideOutMergingSequenceEFCBFS{}".format("_probe" if is_probe_leg else ""))
757  acc.addSequence(seqmerge)
758 
759  muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
760  acc2 = ComponentAccumulator()
761  seqreco = parOR("muonEFCBFSInsideOutRecoSequence{}".format("_probe" if is_probe_leg else ""))
762  acc2.addSequence(seqreco)
763 
764  acc2.merge(muEFCBRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "FS", ''), sequenceName=seqreco.name)
765  sequenceOutCB = muNamesFS.EFCBOutInName
766 
767  #Alg fitltering for no muon events
768  muonFilter = MuonFilterAlgCfg(flags, name="FilterZeroMuonsEFCBFS", MuonContainerLocation = sequenceOutCB)
769 
770  acc3 = ComponentAccumulator()
771  seqfilt = seqAND("muonEFCBFSInsideOutSequence{}".format("_probe" if is_probe_leg else ""))
772  acc3.addSequence(seqfilt)
773  acc3.merge(muonFilter, sequenceName=seqfilt.name)
774 
775 
776  #If filter passed
777  acc4 = ComponentAccumulator()
778  seqio = parOR("efmuInsideOutViewNode_FS{}".format("_probe" if is_probe_leg else ""))
779  acc4.addSequence(seqio)
780 
781  muonEFInsideOutRecoAlgSequence = muEFInsideOutRecoSequenceCfg(muonflagsCB, viewName+"RoIs", "FS", '' )
782  acc4.merge(muonEFInsideOutRecoAlgSequence, sequenceName=seqio.name)
783  acc3.merge(acc4, sequenceName=seqfilt.name)
784  acc2.merge(acc3, sequenceName=seqreco.name)
785  acc.merge(acc2, sequenceName=seqmerge.name)
786  sequenceOutInsideOut = muNamesFS.EFCBInOutName
787 
788  #Merge muon containers from O-I and I-O reco
789  mergeMuons = MergeEFMuonsAlgCfg(flags, name="MergeEFCBFSMuons", MuonCBContainerLocation = sequenceOutCB,
790  MuonInsideOutContainerLocation = sequenceOutInsideOut, MuonOutputLocation = muNamesFS.EFCBName)
791  acc.merge(mergeMuons, sequenceName=seqmerge.name)
792  recoCB.mergeReco(acc)
793 
794  sequenceOut = muNamesFS.EFCBName
795  selAccCB.mergeReco(recoCB)
796 
797  return (selAccCB, sequenceOut)
798 
799 
800 @AccumulatorCache
801 def muEFCBFSSequenceGenCfg(flags, is_probe_leg=False):
802 
803  (selAcc, sequenceOut) = muEFCBFSAlgSequenceCfg(flags, is_probe_leg)
804 
805  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg, TrigMuonEFCombinerHypoToolFromName
806  efmuCBHypo = TrigMuonEFHypoAlgCfg( flags,
807  name = 'TrigMuonEFFSCombinerHypoAlg',
808  MuonDecisions = sequenceOut)
809 
810  selAcc.addHypoAlgo(efmuCBHypo)
811 
812  efmuCBSequence = MenuSequence(flags, selAcc,
813  HypoToolGen = TrigMuonEFCombinerHypoToolFromName)
814 
815  return efmuCBSequence
816 
817 
818 def efLateMuRoIAlgSequenceCfg(flags, is_probe_leg=False):
819 
820  selAcc = SelectionCA('EFLateMuSel', isProbe=is_probe_leg)
821 
822  viewName = "EFLateMuRoIReco"
823  viewcreator = CompFactory.ViewCreatorInitialROITool
824  roiTool = viewcreator()
825 
826  recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg)
827 
828  from .MuonRecoSequences import efLateMuRoISequenceCfg
829 
830  #Get Late Muon RoIs
831  efLateMuRoIAcc, sequenceOut = efLateMuRoISequenceCfg(flags)
832  recoLateMu.mergeReco(efLateMuRoIAcc)
833 
834  selAcc.mergeReco(recoLateMu)
835  return (selAcc, sequenceOut)
836 
837 
838 @AccumulatorCache
839 def efLateMuRoISequenceGenCfg(flags, is_probe_leg=False):
840 
841  (selAcc, sequenceOut) = efLateMuRoIAlgSequenceCfg(flags, is_probe_leg)
842 
843  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonLateMuRoIHypoAlgCfg, TrigMuonLateMuRoIHypoToolFromDict
844  latemuHypo = TrigMuonLateMuRoIHypoAlgCfg( flags,
845  name = 'TrigMuonLateMuRoIHypoAlg',
846  LateRoIs = sequenceOut)
847 
848  selAcc.addHypoAlgo(latemuHypo)
849 
850  latemuRoISequence = MenuSequence(flags, selAcc,
851  HypoToolGen = TrigMuonLateMuRoIHypoToolFromDict)
852 
853 
854  return latemuRoISequence
855 
856 
857 def efLateMuAlgSequenceCfg(flags, is_probe_leg=False):
858 
859  from .MuonRecoSequences import muEFInsideOutRecoSequenceCfg, muonDecodeCfg, muonIDFastTrackingSequenceCfg
860  selAcc = SelectionCA('EFLateMuAlg', isProbe=is_probe_leg)
861 
862  viewName = "EFLateMuReco"
863  viewcreator = CompFactory.ViewCreatorNamedROITool
864  roiTool = viewcreator(ROILinkName="feature")
865 
866  recoLateMu = InViewRecoCA(name=viewName, RoITool = roiTool, RequireParentView=True, mergeUsingFeature=True, isProbe=is_probe_leg)
867 
868 
869  #Clone and replace offline flags so we can set muon trigger specific values
870  muonflagsCB = flags.cloneAndReplace('Muon', 'Trigger.Offline.Muon').cloneAndReplace('MuonCombined', 'Trigger.Offline.Combined.MuonCombined')
871  muonflags = flags.cloneAndReplace('Muon', 'Trigger.Offline.SA.Muon')
872  #decode data in these RoIs
873  recoLateMu.mergeReco(muonDecodeCfg(muonflags,RoIs=recoLateMu.name+"RoIs"))
874  #ID fast tracking
875  recoLateMu.mergeReco(muonIDFastTrackingSequenceCfg(flags, recoLateMu.name+"RoIs","muonLate" ))
876  #inside-out reco sequence
877  recoLateMu.mergeReco(muEFInsideOutRecoSequenceCfg(muonflagsCB, recoLateMu.name+"RoIs", "LateMu", ''))
878  sequenceOut = muNames.EFCBInOutName+'_Late'
879 
880 
881  from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Muon
882  robPrefetchAlg = ROBPrefetchingAlgCfg_Muon(flags, nameSuffix=viewName)
883  selAcc.mergeReco(recoLateMu, robPrefetchCA = robPrefetchAlg)
884 
885  return (selAcc, sequenceOut)
886 
887 
888 @AccumulatorCache
889 def efLateMuSequenceGenCfg(flags, is_probe_leg=False):
890 
891  (selAcc, sequenceOut) = efLateMuAlgSequenceCfg(flags, is_probe_leg=False)
892 
893  # setup EFCB hypo
894  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFHypoAlgCfg
895  trigMuonEFLateHypo = TrigMuonEFHypoAlgCfg( "TrigMuonEFCombinerLateMuHypoAlg", MuonDecisions = sequenceOut )
896 
897  selAcc.addHypoAlgo(trigMuonEFLateHypo)
898  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFCombinerHypoToolFromDict
899 
900  return MenuSequence(flags, selAcc,
901  HypoToolGen = TrigMuonEFCombinerHypoToolFromDict )
902 
903 
904 
905 
908 def muEFIsoAlgSequenceCfg(flags, doMSiso=False, is_probe_leg=False):
909  name = ""
910  if doMSiso:
911  name = "MS"
912 
913 
914  selAccIso = SelectionCA('EFMuIso'+name, isProbe=is_probe_leg)
915 
916  viewName="EFMuIsoReco"+name
917  if doMSiso:
918  roisWriteHandleKey = "Roi_MuonIsoMS"
919  else:
920  roisWriteHandleKey = recordable("HLT_Roi_MuonIso")
921 
922  roiTool = CompFactory.ViewCreatorCentredOnIParticleROITool(RoisWriteHandleKey = roisWriteHandleKey,
923  RoIEtaWidth=flags.Trigger.InDetTracking.muonIso.etaHalfWidth,
924  RoIPhiWidth=flags.Trigger.InDetTracking.muonIso.phiHalfWidth,
925  RoIZedWidth=flags.Trigger.InDetTracking.muonIso.zedHalfWidth)
926 
927  recoIso = InViewRecoCA(name=viewName, RoITool = roiTool, isProbe=is_probe_leg, mergeUsingFeature=True,
928  PlaceMuonInView=True, InViewMuons = "IsoViewMuons"+name, InViewMuonCandidates = "IsoMuonCandidates"+name)
929 
930 
931 
932  from .MuonRecoSequences import efmuisoRecoSequenceCfg
933  sequenceOut = muNames.EFIsoMuonName+name
934  recoIso.mergeReco(efmuisoRecoSequenceCfg( flags, viewName+"RoIs", "IsoViewMuons"+name, doMSiso ))
935 
936 
937  from TrigGenericAlgs.TrigGenericAlgsConfig import ROBPrefetchingAlgCfg_Si
938  robPrefetchAlg = ROBPrefetchingAlgCfg_Si(flags, nameSuffix=viewName+'_probe' if is_probe_leg else viewName)
939 
940  selAccIso.mergeReco(recoIso, robPrefetchCA = robPrefetchAlg)
941 
942  return (selAccIso, sequenceOut)
943 
944 
945 @AccumulatorCache
946 def muEFIsoSequenceGenCfg(flags, is_probe_leg=False):
947 
948  (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, False, is_probe_leg)
949 
950  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
951  efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
952  name = 'EFMuisoHypoAlg',
953  EFMuonsName = sequenceOut)
954 
955  selAcc.addHypoAlgo(efmuisoHypo)
956 
957  efmuisoSequence = MenuSequence(flags, selAcc,
958  HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
959 
960  return efmuisoSequence
961 
962 
963 @AccumulatorCache
964 def muEFMSIsoSequenceGenCfg(flags, is_probe_leg=False):
965 
966  (selAcc, sequenceOut) = muEFIsoAlgSequenceCfg(flags, True, is_probe_leg)
967 
968  from TrigMuonHypo.TrigMuonHypoConfig import TrigMuonEFTrackIsolationHypoAlgCfg, TrigMuonEFTrackIsolationHypoToolFromDict
969  efmuisoHypo = TrigMuonEFTrackIsolationHypoAlgCfg( flags,
970  name = 'EFMuMSisoHypoAlg',
971  EFMuonsName = sequenceOut)
972 
973  selAcc.addHypoAlgo(efmuisoHypo)
974 
975  efmuisoSequence = MenuSequence(flags, selAcc,
976  HypoToolGen = TrigMuonEFTrackIsolationHypoToolFromDict)
977 
978  return efmuisoSequence
979 
980 
981 
984 
986 
987  from TrigLongLivedParticles.TrigLongLivedParticlesConfig import MuonClusterConfig
988  from TrigLongLivedParticlesHypo.TrigLongLivedParticlesHypoConfig import MuonClusterHypoAlgConfig, TrigLongLivedParticlesHypoToolFromDict
989 
990  selAcc = SelectionCA('muRoIClusterSel')
991 
992  viewName="MuRoIClusReco"
993  viewcreator = CompFactory.ViewCreatorInitialROITool
994  roiTool = viewcreator()
995 
996  recoRoICluster = InEventRecoCA(name=viewName, RoITool = roiTool, mergeUsingFeature = False, RoIs = 'HLT_muVtxCluster_RoIs')
997  recoRoICluster.mergeReco(MuonClusterConfig(flags, 'muvtxMuonCluster'))
998  selAcc.mergeReco(recoRoICluster)
999 
1000 
1001  hypoAlg = MuonClusterHypoAlgConfig( flags,
1002  name = 'MuRoiClusterHypoAlg')
1003 
1004  selAcc.addHypoAlgo(hypoAlg)
1005 
1006  muRoIClusterSequence = MenuSequence(flags, selAcc,
1007  HypoToolGen = TrigLongLivedParticlesHypoToolFromDict)
1008 
1009  return muRoIClusterSequence
1010 
1011 
1012 
1013 
1018 
1020  from ..Config.GenerateMenuMT import GenerateMenuMT
1021  menu = GenerateMenuMT() # get menu singleton
1022  chains = [chain.name for chain in menu.chainsInMenu['Bphysics']]
1023  return chains
1024 
1025 
1029 
1031  from ..Config.GenerateMenuMT import GenerateMenuMT
1032  menu = GenerateMenuMT() # get menu singleton
1033  chains = [chain.name for chain in menu.chainsInMenu['Muon'] if "l2io" in chain.name]
1034  chains += [chain.name for chain in menu.chainsInMenu['Bphysics'] if not any(key in chain.name for key in ['noL2Comb','l2mt'])]
1035  return chains
1036 
1037 
1041 
1043  from ..Config.GenerateMenuMT import GenerateMenuMT
1044  menu = GenerateMenuMT() # get menu singleton
1045  chains = [chain.name for chain in menu.chainsInMenu['Muon'] if "l2mt" in chain.name]
1046  chains += [chain.name for chain in menu.chainsInMenu['Bphysics'] if "l2mt" in chain.name]
1047  return chains
python.HLT.Muon.MuonMenuSequences.muEFCBSequenceGenCfg
def muEFCBSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:510
python.HLT.Muon.MuonMenuSequences.muFastCalibSequenceGenCfg
def muFastCalibSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:124
python.HLT.Muon.MuonMenuSequences.muEFSAAlgSequenceCfg
def muEFSAAlgSequenceCfg(flags, is_probe_leg=False)
EFSA step ###.
Definition: MuonMenuSequences.py:395
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
TrigMuonEFConfig.MergeEFMuonsAlgCfg
def MergeEFMuonsAlgCfg(flags, name="MergeEFMuonsAlg", **kwargs)
Definition: TrigMuonEFConfig.py:50
vtune_athena.format
format
Definition: vtune_athena.py:14
python.TrigGenericAlgsConfig.ROBPrefetchingAlgCfg_Muon
def ROBPrefetchingAlgCfg_Muon(flags, nameSuffix, **kwargs)
Definition: TrigGenericAlgsConfig.py:63
python.HLT.Muon.MuonRecoSequences.muCombRecoSequenceCfg
def muCombRecoSequenceCfg(flags, RoIs, name, l2mtmode=False, l2CBname="")
Definition: MuonRecoSequences.py:308
python.HLT.Muon.MuonRecoSequences.efLateMuRoISequenceCfg
def efLateMuRoISequenceCfg(flags)
Definition: MuonRecoSequences.py:662
python.HLT.Muon.MuonRecoSequences.muonDecodeCfg
def muonDecodeCfg(flags, RoIs)
Definition: MuonRecoSequences.py:132
ViewCreatorFSROITool
Definition: ViewCreatorFSROITool.h:22
python.HLT.Muon.MuonMenuSequences.muEFCBAlgSequenceCfg
def muEFCBAlgSequenceCfg(flags, suffix, selCAName='', is_probe_leg=False)
EFCB seq ###.
Definition: MuonMenuSequences.py:448
python.HLT.Muon.MuonMenuSequences.muFastCalibAlgSequenceCfg
def muFastCalibAlgSequenceCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:77
python.HLT.Muon.MuonMenuSequences.muCombAlgSequenceCfg
def muCombAlgSequenceCfg(flags, selCAName="", is_probe_leg=False, trackingMode="FTF")
************* Step2 ************* ### --------------------------------------------------—#
Definition: MuonMenuSequences.py:166
python.HLT.Muon.MuonMenuSequences.mul2mtSAOvlpRmSequenceGenCfg
def mul2mtSAOvlpRmSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:143
python.HLT.Muon.MuonRecoSequences.isCosmic
def isCosmic(flags)
Definition: MuonRecoSequences.py:61
GenerateMenuMT
Definition: GenerateMenuMT.py:1
python.HLT.Muon.MuonRecoSequences.muEFSARecoSequenceCfg
def muEFSARecoSequenceCfg(flags, RoIs, name)
Definition: MuonRecoSequences.py:335
python.HLT.Muon.MuonRecoSequences.muonIDFastTrackingSequenceCfg
def muonIDFastTrackingSequenceCfg(flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None, doLRT=False, trackingMode="FTF")
Definition: MuonRecoSequences.py:272
python.HLT.Muon.MuonMenuSequences.muCombSequenceGenCfg
def muCombSequenceGenCfg(flags, is_probe_leg=False, trackingMode="FTF")
Definition: MuonMenuSequences.py:259
TrigMuonEFConfig.MuonFilterAlgCfg
def MuonFilterAlgCfg(flags, name="FilterZeroMuons", **kwargs)
Definition: TrigMuonEFConfig.py:40
python.HLT.Muon.MuonMenuSequences.muEFCBIDperfSequenceGenCfg
def muEFCBIDperfSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:586
python.HLT.Muon.MuonMenuSequences.mul2mtCBOvlpRmSequenceGenCfg
def mul2mtCBOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode="FTF")
Definition: MuonMenuSequences.py:373
TrigMuonHypoConfig.TrigMufastHypoAlgCfg
def TrigMufastHypoAlgCfg(flags, name="UNSPECIFIED", **kwargs)
Definition: TrigMuonHypoConfig.py:285
python.HLT.Muon.MuonRecoSequences.efmuisoRecoSequenceCfg
def efmuisoRecoSequenceCfg(flags, RoIs, Muons, doMSiso=False)
Definition: MuonRecoSequences.py:626
python.HLT.Muon.MuonMenuSequences.getInsideOutMuonChainNames
def getInsideOutMuonChainNames()
Get muon triggers except L2 inside-out trigger to filter chains where we don't want to run L2SA IO mo...
Definition: MuonMenuSequences.py:1030
python.HLT.Muon.MuonMenuSequences.muEFSAFSAlgSequenceCfg
def muEFSAFSAlgSequenceCfg(flags)
EF SA full scan ###.
Definition: MuonMenuSequences.py:690
python.HLT.Muon.MuonMenuSequences.muEFCBLRTAlgSequenceCfg
def muEFCBLRTAlgSequenceCfg(flags, selCAName='', is_probe_leg=False)
Definition: MuonMenuSequences.py:623
python.HLT.Muon.MuonMenuSequences.muCombLRTSequenceGenCfg
def muCombLRTSequenceGenCfg(flags, is_probe_leg=False, trackingMode="FTF")
Definition: MuonMenuSequences.py:333
python.HLT.Muon.MuonMenuSequences.muCombLRTAlgSequenceCfg
def muCombLRTAlgSequenceCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:298
python.HLT.Muon.MuonMenuSequences.muEFIsoSequenceGenCfg
def muEFIsoSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:946
TrigMuonHypoConfig.TrigMuonEFTrackIsolationHypoAlgCfg
def TrigMuonEFTrackIsolationHypoAlgCfg(flags, name="TrigMuonEFTrackIsolationHypoAlg", **kwargs)
Definition: TrigMuonHypoConfig.py:995
python.HLT.Muon.MuonMenuSequences.efLateMuRoISequenceGenCfg
def efLateMuRoISequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:839
python.HLT.Muon.MuonMenuSequences.muEFCBLRTSequenceGenCfg
def muEFCBLRTSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:646
python.HLT.Muon.MuonMenuSequences.muEFCBidReuseSequenceGenCfg
def muEFCBidReuseSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:567
python.CFElements.seqAND
def seqAND(name, subs=[])
Definition: CFElements.py:25
python.HLT.Muon.MuonRecoSequences.muEFCBRecoSequenceCfg
def muEFCBRecoSequenceCfg(flags, RoIs, name, suffix)
Definition: MuonRecoSequences.py:444
python.JetAnalysisCommon.parOR
parOR
Definition: JetAnalysisCommon.py:271
python.HLT.Muon.MuonRecoSequences.muonIDCosmicTrackingSequenceCfg
def muonIDCosmicTrackingSequenceCfg(flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None)
Definition: MuonRecoSequences.py:282
ViewCreatorFetchFromViewROITool
Definition: ViewCreatorFetchFromViewROITool.h:26
python.HLT.Muon.MuonMenuSequences.muEFMSIsoSequenceGenCfg
def muEFMSIsoSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:964
python.HLT.Muon.MuonMenuSequences.muEFSAFSSequenceGenCfg
def muEFSAFSSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:716
python.HLT.Muon.MuonMenuSequences.muFastSequenceGenCfg
def muFastSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:105
TrigMuonEFConfig.MuonChainFilterAlgCfg
def MuonChainFilterAlgCfg(flags, name="MuonChainFilter", **kwargs)
Definition: TrigMuonEFConfig.py:61
python.HLT.Muon.MuonMenuSequences.muEFCBl2mtSequenceGenCfg
def muEFCBl2mtSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:548
python.HLT.Muon.MuonMenuSequences.muRoiClusterSequenceGenCfg
def muRoiClusterSequenceGenCfg(flags)
Muon RoI Cluster Trigger for MS LLP Searches ##.
Definition: MuonMenuSequences.py:985
python.HLT.Muon.MuonMenuSequences.muEFSASequenceGenCfg
def muEFSASequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:425
TrigMuonHypoConfig.TrigMuonEFHypoAlgCfg
def TrigMuonEFHypoAlgCfg(flags, name="UNSPECIFIED", **kwargs)
Definition: TrigMuonHypoConfig.py:683
python.HLT.Muon.MuonMenuSequences.muCombOvlpRmSequenceGenCfg
def muCombOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode="FTF")
Definition: MuonMenuSequences.py:354
python.HLT.Muon.MuonMenuSequences.efLateMuSequenceGenCfg
def efLateMuSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:889
python.HLT.Muon.MuonMenuSequences.muEFIsoAlgSequenceCfg
def muEFIsoAlgSequenceCfg(flags, doMSiso=False, is_probe_leg=False)
efMuiso step ###
Definition: MuonMenuSequences.py:908
python.HLT.Muon.MuonMenuSequences.muEFCBl2ioSequenceGenCfg
def muEFCBl2ioSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:529
python.HLT.Muon.MuonMenuSequences.efLateMuAlgSequenceCfg
def efLateMuAlgSequenceCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:857
TrigMuonHypoConfig.TrigMuonLateMuRoIHypoAlgCfg
def TrigMuonLateMuRoIHypoAlgCfg(flags, name="TrigMuRoIHypoAlg", **kwargs)
Definition: TrigMuonHypoConfig.py:1100
python.HLT.Muon.MuonMenuSequences.getBphysChainNames
def getBphysChainNames()
Get Bphysics triggers to # filter chains where we # don't want to run muComb #.
Definition: MuonMenuSequences.py:1019
python.HLT.Muon.MuonMenuSequences.muFastAlgSequenceCfg
def muFastAlgSequenceCfg(flags, selCAName="", is_probe_leg=False)
************* Step1 ************* ### --------------------------------------------------—#
Definition: MuonMenuSequences.py:24
python.TrigGenericAlgsConfig.ROBPrefetchingAlgCfg_Si
def ROBPrefetchingAlgCfg_Si(flags, nameSuffix, **kwargs)
Definition: TrigGenericAlgsConfig.py:57
TrigMuonHypoConfig.TrigmuCombHypoAlgCfg
def TrigmuCombHypoAlgCfg(flags, name="UNSPECIFIED", **kwargs)
Definition: TrigMuonHypoConfig.py:486
python.HLT.Muon.MuonMenuSequences.muEFCBFSSequenceGenCfg
def muEFCBFSSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:801
python.HLT.Muon.MuonMenuSequences.getMultiTrackChainNames
def getMultiTrackChainNames()
Get muon triggers except L2 multi-track trigger to filter chains where we don't want to run L2SA mult...
Definition: MuonMenuSequences.py:1042
python.TrigLongLivedParticlesHypoConfig.MuonClusterHypoAlgConfig
def MuonClusterHypoAlgConfig(flags, name="MuonClusterHypoAlgConfig")
Definition: TrigLongLivedParticlesHypoConfig.py:17
TrigLongLivedParticlesConfig.MuonClusterConfig
def MuonClusterConfig(flags, name="MuonClusterConfig")
Definition: TrigLongLivedParticlesConfig.py:7
python.HLT.Muon.MuonMenuSequences.efLateMuRoIAlgSequenceCfg
def efLateMuRoIAlgSequenceCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:818
python.HLT.Muon.MuonMenuSequences.muEFCBLRTIDperfSequenceGenCfg
def muEFCBLRTIDperfSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:666
python.TriggerEDM.recordable
def recordable(arg, runVersion=3)
Definition: TriggerEDM.py:37
TrigMuonHypoConfig.TrigMuonEFIdtpHypoAlgCfg
def TrigMuonEFIdtpHypoAlgCfg(flags, name="TrigMuonEFIdtpHypoAlg", **kwargs)
Definition: TrigMuonHypoConfig.py:1097
python.HLT.Muon.MuonMenuSequences.muEFIDtpSequenceGenCfg
def muEFIDtpSequenceGenCfg(flags, is_probe_leg=False)
Definition: MuonMenuSequences.py:606
python.HLT.Muon.MuonRecoSequences.muFastRecoSequenceCfg
def muFastRecoSequenceCfg(flags, RoIs, doFullScanID=False, InsideOutMode=False, extraLoads=None, l2mtmode=False, calib=False)
Definition: MuonRecoSequences.py:231
python.HLT.Muon.MuonRecoSequences.muonNames
Definition: MuonRecoSequences.py:27
python.HLT.Muon.MuonMenuSequences.mul2IOOvlpRmSequenceGenCfg
def mul2IOOvlpRmSequenceGenCfg(flags, is_probe_leg=False, trackingMode="FTF")
Definition: MuonMenuSequences.py:279
python.HLT.Muon.MuonMenuSequences.muEFCBFSAlgSequenceCfg
def muEFCBFSAlgSequenceCfg(flags, is_probe_leg=False)
EF CB full scan ###.
Definition: MuonMenuSequences.py:740
python.HLT.Muon.MuonRecoSequences.muEFInsideOutRecoSequenceCfg
def muEFInsideOutRecoSequenceCfg(flags, RoIs, name, suffix)
Definition: MuonRecoSequences.py:544