ATLAS Offline Software
Loading...
Searching...
No Matches
MuonRecoSequences.py
Go to the documentation of this file.
1#
2# Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
3#
4
5from AthenaCommon.Logging import logging
6log = logging.getLogger(__name__)
7
8
9from TrigEDMConfig.TriggerEDM import recordable
10from MuonConfig.MuonBytestreamDecodeConfig import RpcBytestreamDecodeCfg, NrpcBytestreamDecodeCfg, TgcBytestreamDecodeCfg, MdtBytestreamDecodeCfg, CscBytestreamDecodeCfg, sTgcBytestreamDecodeCfg, MmBytestreamDecodeCfg
11from MuonConfig.MuonRdoDecodeConfig import RpcRDODecodeCfg, TgcRDODecodeCfg, MdtRDODecodeCfg, CscRDODecodeCfg, CscClusterBuildCfg, StgcRDODecodeCfg, MMRDODecodeCfg
12from MuonConfig.MuonRdoDecodeConfig import MuonPrdCacheNames
13from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
14from AthenaConfiguration.ComponentFactory import CompFactory
15from TrigInDetConfig.utils import getFlagsForActiveConfig
16
17from AthenaConfiguration.Enums import BeamType, LHCPeriod, Format
18
19from .TrigMuonKeys import muonNames
20muNames = muonNames().getNames('RoI')
21muNamesFS = muonNames().getNames('FS')
22muNamesLRT = muonNames().getNames('LRT')
23
24def isCosmic(flags):
25 #FIXME: this might not be ideal criteria to determine if this is cosmic chain but used to work in Run2 and will do for now, ATR-22758
26 return (flags.Beam.Type == BeamType.Cosmics)
27
28def isLRT(name):
29 return "LRT" in name
30
31#Returns relevant track collection name
32def getIDTracks(flags, name='', muonIDreuse=False, precision=False, suffix=''):
33
34 if muonIDreuse or suffix != '':
35 if isLRT(name):
36 return 'HLT_IDTrack_MuonComb_FTF_LRT'
37 elif isCosmic(flags):
38 return 'HLT_IDTrack_MuonComb_FTF'
39 else:
40 return 'HLT_IDTrack_MuonComb_FTF'+suffix
41
42 else:
43 if precision:
44 return flags.Tracking.ActiveConfig.tracks_IDTrig
45 else:
46 if isLRT(name):
47 return flags.Trigger.InDetTracking.muonLRT.tracks_FTF
48 elif isCosmic(flags):
49 return flags.Trigger.InDetTracking.cosmics.tracks_IDTrig
50 else:
51 return flags.Trigger.InDetTracking.muon.tracks_FTF
52
53
54def MuDataPrepViewDataVerifierCfg(flags):
55 result = ComponentAccumulator()
56
57 # Cache
58 dataObjects=[( 'RpcPrepDataCollection_Cache' , 'StoreGateSvc+RpcPrdCache' ),
59 ( 'TgcRdo_Cache' , 'StoreGateSvc+TgcRdoCache' ),
60 ( 'MdtCsm_Cache' , 'StoreGateSvc+MdtCsmRdoCache' ),
61 ( 'RpcPad_Cache' , 'StoreGateSvc+RpcRdoCache' ),
62 ( 'RpcCoinDataCollection_Cache' , 'StoreGateSvc+RpcCoinCache' ),
63 ( 'TgcPrepDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCache + 'AllBCs' ),
64 ( 'TgcCoinDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCoinCache + 'PriorBC' ),
65 ( 'TgcCoinDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCoinCache + 'NextBC' ),
66 ( 'TgcCoinDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCoinCache + 'NextNextBC' ),
67 ( 'TgcCoinDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.TgcCoinCache )
68 ]
69
70 if flags.Detector.GeometrysTGC:
71 dataObjects += [( 'sTgcPrepDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.sTgcCache)]
72 if flags.Input.Format is Format.POOL:
73 dataObjects += [( 'Muon::STGC_RawDataContainer' , 'StoreGateSvc+sTGCRDO' )]
74
75 if flags.Detector.GeometryMM:
76 dataObjects += [( 'MMPrepDataCollection_Cache' , 'StoreGateSvc+' + MuonPrdCacheNames.MmCache)]
77 if flags.Input.Format is Format.POOL:
78 dataObjects += [( 'Muon::MM_RawDataContainer' , 'StoreGateSvc+MMRDO' )]
79
80 if flags.Detector.GeometryCSC:
81 dataObjects+=[( 'CscRawDataCollection_Cache' , 'StoreGateSvc+CscRdoCache' )]
82 if flags.Input.Format is Format.POOL:
83 dataObjects += [( 'CscRawDataContainer' , 'StoreGateSvc+CSCRDO' ),
84 ( 'CscRawDataCollection_Cache' , 'StoreGateSvc+CscRdoCache' )]
85
86 if flags.Input.Format is Format.POOL:
87 dataObjects += [( 'MdtCsmContainer' , 'StoreGateSvc+MDTCSM' ),
88 *( [( 'RpcPadContainer' , 'StoreGateSvc+RPCPAD' )] if "RPCPAD" in flags.Input.Collections else [] ),
89 *( [( 'xAOD::NRPCRDOContainer' , 'StoreGateSvc+NRPCRDO' )] if flags.Muon.enableNRPC else [] ),
90 ('TgcRdoContainer' , 'StoreGateSvc+TGCRDO' )]
91
92 if flags.Muon.usePhaseIIGeoSetup:
93 dataObjects += [('ActsTrk::GeometryContext' , 'StoreGateSvc+ActsAlignment' )]
94
95 alg = CompFactory.AthViews.ViewDataVerifier( name = "VDVMuDataPrep",
96 DataObjects = dataObjects)
97 result.addEventAlgo(alg)
98 return result
99
100
101def muonDecodeCfg(flags, RoIs, inView=True):
102 acc = ComponentAccumulator()
103
104 doSeededDecoding =True
105 if 'FSRoI' in RoIs or not inView:
106 doSeededDecoding = False
107
108 if inView:
109 acc.merge(MuDataPrepViewDataVerifierCfg(flags))
110 else:
111 loadFromSG = []
112 if flags.Input.Format is Format.POOL:
113 loadFromSG += [( 'MdtCsmContainer' , 'StoreGateSvc+MDTCSM' )]
114 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
115 acc.merge(SGInputLoaderCfg(flags, loadFromSG))
116
117 # Get RPC BS decoder
118 if flags.Input.Format is Format.BS:
119 rpcAcc = RpcBytestreamDecodeCfg( flags, name = "RpcRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
120 acc.merge( rpcAcc )
121 if flags.Muon.enableNRPC:
122 acc.merge(NrpcBytestreamDecodeCfg( flags, name="NRpcRawDataProvider_"+RoIs ))
123 # Get RPC RDO convertor
124 rpcAcc = RpcRDODecodeCfg( flags, name= "RpcRdoToRpcPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
125 acc.merge( rpcAcc )
126 # Get TGC BS decoder
127 if flags.Input.Format is Format.BS:
128 tgcAcc = TgcBytestreamDecodeCfg( flags, name="TgcRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
129 acc.merge( tgcAcc )
130 # Get TGC RDO convertor
131 tgcAcc = TgcRDODecodeCfg( flags, name="TgcRdoToTgcPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
132 acc.merge( tgcAcc )
133 # Get MDT BS decoder
134 if flags.Input.Format is Format.BS:
135 mdtAcc = MdtBytestreamDecodeCfg( flags, name="MdtRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
136 acc.merge( mdtAcc )
137 # Get MDT RDO convertor
138 mdtAcc = MdtRDODecodeCfg( flags, name="MdtRdoToMdtPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
139 acc.merge( mdtAcc )
140 # Get CSC BS decoder
141 if flags.Detector.GeometryCSC:
142 if flags.Input.Format is Format.BS:
143 cscAcc = CscBytestreamDecodeCfg( flags, name="CscRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
144 acc.merge( cscAcc )
145 # Get CSC RDO convertor
146 cscAcc = CscRDODecodeCfg( flags, name="CscRdoToCscPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
147 acc.merge( cscAcc )
148 # Get CSC cluster builder
149 cscAcc = CscClusterBuildCfg( flags, name="CscThresholdClusterBuilder_"+RoIs )
150 acc.merge( cscAcc )
151 #sTGC and MM BS decoder
152 if flags.Detector.GeometrysTGC and flags.Detector.GeometryMM:
153 if flags.Input.Format is Format.BS:
154 stgcAcc = sTgcBytestreamDecodeCfg(flags, name="sTgcRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding)
155 acc.merge( stgcAcc )
156 mmAcc = MmBytestreamDecodeCfg(flags, name="MMRawDataProvider_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding)
157 acc.merge( mmAcc )
158 #sTGC and MM RDO converter
159 stgcAcc = StgcRDODecodeCfg( flags, name="StgcRdoToStgcPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding )
160 acc.merge( stgcAcc )
161
162 mmAcc = MMRDODecodeCfg( flags, name="MMRdoToMMPrepData_"+RoIs, RoIs = RoIs, DoSeededDecoding = doSeededDecoding)
163 acc.merge( mmAcc )
164
165 # SpacePoint formation
166 if flags.Muon.usePhaseIIGeoSetup and flags.Muon.scheduleActsReco:
167 from MuonSpacePointFormation.SpacePointFormationConfig import MuonSpacePointFormationCfg
168 acc.merge( MuonSpacePointFormationCfg( flags, suffix =f'_{RoIs}' ) )
169
170 return acc
171
172def muFastVDVCfg(flags, RoIs, suffix, InsideOutMode, extraLoads):
173 result=ComponentAccumulator()
174 # In insideout mode, need to inherit muon decoding objects for TGC, RPC, MDT, CSC
175 dataObjects=[]
176 if InsideOutMode:
177 dataObjects = [('Muon::TgcPrepDataContainer','StoreGateSvc+TGC_MeasurementsAllBCs'),
178 ('TgcRdoContainer' , 'StoreGateSvc+TGCRDO'),
179 ('Muon::RpcPrepDataContainer','StoreGateSvc+RPC_Measurements'),
180 ('Muon::MdtPrepDataContainer','StoreGateSvc+MDT_DriftCircles'),
181 *( [( 'RpcPadContainer' , 'StoreGateSvc+RPCPAD' )] if "RPCPAD" in flags.Input.Collections else [] )]
182 if flags.Detector.GeometryCSC:
183 dataObjects += [('Muon::CscPrepDataContainer','StoreGateSvc+CSC_Clusters')]
184 if flags.Detector.GeometrysTGC:
185 dataObjects += [('Muon::sTgcPrepDataContainer','StoreGateSvc+STGC_Measurements')]
186 if flags.Detector.GeometryMM:
187 dataObjects += [('Muon::MMPrepDataContainer','StoreGateSvc+MM_Measurements')]
188
189 if flags.Muon.usePhaseIIGeoSetup:
190 dataObjects += [('ActsTrk::GeometryContext' , 'StoreGateSvc+ActsAlignment' )]
191
192 else:
193 dataObjects += [( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+%s' % RoIs )]
194 dataObjects += [( 'xAOD::EventInfo' , 'StoreGateSvc+EventInfo' )]
195 if flags.Trigger.enableL1MuonPhase1:
196 dataObjects += [( 'xAOD::MuonRoIContainer' , 'StoreGateSvc+LVL1MuonRoIs' )]
197 else:
198 dataObjects += [( 'DataVector< LVL1::RecMuonRoI >' , 'StoreGateSvc+HLT_RecMURoIs' )]
199
200 #For L2 multi-track SA mode
201 if extraLoads:
202 dataObjects += extraLoads
203 ViewVerify = CompFactory.AthViews.ViewDataVerifier("muFastRecoVDV"+suffix, DataObjects = dataObjects)
204
205 result.addEventAlgo(ViewVerify)
206 return result
207
208def muFastRecoSequenceCfg( flags, RoIs, suffix="", doFullScanID = False, InsideOutMode=False, extraLoads=None, l2mtmode=False, calib=False, useNewFast=False ):
209
210 acc = ComponentAccumulator()
211
212 if useNewFast:
213 acc.merge(muFastVDVCfg(flags, RoIs=RoIs, suffix=suffix, InsideOutMode=False, extraLoads=None))
214
215 from MuonFastRecoAlgs.MuonFastReconstructionConfig import MuonGlobalPatternFindingAlgCfg, MuonFastSegmentFittingAlgCfg, MuonFastSABuilderAlgCfg
216 acc.merge(MuonGlobalPatternFindingAlgCfg(flags, name=f"MuonGlobalPatternFindingAlg_{suffix}"))
217 acc.merge(MuonFastSegmentFittingAlgCfg(flags, name=f"MuonFastSegmentFittingAlg_{suffix}"))
218 acc.merge(MuonFastSABuilderAlgCfg(flags, name=f"MuonFastSABuilderAlg_{suffix}",
219 OutMuons=muNames.L2SAMuonsPhII))
220 else:
221 suffix = ""
222 if InsideOutMode:
223 suffix="IOmode"
224 elif l2mtmode:
225 suffix="l2mtmode"
226 elif calib:
227 suffix="Calib"
228
229 acc.merge(muFastVDVCfg(flags, RoIs=RoIs, suffix=suffix, InsideOutMode=InsideOutMode, extraLoads=extraLoads))
230
231
232 from TrigL2MuonSA.TrigL2MuonSAConfig import l2MuFastAlgCfg
233 acc.merge(l2MuFastAlgCfg(flags,
234 roisKey = RoIs,
235 setup = suffix,
236 FILL_FSIDRoI = doFullScanID,
237 MuonL2SAInfo = muNames.L2SAMuons+suffix,
238 L2IOCB = muNames.L2CBMuons+suffix,
239 forID = muNames.L2forIDName+suffix,
240 forMS = "forMS"+suffix,
241 TrackParticlesContainerName = getIDTracks(flags)))
242 return acc
243
244def muonIDtrackVDVCfg( flags, name, RoIs, extraLoads=None, extraLoadsForl2mtmode=None ):
245 result=ComponentAccumulator()
246 dataObjects=[( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+%s' % RoIs )]
247 if extraLoads:
248 dataObjects += extraLoads
249 if extraLoadsForl2mtmode:
250 dataObjects += extraLoadsForl2mtmode
251 ViewVerify = CompFactory.AthViews.ViewDataVerifier("muCombVDV"+name, DataObjects = dataObjects)
252
253 result.addEventAlgo(ViewVerify)
254 return result
255
256def muonIDFastTrackingSequenceCfg( flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None, doLRT=False, trackingMode="FTF" ):
257
258 acc = ComponentAccumulator()
259 from TrigInDetConfig.TrigInDetConfig import trigInDetFastTrackingCfg
260 acc.merge(trigInDetFastTrackingCfg( flags, roisKey=RoIs, signatureName=name, patternMode=trackingMode ))
261
262 acc.merge(muonIDtrackVDVCfg(flags, name, RoIs, extraLoads, extraLoadsForl2mtmode))
263
264 return acc
265
266def muonIDCosmicTrackingSequenceCfg( flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None ):
267
268 acc = ComponentAccumulator()
269
270 acc.merge(muonIDtrackVDVCfg(flags, 'cosmics', RoIs, extraLoads, extraLoadsForl2mtmode))
271
272 flagsWithTrk = getFlagsForActiveConfig(flags, "cosmics", log)
273
274 from TrigInDetConfig.InnerTrackingTrigSequence import InnerTrackingTrigSequence
275 seq = InnerTrackingTrigSequence.create(flagsWithTrk,
276 flagsWithTrk.Tracking.ActiveConfig.input_name,
277 rois = RoIs,
278 inView = "muCombVDVcosmics")
279 acc.merge(seq.sequence("Offline"))
280
281
282 return acc
283
284def muCombVDVCfg( flags, postFix):
285 result=ComponentAccumulator()
286 dataObjects=[('xAOD::L2StandAloneMuonContainer','StoreGateSvc+%s' % muNames.L2SAMuons+postFix)]
287 ViewVerify = CompFactory.AthViews.ViewDataVerifier("muCombAlgVDV"+postFix, DataObjects = dataObjects)
288 result.addEventAlgo(ViewVerify)
289 return result
290
291
292def muCombRecoSequenceCfg( flags, RoIs, name, l2mtmode=False, l2CBname="" ):
293
294 acc = ComponentAccumulator()
295 postFix = ""
296 if l2mtmode:
297 postFix = "l2mtmode"
298
299 acc.merge(muCombVDVCfg(flags, postFix))
300 from TrigmuComb.TrigmuCombConfig import muCombCfg
301 l2trackname = getIDTracks(flags) if l2mtmode else getIDTracks(flags, name)
302 acc.merge(muCombCfg(flags, f'{postFix}_{name}', useBackExtrp=True,
303 L2StandAloneMuonContainerName = muNames.L2SAMuons+postFix,
304 L2CombinedMuonContainerName = l2CBname, TrackParticleContainerName = l2trackname ))
305
306 return acc
307
308def EFMuSADataPrepViewDataVerifierCfg(flags, RoIs, suffix=""):
309 result=ComponentAccumulator()
310 dataObjects=[( 'xAOD::EventInfo' , 'StoreGateSvc+EventInfo' ),
311 ( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+%s' % RoIs )]
312
313 if flags.Muon.usePhaseIIGeoSetup:
314 dataObjects += [( 'ActsGeometryContext' , 'StoreGateSvc+ActsAlignment' )]
315
316 if flags.Muon.setupTruthAlgorithms:
317 dataObjects += [( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MDT_SDO' ),
318 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MM_SDO' ),
319 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+RPC_SDO' ),
320 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+TGC_SDO' ),
321 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+sTGC_SDO' ),
322 ( 'McEventCollection' , 'StoreGateSvc+TruthEvent' ),
323 # Truth muons containers and decorations
324 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles' ),
325 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthClassification' ),
326 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthOrigin' ),
327 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthParticleLink' ),
328 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthType' ),
329 # Truth segments and SDO-to-segment links
330 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments' ),
331 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.charge' ),
332 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.localSegPars' ),
333 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.pt' ),
334 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.simHitLinks' ),
335 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MDT_SDO.truthSegmentLink' ),
336 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+MM_SDO.truthSegmentLink' ),
337 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+RPC_SDO.truthSegmentLink' ),
338 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+TGC_SDO.truthSegmentLink' ),
339 ( 'xAOD::MuonSimHitContainer' , 'StoreGateSvc+sTGC_SDO.truthSegmentLink' ),
340 # Truth segment to truth particle links
341 ( 'xAOD::MuonSegmentContainer' , 'StoreGateSvc+MuonTruthSegments.truthParticleLink' ),
342 ( 'xAOD::TruthParticleContainer' , 'StoreGateSvc+MuonTruthParticles.truthSegmentLinks' )]
343
344 alg = CompFactory.AthViews.ViewDataVerifier( name = f"VDVMuEFSA_{suffix}",
345 DataObjects = dataObjects)
346 result.addEventAlgo(alg)
347 return result
348
349
350def muEFSARecoSequenceCfg(flags, RoIs, suffix="", useBucketFilter=False):
351
352 acc = ComponentAccumulator()
353
354 acc.merge(EFMuSADataPrepViewDataVerifierCfg(flags, RoIs=RoIs, suffix=suffix))
355
356 nameGroups = muNamesFS if 'FS' in suffix else muNames
357
358 msMuonName = nameGroups.EFSAMuons
359 if flags.Muon.usePhaseIIGeoSetup and flags.Muon.scheduleActsReco:
360
361 if "newFast" in suffix:
362 msMuonName = nameGroups.EFSAMuonsPhIINewFast
363 msTrackName = nameGroups.EFSATrackParticlesPhIINewFast
364 elif useBucketFilter:
365 msMuonName = nameGroups.EFSAMuonsPhIIMlbkt
366 msTrackName = nameGroups.EFSATrackParticlesPhIIMlbkt
367 else:
368 msTrackName = nameGroups.EFSATrackParticlesPhII
369
370 # Schedule reco-to-truth object association
371 if flags.Muon.setupTruthAlgorithms:
372 from MuonObjectMarker.ObjectMarkerConfig import TruthMeasMarkerAlgCfg
373 acc.merge(TruthMeasMarkerAlgCfg(flags, name = f"TruthMeasMarkerAlg{suffix}"))
374 from MuonTruthAlgsR4.MuonTruthAlgsConfig import TruthHitAssociationCfg, RecoSegmentTruthAssocCfg, MuonToTruthAssocAlgCfg
375 acc.merge(TruthHitAssociationCfg(flags, useSDO=True, suffix=suffix))
376 acc.merge(RecoSegmentTruthAssocCfg(flags, name=f"MuonSegmentsFromR4TruthMatching{suffix}",
377 SegmentKey="MuonSegmentsFromR4"))
378 acc.merge(MuonToTruthAssocAlgCfg(flags, name=f'MuonToTruthMatchingAlg{suffix}'))
379
380 # ML bucket filter
381 if useBucketFilter:
382 from MuonInference.InferenceConfig import GraphBucketFilterToolCfg, GraphInferenceAlgCfg
383 bucketTool = acc.popToolsAndMerge(GraphBucketFilterToolCfg(flags, name=f"GraphBucketFilterTool{suffix}",
384 WriteSpacePointKey="FilteredMlBuckets"))
385 acc.merge(GraphInferenceAlgCfg(flags, name = f"GraphInferenceAlg{suffix}",
386 InferenceTools=[bucketTool]))
387
388 # Pattern recognition & segment fitting
389 from MuonPatternRecognitionAlgs.MuonPatternRecognitionConfig import MuonEtaHoughTransformAlgCfg, MuonNSWSegmentFinderAlgCfg, MuonPhiHoughTransformAlgCfg, MuonSegmentFittingAlgCfg
390 segmentContainers = []
391 if flags.Detector.GeometrysTGC or flags.Detector.GeometryMM:
392 segmentContainers+=["MuonNswSegments"]
393 acc.merge(MuonEtaHoughTransformAlgCfg(flags, name=f"MuonNswEtaHoughTransformAlg{suffix}",
394 EtaHoughMaxContainer = "MuonHoughNswMaxima",
395 SpacePointContainer = "NswSpacePoints"))
396 acc.merge(MuonNSWSegmentFinderAlgCfg(flags, name=f"MuonNswSegmentFinderAlg{suffix}",
397 MuonNswSegmentWriteKey = segmentContainers[-1],
398 MuonNswSegmentSeedWriteKey = "MuonNswSegmentSeeds",
399 CombinatorialReadKey = "MuonHoughNswMaxima"))
400
401 if flags.Detector.GeometryMDT or flags.Detector.GeometryRPC or flags.Detector.GeometryTGC:
402 if useBucketFilter:
403 acc.merge(MuonEtaHoughTransformAlgCfg(flags, name = f"MuonEtaHoughTransformAlg{suffix}",
404 SpacePointContainer = "FilteredMlBuckets"))
405 else:
406 acc.merge(MuonEtaHoughTransformAlgCfg(flags, name = f"MuonEtaHoughTransformAlg{suffix}"))
407
408 acc.merge(MuonPhiHoughTransformAlgCfg(flags, name = f"MuonPhiHoughTransformAlg{suffix}"))
409
410 segmentContainers+=["R4MuonSegments"]
411 acc.merge(MuonSegmentFittingAlgCfg(flags, name = f"MuonSegmentFittingAlg{suffix}",
412 OutSegmentContainer=segmentContainers[-1]))
413
414 from MuonSegmentCnv.MuonSegmentCnvConfig import xAODSegmentCnvAlgCfg
415 acc.merge(xAODSegmentCnvAlgCfg(flags, name = f"MuonR4xAODSegmentCnvAlg{suffix}",
416 InSegmentKeys = segmentContainers))
417
418 from MuonSegmentCnv.MuonSegmentCnvConfig import MuonR4SegmentCnvAlgCfg
419 acc.merge(MuonR4SegmentCnvAlgCfg(flags, name=f"MuonR4SegmentCnvAlg{suffix}",
420 ReadSegments = segmentContainers,
421 WriteKey="TrackMuonSegments"))
422
423 # Track building
424 from MuonTrackFindingAlgs.TrackFindingConfig import MSTrackFinderAlgCfg, StandaloneTrackPartCnvCfg
425 from MuonCombinedAlgsR4.MuonCombinedAlgsConfigR4 import MuidSaTagMakerAlgCfg, MuonCreatorAlgCfg
426 acc.merge(MSTrackFinderAlgCfg(flags, name=f"MSTrackFinderAlg{suffix}"))
427 acc.merge(StandaloneTrackPartCnvCfg(flags, name=f"MuonMsTrackParticleCnvR4{suffix}",
428 TrackParticlesOutKey = msTrackName))
429 acc.merge(MuidSaTagMakerAlgCfg(flags, name=f"MuidSaTagMakerAlg{suffix}",
430 MsTracks = msTrackName))
431 acc.merge(MuonCreatorAlgCfg(flags, name = f"MuonActsCreatorAlg{suffix}",
432 TagKeys = ["MuonTagsSA"],
433 MuonKey = msMuonName))
434 # This alg needs to be removed once the Phase-2 combined steps is ready
435 from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCombinedMuonCandidateAlgCfg
436 acc.merge(MuonCombinedMuonCandidateAlgCfg(flags, name=f"MuonCombinedMuonCandidateAlg{suffix}",
437 MuonSpectrometerTrackParticleLocation = msTrackName))
438 else:
439
440 from MuonConfig.MuonSegmentFindingConfig import MuonSegmentFinderAlgCfg, MuonLayerHoughAlgCfg
441 acc.merge(MuonLayerHoughAlgCfg(flags, f"TrigMuonLayerHoughAlg{suffix}"))
442 acc.merge(MuonSegmentFinderAlgCfg(flags, f"TrigMuonSegmentMaker{suffix}"))
443
444 from MuonSegmentTrackMaker.MuonTrackMakerAlgsMonitoring import MuPatTrackBuilderMonitoring
445 from MuonConfig.MuonTrackBuildingConfig import MuPatTrackBuilderCfg
446 from xAODTrackingCnv.xAODTrackingCnvConfig import MuonStandaloneTrackParticleCnvAlgCfg
447 acc.merge(MuPatTrackBuilderCfg(flags, name=f"TrigMuPatTrackBuilder{suffix}",
448 MuonSegmentCollection = "TrackMuonSegments",
449 MonTool = MuPatTrackBuilderMonitoring(flags, f"MuPatTrackBuilderMonitoringSA{suffix}")))
450
451 acc.merge(MuonStandaloneTrackParticleCnvAlgCfg(flags, name = f"TrigMuonStandaloneTrackParticleCnvAlg{suffix}"))
452 from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCombinedMuonCandidateAlgCfg, MuonCreatorAlgCfg
453 from MuonCombinedAlgs.MuonCombinedAlgsMonitoring import MuonCreatorAlgMonitoring
454 acc.merge(MuonCombinedMuonCandidateAlgCfg(flags, name=f"TrigMuonCandidateAlg{suffix}"))
455 acc.merge(MuonCreatorAlgCfg(flags, name=f"TrigMuonCreatorAlg_{suffix}",
456 CreateSAmuons=True,
457 TagMaps=[],
458 MuonContainerLocation=msMuonName,
459 ExtrapolatedLocation = f"HLT_MSExtrapolatedMuons_{suffix}",
460 MSOnlyExtrapolatedLocation = f"HLT_MSOnlyExtrapolatedMuons_{suffix}",
461 MonTool = MuonCreatorAlgMonitoring(flags, f"MuonCreatorAlgSA_{suffix}")))
462
463 sequenceOut = msMuonName
464
465 return acc, sequenceOut
466
467
468
469def VDVEFMuCBCfg(flags, RoIs, name, suffix):
470 acc = ComponentAccumulator()
471 dataObjects = [( 'Muon::MdtPrepDataContainer' , 'StoreGateSvc+MDT_DriftCircles' ),
472 ( 'Muon::TgcPrepDataContainer' , 'StoreGateSvc+TGC_MeasurementsAllBCs' ),
473 ( 'Muon::RpcPrepDataContainer' , 'StoreGateSvc+RPC_Measurements' ),
474 ( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+%s' % RoIs ),
475 ( 'xAOD::EventInfo' , 'StoreGateSvc+EventInfo' ),
476 ]
477 if "FS" in name:
478 dataObjects +=[( 'MuonCandidateCollection' , 'StoreGateSvc+MuonCandidates_FS' )]
479 else:
480 dataObjects +=[( 'MuonCandidateCollection' , 'StoreGateSvc+MuonCandidates')]
481
482 if flags.Detector.GeometryCSC:
483 dataObjects += [( 'Muon::CscStripPrepDataContainer' , 'StoreGateSvc+CSC_Measurements' )]
484 if flags.Detector.GeometrysTGC and flags.Detector.GeometryMM:
485 dataObjects += [( 'Muon::MMPrepDataContainer' , 'StoreGateSvc+MM_Measurements'),
486 ( 'Muon::sTgcPrepDataContainer' , 'StoreGateSvc+STGC_Measurements') ]
487 if flags.Muon.usePhaseIIGeoSetup:
488 dataObjects += [( 'MuonR4::SpacePointContainer' , 'StoreGateSvc+MuonSpacePoints' )]
489 if flags.Detector.GeometrysTGC or flags.Detector.GeometryMM:
490 dataObjects += [( 'MuonR4::SpacePointContainer' , 'StoreGateSvc+NswSpacePoints' )]
491
492 alg = CompFactory.AthViews.ViewDataVerifier( name = "VDVMuEFCB_"+name+suffix,
493 DataObjects = dataObjects)
494 acc.addEventAlgo(alg)
495 return acc
496
497
498
499def VDVPrecMuTrkCfg(flags, name, suffix):
500 acc = ComponentAccumulator()
501
502 vdvName = "VDVMuTrkLRT" if "LRT" in name else "VDVMuTrk"
503 trkname = "LRT" if "LRT" in name else ''
504 dataObjects = [( 'xAOD::IParticleContainer' , 'StoreGateSvc+'+ getIDTracks(flags, trkname) )]
505
506 if not flags.Muon.enableTrigIDtrackReuse and suffix == '':
507 dataObjects += [( 'xAOD::TrackParticleContainer' , 'StoreGateSvc+'+getIDTracks(flags, trkname, muonIDreuse=flags.Muon.enableTrigIDtrackReuse) )]
508 else:
509 if suffix != 'idReuse':
510 MuonL2CBContainer = muNames.L2CBMuons+suffix
511 else:
512 MuonL2CBContainer = muNames.L2CBMuons
513 dataObjects += [( 'xAOD::L2CombinedMuonContainer', 'StoreGateSvc+'+MuonL2CBContainer)]
514
515 if flags.Input.Format is Format.BS:
516 dataObjects += [( 'IDCInDetBSErrContainer' , 'StoreGateSvc+PixelByteStreamErrs' ),
517 ( 'IDCInDetBSErrContainer' , 'StoreGateSvc+SCT_ByteStreamErrs' )]
518
519 alg = CompFactory.AthViews.ViewDataVerifier( name = vdvName+suffix,
520 DataObjects = dataObjects)
521 acc.addEventAlgo(alg)
522 return acc
523
524
525def VDVidReuseITkCfg(flags, suffix):
526 acc = ComponentAccumulator()
527
528 vdvName = "VDVidReuseITk"
529 dataObjects = []
530
531 from TrigInDetConfig.TrigInDetConfig import InDetExtraDataObjectsFromDataPrep
532 InDetExtraDataObjectsFromDataPrep(flags, dataObjects)
533
534 alg = CompFactory.AthViews.ViewDataVerifier( name = vdvName+suffix,
535 DataObjects = dataObjects)
536 acc.addEventAlgo(alg)
537 return acc
538
539
540def muEFCBRecoSequenceCfg( flags, RoIs, name, suffix ):
541
542
543 from MuonCombinedAlgs.MuonCombinedAlgsMonitoring import MuonCreatorAlgMonitoring
544 from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCreatorAlgCfg, MuonCombinedAlgCfg, MuonCombinedInDetCandidateAlgCfg
545 acc = ComponentAccumulator()
546
547 acc.merge(VDVEFMuCBCfg(flags, RoIs, name, suffix))
548
549 if "FS" in name:
550 #Need to run tracking for full scan chains
551 from TrigInDetConfig.TrigInDetConfig import trigInDetFastTrackingCfg
552 acc.merge(trigInDetFastTrackingCfg( flags, roisKey=RoIs, signatureName="muonFS" ))
553
554 else:
555 acc.merge(VDVPrecMuTrkCfg(flags, name, suffix))
556
557
558 #Precision Tracking
559 from TrigInDetConfig.TrigInDetConfig import trigInDetPrecisionTrackingCfg
560 #When run in a different view than FTF some data dependencies needs to be loaded through verifier
561 #Pass verifier as an argument and it will automatically append necessary DataObjects
562 #@NOTE: Don't provide any verifier if loaded in the same view as FTF
563 if isCosmic(flags) and 'LRT' not in name:
564 trackParticles=getIDTracks(flags, name, muonIDreuse=flags.Muon.enableTrigIDtrackReuse)
565 elif 'LRT' in name:
566 muLrtFlags = getFlagsForActiveConfig(flags, "muonLRT", log)
567 acc.merge(trigInDetPrecisionTrackingCfg(muLrtFlags, rois= RoIs, signatureName="muonLRT"))
568 trackParticles = getIDTracks(muLrtFlags, name, precision=True)
569 elif 'FS' in name:
570 muFsFlags = getFlagsForActiveConfig(flags, "muonFS", log)
571 acc.merge(trigInDetPrecisionTrackingCfg(muFsFlags, rois= RoIs, signatureName="muonFS", in_view=False))
572 trackParticles = getIDTracks(muFsFlags, precision=True)
573 else:
574 muFlags = getFlagsForActiveConfig(flags, "muon", log)
575 if not flags.Muon.enableTrigIDtrackReuse and suffix == '':
576 acc.merge(trigInDetPrecisionTrackingCfg(muFlags, rois= RoIs, signatureName="muon"))
577 trackParticles=getIDTracks(muFlags, name, muonIDreuse=flags.Muon.enableTrigIDtrackReuse, precision=True, suffix=suffix)
578
579 if flags.Muon.enableTrigIDtrackReuse or suffix != '':
580 if 'LRT' not in name or 'FS' not in name:
581 if flags.GeoModel.Run > LHCPeriod.Run3:
582 acc.merge(VDVidReuseITkCfg(flags, suffix))
583 if suffix != 'idReuse':
584 MuonL2CBInputContainer = muNames.L2CBMuons+suffix
585 else:
586 MuonL2CBInputContainer = muNames.L2CBMuons
587 from TrigMuonEF.TrigMuonEFConfig import GetL2CBmuonInDetTracksAlgCfg
588 acc.merge(GetL2CBmuonInDetTracksAlgCfg(flags, name="GetL2CBInDetTracks"+suffix,
589 MuonL2CBContainerLocation=MuonL2CBInputContainer,
590 IDtrackOutputLocation="HLT_IDTrack_MuonComb_FTF"+suffix))
591
592 #Make InDetCandidates
593 acc.merge(MuonCombinedInDetCandidateAlgCfg(flags, name="TrigMuonCombinedInDetCandidateAlg_"+name+suffix,TrackParticleLocation = [trackParticles], InDetCandidateLocation="InDetCandidates_"+name+suffix))
594
595
596 #MS ID combination
597 candidatesName = "MuonCandidates"
598 if 'FS' in name:
599 candidatesName = "MuonCandidates_FS"
600
601 acc.merge(MuonCombinedAlgCfg(flags,name="TrigMuonCombinedAlg_"+name+suffix, MuonCandidateLocation=candidatesName, InDetCandidateLocation="InDetCandidates_"+name+suffix))
602
603 if 'FS' in name:
604 cbMuonName = muNamesFS.EFCBOutInMuons
605 elif 'LRT' in name:
606 cbMuonName = muNamesLRT.EFCBMuons
607 else:
608 cbMuonName = muNames.EFCBOutInMuons
609
610
611 acc.merge(MuonCreatorAlgCfg(flags, name="TrigMuonCreatorAlgCB_"+name+suffix, MuonCandidateLocation=[candidatesName], TagMaps=["muidcoTagMap"], InDetCandidateLocation="InDetCandidates_"+name+suffix,
612 MuonContainerLocation = cbMuonName+suffix, ExtrapolatedLocation = "CBExtrapolatedMuons"+suffix,
613 MSOnlyExtrapolatedLocation = "CBMSonlyExtrapolatedMuons"+suffix, CombinedLocation = "HLT_CBCombinedMuon_"+name+suffix,
614 MonTool = MuonCreatorAlgMonitoring(flags, "MuonCreatorAlgCB_"+name+suffix)))
615
616
617
618 return acc
619
620
621def VDVMuInsideOutCfg(flags, name, candidatesName, suffix):
622 acc = ComponentAccumulator()
623 dataObjects = [( 'Muon::RpcPrepDataContainer' , 'StoreGateSvc+RPC_Measurements' ),
624 ( 'Muon::TgcPrepDataContainer' , 'StoreGateSvc+TGC_MeasurementsAllBCs' ),
625 ( 'MuonCandidateCollection' , 'StoreGateSvc+'+candidatesName ),
626 ('Trk::SegmentCollection' , 'StoreGateSvc+TrackMuonSegments')]
627 if not isCosmic(flags): dataObjects += [( 'Muon::HoughDataPerSectorVec' , 'StoreGateSvc+HoughDataPerSectorVec')]
628 if flags.Detector.GeometryCSC:
629 dataObjects += [( 'Muon::CscPrepDataContainer' , 'StoreGateSvc+CSC_Clusters' )]
630 if flags.Detector.GeometrysTGC and flags.Detector.GeometryMM:
631 dataObjects += [( 'Muon::MMPrepDataContainer' , 'StoreGateSvc+MM_Measurements'),
632 ( 'Muon::sTgcPrepDataContainer' , 'StoreGateSvc+STGC_Measurements') ]
633
634 alg = CompFactory.AthViews.ViewDataVerifier( name = "VDVMuInsideOut_"+name+suffix,
635 DataObjects = dataObjects)
636 acc.addEventAlgo(alg)
637 return acc
638
639
640def muEFInsideOutRecoSequenceCfg(flags, RoIs, name, suffix ):
641
642 from MuonConfig.MuonSegmentFindingConfig import MuonSegmentFinderAlgCfg, MuonLayerHoughAlgCfg
643 from MuonCombinedAlgs.MuonCombinedAlgsMonitoring import MuonCreatorAlgMonitoring
644 from MuonCombinedConfig.MuonCombinedReconstructionConfig import MuonCreatorAlgCfg, MuGirlStauAlgCfg, StauCreatorAlgCfg, MuonInDetToMuonSystemExtensionAlgCfg, MuonInsideOutRecoAlgCfg, MuonCombinedInDetCandidateAlgCfg
645 from MuonCombinedConfig.MuonCombinedRecToolsConfig import MuonInsideOutRecoToolCfg
646
647 acc = ComponentAccumulator()
648
649 candidatesName = "MuonCandidates"
650 if 'FS' in name:
651 candidatesName = "MuonCandidates_FS"
652
653 if "Late" in name:
654
655 #Need to run hough transform at start of late muon chain
656 acc.merge(MuonLayerHoughAlgCfg(flags, "TrigMuonLayerHoughAlg_"+name,MuonPatternCombinationCollection="MuonLayerHoughCombis_"+name,
657 Key_MuonLayerHoughToolHoughDataPerSectorVec="HoughDataPerSectorVec_"+name))
658
659 acc.merge(MuonSegmentFinderAlgCfg(flags, "TrigMuonSegmentMaker_"+name,MuonLayerHoughCombisKey="MuonLayerHoughCombis_"+name))
660
661
662 # need to run precisions tracking for late muons, since we don't run it anywhere else
663 from TrigInDetConfig.TrigInDetConfig import trigInDetPrecisionTrackingCfg
664 muLateFlags = getFlagsForActiveConfig(flags, "muonLate", log)
665 acc.merge(trigInDetPrecisionTrackingCfg(muLateFlags, rois= RoIs, signatureName="muonLate", in_view=False))
666 trackParticles = muLateFlags.Tracking.ActiveConfig.tracks_IDTrig
667
668 #Make InDetCandidates
669 acc.merge(MuonCombinedInDetCandidateAlgCfg(flags, name="TrigMuonCombinedInDetCandidateAlg_"+name,TrackParticleLocation=[trackParticles],ForwardParticleLocation=trackParticles,InDetCandidateLocation="InDetCandidates_"+name,ExtendBulk=True))
670
671 else:
672 # for non-latemu chains, the decoding/hough transform is run in an earlier step
673 #Need PRD containers for inside-out reco
674 acc.merge(VDVMuInsideOutCfg(flags, name, candidatesName, suffix))
675
676 #Inside-out reconstruction
677
678 cbMuonName = muNames.EFCBInOutMuons+suffix
679 if 'Late' in name:
680 cbMuonName = recordable(cbMuonName+"_Late")
681 acc.merge(MuGirlStauAlgCfg(flags, name="TrigMuonLateInsideOutRecoAlg_"+name,InDetCandidateLocation="InDetCandidates_"+name))
682 acc.merge(StauCreatorAlgCfg(flags, name="TrigLateMuonCreatorAlg_"+name, TagMaps=["stauTagMap"], SegmentContainerName="", InDetCandidateLocation="InDetCandidates_"+name,
683 MuonContainerLocation=cbMuonName, MonTool=MuonCreatorAlgMonitoring(flags, "LateMuonCreatorAlg_"+name)))
684 else:
685 acc.merge(MuonInDetToMuonSystemExtensionAlgCfg(flags, name="TrigInDetMuonExtensionAlg_"+name+suffix, InputInDetCandidates="InDetCandidates_"+name+suffix,
686 WriteInDetCandidates="InDetCandidatesSystemExtended_"+name+suffix))
687 if 'RoI' in name:
688 ioTool = MuonInsideOutRecoToolCfg(flags, MuonLayerSegmentFinderTool="", InputSegments="TrackMuonSegments")
689 else:
690 ioTool = MuonInsideOutRecoToolCfg(flags)
691 InsideOutRecoTool = acc.popToolsAndMerge(ioTool)
692
693 acc.merge(MuonInsideOutRecoAlgCfg(flags, name="TrigMuonInsideOutRecoAlg_"+name+suffix,InDetCandidateLocation="InDetCandidatesSystemExtended_"+name+suffix, MuonCombinedInDetExtensionTool=InsideOutRecoTool))
694
695 acc.merge(MuonCreatorAlgCfg(flags, name="TrigMuonCreatorAlgInsideOut_"+name+suffix, MuonCandidateLocation=[candidatesName], TagMaps=["muGirlTagMap"],InDetCandidateLocation="InDetCandidates_"+name+suffix,
696 MuonContainerLocation = cbMuonName, ExtrapolatedLocation = "InsideOutCBExtrapolatedMuons"+suffix,
697 MSOnlyExtrapolatedLocation = "InsideOutCBMSOnlyExtrapolatedMuons"+suffix, CombinedLocation = "InsideOutCBCombinedMuon"+suffix, MonTool = MuonCreatorAlgMonitoring(flags, "MuonCreatorAlgInsideOut_"+name+suffix)))
698
699 return acc
700
701
702def VDVMuIsoCfg(flags, name, RoIs):
703 acc = ComponentAccumulator()
704 dataObjects = [( 'TrigRoiDescriptorCollection' , 'StoreGateSvc+'+RoIs ),
705 ( 'xAOD::MuonContainer' , 'StoreGateSvc+IsoViewMuons'+name )]
706
707 alg = CompFactory.AthViews.ViewDataVerifier( name = "efMuIsoVDV"+name,
708 DataObjects = dataObjects)
709 acc.addEventAlgo(alg)
710 return acc
711
712
713def efmuisoRecoSequenceCfg( flags, RoIs, Muons, doMSiso=False ):
714
715 name = ""
716 if doMSiso:
717 name = "MS"
718 acc = VDVMuIsoCfg(flags, name, RoIs)
719
720 acc.merge(muonIDFastTrackingSequenceCfg(flags, RoIs, "muonIso"+name ))
721
722 from TrigInDetConfig.TrigInDetConfig import trigInDetPrecisionTrackingCfg
723 muIsoFlags = getFlagsForActiveConfig(flags, "muonIso"+name, log)
724 acc.merge(trigInDetPrecisionTrackingCfg(muIsoFlags, rois= RoIs, signatureName="muonIso"+name, in_view=False))
725 trackParticles = muIsoFlags.Tracking.ActiveConfig.tracks_IDTrig
726
727 # Isolation alg
728 from TrigMuonEF.TrigMuonEFConfig import TrigMuonEFTrackIsolationAlgCfg
729 acc.merge(TrigMuonEFTrackIsolationAlgCfg(flags,name="TrigEFMuIso"+name, requireCombinedMuon = not doMSiso,
730 MuonEFContainer = Muons,IdTrackParticles = trackParticles, MuonContName = muNames.EFIsoMuons+name,
731 ptcone02Name = muNames.EFIsoMuons+name + ".ptcone02",
732 ptcone03Name = muNames.EFIsoMuons+name + ".ptcone03"))
733
734 return acc
735
736def VDVLateMuCfg(flags):
737 acc = ComponentAccumulator()
738 dataObjects = [( 'xAOD::MuonRoIContainer', 'StoreGateSvc+LVL1MuonRoIsBCm2' ),
739 ( 'xAOD::MuonRoIContainer', 'StoreGateSvc+LVL1MuonRoIsBCm1' ),
740 ( 'xAOD::MuonRoIContainer', 'StoreGateSvc+LVL1MuonRoIsBCp1' ),
741 ( 'xAOD::MuonRoIContainer', 'StoreGateSvc+LVL1MuonRoIsBCp2' )]
742
743 alg = CompFactory.AthViews.ViewDataVerifier( name = "efLateMuRoIVDV",
744 DataObjects = dataObjects)
745 acc.addEventAlgo(alg)
746 return acc
747
748
749def efLateMuRoISequenceCfg(flags):
750
751 acc = VDVLateMuCfg(flags)
752
753 from TrigmuRoI.TrigmuRoIConfig import TrigmuRoIConfig
754 sequenceOut = "LateMuRoIs"
755 acc.merge(TrigmuRoIConfig(flags, "TrigmuRoI", outputRoIs=sequenceOut))
756
757 return acc, sequenceOut
758
759
762
763def MlMuonDVtxCaloTowerRecoSequenceCfg(flags):
764 acc = ComponentAccumulator()
765
766 # Use same names of calo algs as in Jet reco to avoid running them twice
767 """ Create the calo cells """
768 acc = ComponentAccumulator()
769 from TrigCaloRec.TrigCaloRecConfig import hltCaloCellSeedlessMakerCfg, hltHICaloTowerMakerCfg
770 acc.merge(hltCaloCellSeedlessMakerCfg(flags, roisKey=''))
771
772 """ Create the calo towers """
773 from TriggerMenuMT.HLT.CommonSequences.FullScanDefs import fs_towers
774 acc.merge(hltHICaloTowerMakerCfg(flags, name="HLTCaloTowerMakerFS",
775 towersKey=fs_towers,
776 cellsKey="SeedLessFS",
777 RoIs=''))
778 return acc
779
780
781def MlMuonDVtxRecoSequenceCfg(flags):
782
783 acc = ComponentAccumulator()
784
785 # Pattern recognition & segment fitting
786 from MuonPatternRecognitionAlgs.MuonPatternRecognitionConfig import MuonEtaHoughTransformAlgCfg, MuonNSWSegmentFinderAlgCfg, MuonPhiHoughTransformAlgCfg, MuonSegmentFittingAlgCfg
787 segmentContainers = []
788 if flags.Detector.GeometrysTGC or flags.Detector.GeometryMM:
789 segmentContainers+=["MuonNswSegments"]
790 acc.merge(MuonEtaHoughTransformAlgCfg(flags, name="MuonNswEtaHoughTransformAlgMlVtx",
791 EtaHoughMaxContainer = "MuonHoughNswMaxima",
792 SpacePointContainer = "NswSpacePoints"))
793 acc.merge(MuonNSWSegmentFinderAlgCfg(flags, name="MuonNswSegmentFinderAlgMlVtx",
794 MuonNswSegmentWriteKey = segmentContainers[-1],
795 MuonNswSegmentSeedWriteKey = "MuonNswSegmentSeeds",
796 CombinatorialReadKey = "MuonHoughNswMaxima"))
797
798 if flags.Detector.GeometryMDT or flags.Detector.GeometryRPC or flags.Detector.GeometryTGC:
799 acc.merge(MuonEtaHoughTransformAlgCfg(flags, name = "MuonEtaHoughTransformAlgMlVtx"))
800 acc.merge(MuonPhiHoughTransformAlgCfg(flags, name = "MuonPhiHoughTransformAlgMlVtx"))
801
802 segmentContainers+=["R4MuonSegments"]
803 acc.merge(MuonSegmentFittingAlgCfg(flags, name = "MuonSegmentFittingAlgMlVtx",
804 OutSegmentContainer=segmentContainers[-1]))
805
806 from MuonSegmentCnv.MuonSegmentCnvConfig import xAODSegmentCnvAlgCfg
807 acc.merge(xAODSegmentCnvAlgCfg(flags, name = "MuonR4xAODSegmentCnvAlgMlVtx",
808 InSegmentKeys = segmentContainers))
809
810 from MuonInference.InferenceConfig import DisplacedVertexInferenceToolCfg
811 from TriggerMenuMT.HLT.CommonSequences.FullScanDefs import fs_towers
812 dv_tool = acc.popToolsAndMerge(DisplacedVertexInferenceToolCfg(flags,
813 TowerContainerKey=fs_towers,
814 SpacePointKeys=["MuonSpacePoints", "NswSpacePoints"]))
815 alg = CompFactory.MuonML.DVInferenceAlg(name="InferenceAlgMlVtx",
816 WriteDVoutput=True,
817 InferenceTool = dv_tool)
818 acc.addEventAlgo(alg, primary=True)
819
820 return acc
821
822
python.HLT.Muon.MuonRecoSequences.muCombRecoSequenceCfg
muCombRecoSequenceCfg(flags, RoIs, name, l2mtmode=False, l2CBname="")
Definition MuonRecoSequences.py:292
python.HLT.Muon.MuonRecoSequences.muonDecodeCfg
muonDecodeCfg(flags, RoIs, inView=True)
Definition MuonRecoSequences.py:101
python.HLT.Muon.MuonRecoSequences.muEFCBRecoSequenceCfg
muEFCBRecoSequenceCfg(flags, RoIs, name, suffix)
Definition MuonRecoSequences.py:540
python.HLT.Muon.MuonRecoSequences.muonIDtrackVDVCfg
muonIDtrackVDVCfg(flags, name, RoIs, extraLoads=None, extraLoadsForl2mtmode=None)
Definition MuonRecoSequences.py:244
python.HLT.Muon.MuonRecoSequences.VDVMuInsideOutCfg
VDVMuInsideOutCfg(flags, name, candidatesName, suffix)
Definition MuonRecoSequences.py:621
python.HLT.Muon.MuonRecoSequences.muonIDFastTrackingSequenceCfg
muonIDFastTrackingSequenceCfg(flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None, doLRT=False, trackingMode="FTF")
Definition MuonRecoSequences.py:256
python.HLT.Muon.MuonRecoSequences.muFastVDVCfg
muFastVDVCfg(flags, RoIs, suffix, InsideOutMode, extraLoads)
Definition MuonRecoSequences.py:172
python.HLT.Muon.MuonRecoSequences.EFMuSADataPrepViewDataVerifierCfg
EFMuSADataPrepViewDataVerifierCfg(flags, RoIs, suffix="")
Definition MuonRecoSequences.py:308
python.HLT.Muon.MuonRecoSequences.VDVEFMuCBCfg
VDVEFMuCBCfg(flags, RoIs, name, suffix)
Definition MuonRecoSequences.py:469
python.HLT.Muon.MuonRecoSequences.MlMuonDVtxCaloTowerRecoSequenceCfg
MlMuonDVtxCaloTowerRecoSequenceCfg(flags)
ML Displaced Vertex ###.
Definition MuonRecoSequences.py:763
python.HLT.Muon.MuonRecoSequences.muEFSARecoSequenceCfg
muEFSARecoSequenceCfg(flags, RoIs, suffix="", useBucketFilter=False)
Definition MuonRecoSequences.py:350
python.HLT.Muon.MuonRecoSequences.muonIDCosmicTrackingSequenceCfg
muonIDCosmicTrackingSequenceCfg(flags, RoIs, name, extraLoads=None, extraLoadsForl2mtmode=None)
Definition MuonRecoSequences.py:266
python.HLT.Muon.MuonRecoSequences.muEFInsideOutRecoSequenceCfg
muEFInsideOutRecoSequenceCfg(flags, RoIs, name, suffix)
Definition MuonRecoSequences.py:640
python.HLT.Muon.MuonRecoSequences.efmuisoRecoSequenceCfg
efmuisoRecoSequenceCfg(flags, RoIs, Muons, doMSiso=False)
Definition MuonRecoSequences.py:713
python.HLT.Muon.MuonRecoSequences.getIDTracks
getIDTracks(flags, name='', muonIDreuse=False, precision=False, suffix='')
Definition MuonRecoSequences.py:32
python.HLT.Muon.MuonRecoSequences.muFastRecoSequenceCfg
muFastRecoSequenceCfg(flags, RoIs, suffix="", doFullScanID=False, InsideOutMode=False, extraLoads=None, l2mtmode=False, calib=False, useNewFast=False)
Definition MuonRecoSequences.py:208
Generated on for ATLAS Offline Software by doxygen 1.17.0