ATLAS Offline Software
Loading...
Searching...
No Matches
Lvl1MuonSimulationConfig.py
Go to the documentation of this file.
1# Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
2
3from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
4from AthenaConfiguration.ComponentFactory import CompFactory
5from AthenaConfiguration.Enums import Format
6from IOVDbSvc.IOVDbSvcConfig import addFolders
7
8def TMDBConfig(flags):
9 acc = ComponentAccumulator()
10
11 # Read MuRcvRawChCnt from the input file (for POOL directly, for BS via converter)
12 if flags.Input.Format is Format.POOL:
13 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
14 acc.merge(SGInputLoaderCfg(flags, ["TileRawChannelContainer/MuRcvRawChCnt"]))
15 else:
16 from TriggerJobOpts.TriggerByteStreamConfig import ByteStreamReadCfg
17 acc.merge(ByteStreamReadCfg(flags, ["TileRawChannelContainer/MuRcvRawChCnt"]))
18
19 from TileConditions.TileInfoLoaderConfig import TileInfoLoaderCfg
20 acc.merge( TileInfoLoaderCfg(flags) )
21
22 from TileConditions.TileCablingSvcConfig import TileCablingSvcCfg
23 acc.merge(TileCablingSvcCfg(flags))
24
25 from TileConditions.TileEMScaleConfig import TileEMScaleCondAlgCfg
26 acc.merge( TileEMScaleCondAlgCfg(flags) )
27
28 tmdbAlg = CompFactory.TileMuonReceiverDecision('TileMuonReceiverDecision'
29 , TileRawChannelContainer = "MuRcvRawChCnt" # input
30 , TileMuonReceiverContainer = "rerunTileMuRcvCnt" # output
31 , ManualRunPeriod = 2 # forcing Run 2 format (=2) for now, until TGC implements Run 3 format (=3)
32 # run 2 thresholds
33 , MuonReceiverEneThreshCellD6Low = 500
34 , MuonReceiverEneThreshCellD6andD5Low = 500
35 , MuonReceiverEneThreshCellD6High = 600
36 , MuonReceiverEneThreshCellD6andD5High = 600
37 # run 3 thresholds
38 , MuonReceiverEneThreshCellD5 = 500
39 , MuonReceiverEneThreshCellD6 = 500
40 , MuonReceiverEneThreshCellD5andD6 = 500)
41 acc.addEventAlgo(tmdbAlg)
42 return acc
43
44def MuonBytestream2RdoConfig(flags):
45 acc = ComponentAccumulator()
46 if flags.Input.isMC:
47 return acc
48
49 postFix = "_L1MuonSim"
50 from MuonConfig.MuonBytestreamDecodeConfig import MuonCacheNames
51 cacheCreator = CompFactory.MuonCacheCreator(RpcCacheKey = MuonCacheNames.RpcCache,
52 TgcCacheKey = MuonCacheNames.TgcCache,
53 MdtCsmCacheKey = MuonCacheNames.MdtCsmCache,
54 CscCacheKey = (MuonCacheNames.CscCache if flags.Detector.GeometryCSC else ""))
55 acc.addEventAlgo(cacheCreator)
56 # for RPC
57 RPCRodDecoder = CompFactory.Muon.RpcROD_Decoder(name = "RpcROD_Decoder" + postFix, NOBXS=flags.Trigger.L1MuonSim.RPCNBX)
58 MuonRpcRawDataProviderTool = CompFactory.Muon.RPC_RawDataProviderTool(name = "RPC_RawDataProviderTool" + postFix,
59 RpcContainerCacheKey = MuonCacheNames.RpcCache,
60 WriteOutRpcSectorLogic = False,
61 Decoder = RPCRodDecoder,
62 RdoLocation = "RPCPAD_L1" )
63 RpcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "RpcRawDataProvider" + postFix,
64 ProviderTool = MuonRpcRawDataProviderTool,
65 UseHashIds = False,
66 DecodePerRoI = True)
67 acc.addEventAlgo(RpcRawDataProvider)
68 # for TGC
69 TGCRodDecoder = CompFactory.Muon.TGC_RodDecoderReadout(name = "TGC_RodDecoderReadout" + postFix)
70 MuonTgcRawDataProviderTool = CompFactory.Muon.TGC_RawDataProviderTool(name = "TGC_RawDataProviderTool" + postFix,
71 TgcContainerCacheKey = MuonCacheNames.TgcCache,
72 Decoder = TGCRodDecoder,
73 RdoLocation = "TGCRDO_L1")
74 TgcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "TgcRawDataProvider" + postFix,
75 ProviderTool = MuonTgcRawDataProviderTool,
76 UseHashIds = True,
77 DecodePerRoI = True)
78 acc.addEventAlgo(TgcRawDataProvider)
79 # for sTGC
80 if flags.Detector.GeometrysTGC:
81 from MuonConfig.MuonBytestreamDecodeConfig import sTgcRODDecoderCfg
82 MuonsTgcRawDataProviderTool = CompFactory.Muon.STGC_RawDataProviderTool(name = "STGC_RawDataProviderTool"+postFix,
83 Decoder = acc.popToolsAndMerge(sTgcRODDecoderCfg(flags,
84 name = "sTgcROD_Decoder"+postFix)),
85 RdoLocation = "sTGCRDO_L1")
86 sTgcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "sTgcRawDataProvider"+postFix,
87 ProviderTool = MuonsTgcRawDataProviderTool,
88 UseHashIds = False,
89 DecodePerRoI = False)
90 acc.addEventAlgo(sTgcRawDataProvider)
91
92 # for MM
93 if flags.Detector.GeometryMM:
94 from MuonConfig.MuonBytestreamDecodeConfig import MmRDODDecoderCfg
95 Muon_MM_RawDataProviderTool = CompFactory.Muon.MM_RawDataProviderTool
96 MuonMmRawDataProviderTool = Muon_MM_RawDataProviderTool(name = "MM_RawDataProviderTool"+postFix,
97 Decoder = acc.popToolsAndMerge(MmRDODDecoderCfg(flags,
98 name="MM_RODDecoder"+postFix)),
99 RdoLocation = "MMRDO_L1")
100 MmRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "MmRawDataProvider"+postFix,
101 ProviderTool = MuonMmRawDataProviderTool,
102 UseHashIds = False,
103 DecodePerRoI = False)
104 acc.addEventAlgo(MmRawDataProvider)
105
106 if flags.Trigger.L1MuonSim.EmulateNSW and flags.Trigger.L1MuonSim.NSWVetoMode:
107 # for MDT
108 MDTRodDecoder = CompFactory.MdtROD_Decoder(name = "MdtROD_Decoder" + postFix)
109 MuonMdtRawDataProviderTool = CompFactory.Muon.MDT_RawDataProviderTool(name = f"MDT_RawDataProviderTool{postFix}",
110 CsmContainerCacheKey = MuonCacheNames.MdtCsmCache,
111 Decoder = MDTRodDecoder,
112 RdoLocation = "MDTCSM_L1")
113 MdtRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "MdtRawDataProvider" + postFix,
114 ProviderTool = MuonMdtRawDataProviderTool,
115 UseHashIds = False,
116 DecodePerRoI = True)
117 acc.addEventAlgo(MdtRawDataProvider)
118 # for CSC
119 if flags.Detector.GeometryCSC:
120 CSCRodDecoder = CompFactory.Muon.CscROD_Decoder(name = "CscROD_Decoder" + postFix,
121 IsCosmics = False,
122 IsOldCosmics = False )
123 MuonCscRawDataProviderTool = CompFactory.Muon.CSC_RawDataProviderToolMT(name = "CSC_RawDataProviderToolMT" + postFix,
124 CscContainerCacheKey = MuonCacheNames.CscCache,
125 Decoder = CSCRodDecoder,
126 RdoLocation = "CSCRDO_L1" )
127 CscRawDataProvider = CompFactory.Muon.MuonRawDataProvider(name = "CscRawDataProvider" + postFix,
128 ProviderTool = MuonCscRawDataProviderTool,
129 UseHashIds = True,
130 DecodePerRoI = True,
131 RequireDetectorManager = True,
132 DetectorManagerKey = "MuonDetectorManager",
133 IgnoreMissingRoIs = True)
134 acc.addEventAlgo(CscRawDataProvider)
135
136 return acc
137
138def MuonRdo2PrdConfig(flags):
139 acc = ComponentAccumulator()
140 if not flags.Trigger.L1MuonSim.EmulateNSW or not flags.Trigger.L1MuonSim.NSWVetoMode:
141 return acc
142 postFix = "_L1MuonSim"
143 suffix = "" if flags.Input.isMC else "_L1"
144 if flags.Input.Format is Format.POOL:
145 rdoInputs = [
146 ('RpcPadContainer','RPCPAD'),
147 ('TgcRdoContainer','TGCRDO'),
148 ('CscRawDataContainer','CSCRDO'),
149 ('MdtCsmContainer','MDTCSM')
150 ]
151 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
152 acc.merge(SGInputLoaderCfg(flags, Load=rdoInputs))
153
154 if flags.Detector.GeometryCSC:
155 from MuonConfig.MuonRdoDecodeConfig import CscRDODecodeCfg
156 acc.merge(CscRDODecodeCfg(flags,name= "CscRdoToCscPrepData" + postFix, RDOContainer = "CSCRDO"+suffix))
157 CscClusterBuilderTool = CompFactory.CscThresholdClusterBuilderTool(name = "CscThresholdClusterBuilderTool" + postFix)
158 CscClusterBuilder = CompFactory.CscThresholdClusterBuilder(name = "CscThresholdClusterBuilder"+postFix,
159 cluster_builder = CscClusterBuilderTool)
160 acc.addEventAlgo(CscClusterBuilder)
161
162 from MuonConfig.MuonRdoDecodeConfig import MdtRDODecodeCfg
163 acc.merge(MdtRDODecodeCfg(flags, name = "MdtRdoToMdtPrepData" + postFix,
164 RDOContainer = "MDTCSM"+suffix ))
165
166 from MuonConfig.MuonRdoDecodeConfig import RpcRDODecodeCfg
167 acc.merge(RpcRDODecodeCfg(flags, name = "RpcRdoToRpcPrepData" + postFix,
168 RDOContainer = "RPCPAD"+suffix))
169
170 from MuonConfig.MuonRdoDecodeConfig import TgcRDODecodeCfg
171 acc.merge(TgcRDODecodeCfg(flags, name = "TgcRdoToPrepData" + postFix,
172 RDOContainer = "TGCRDO"+suffix))
173 return acc
174
175def RecoMuonSegmentSequence(flags):
176 acc = ComponentAccumulator()
177 if not flags.Trigger.L1MuonSim.EmulateNSW or not flags.Trigger.L1MuonSim.NSWVetoMode:
178 return acc
179 postFix = "_L1MuonSim"
180 theMuonLayerHough = CompFactory.MuonLayerHoughAlg("MuonLayerHoughAlg" + postFix,
181 TgcPrepDataContainer = "TGC_Measurements",
182 RpcPrepDataContainer = "RPC_Measurements",
183 CscPrepDataContainer = ("CSC_Clusters" if flags.Detector.GeometryCSC else ""),
184 MdtPrepDataContainer = "MDT_DriftCircles",
185 sTgcPrepDataContainer = ("STGC_Measurements" if flags.Detector.GeometrysTGC else ""),
186 MMPrepDataContainer = ("MM_Measurements" if flags.Detector.GeometryMM else "") )
187 acc.addEventAlgo(theMuonLayerHough)
188 theSegmentFinderAlg = CompFactory.MuonSegmentFinderAlg("MuonSegmentFinderAlg" + postFix)
189 if not flags.Detector.GeometryCSC:
190 theSegmentFinderAlg.CSC_clusterkey = ""
191 theSegmentFinderAlg.Csc2dSegmentMaker = ""
192 theSegmentFinderAlg.Csc4dSegmentMaker = ""
193 acc.addEventAlgo(theSegmentFinderAlg)
194 xAODMuonSegmentCnv = CompFactory.xAODMaker.MuonSegmentCnvAlg("MuonSegmentCnvAlg" + postFix)
195 acc.addEventAlgo(xAODMuonSegmentCnv)
196 return acc
197
198
199
200def MuonRdoToMuonDigitToolCfg(flags, name="MuonRdoToMuonDigitTool", **kwargs ):
201 result = ComponentAccumulator()
202 kwargs.setdefault("DecodeSTGC_RDO", flags.Detector.GeometrysTGC)
203 kwargs.setdefault("DecodeMM_RDO", flags.Detector.GeometryMM)
204 kwargs.setdefault("DecodeNrpcRDO", flags.Muon.enableNRPC)
205 from MuonConfig.MuonByteStreamCnvTestConfig import STgcRdoDecoderCfg, MMRdoDecoderCfg, MdtRdoDecoderCfg
206 kwargs.setdefault( "stgcRdoDecoderTool", result.popToolsAndMerge(STgcRdoDecoderCfg(flags))
207 if flags.Detector.GeometrysTGC else "" )
208 kwargs.setdefault("mmRdoDecoderTool", result.popToolsAndMerge(MMRdoDecoderCfg(flags))
209 if flags.Detector.GeometryMM else "" )
210 kwargs.setdefault("mdtRdoDecoderTool", result.popToolsAndMerge(MdtRdoDecoderCfg(flags)))
211 #Set N BCs and central BC consistently with RPC readout settings
212 rpcrdo_decode = CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder", BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
213 kwargs.setdefault("rpcRdoDecoderTool", rpcrdo_decode)
214
215 the_tool = CompFactory.MuonRdoToMuonDigitTool (name, **kwargs)
216 result.setPrivateTools(the_tool)
217 return result
218
219def MuonRdo2DigitConfig(flags):
220 acc = ComponentAccumulator()
221
222 from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
223 acc.merge( AtlasFieldCacheCondAlgCfg(flags) )
224 # Read RPCPAD and TGCRDO from the input POOL file (for BS it comes from [Rpc|Tgc]RawDataProvider)
225 suffix = "" if flags.Input.Format is Format.POOL else "_L1"
226 RPCRdoName = "RPCPAD"+suffix
227 TGCRdoName = "TGCRDO"+suffix
228 MMRdoName = "MMRDO"+suffix
229 sTGCRdoName = "sTGCRDO"+suffix
230
231 if flags.Input.Format is Format.POOL:
232 rdoInputs = [('TgcRdoContainer','TGCRDO')]
233
234 if 'RPCPAD' in flags.Input.Collections:
235 rdoInputs += [('RpcPadContainer','RPCPAD')]
236 # Read MMRDO and sTGCRDO
237 if flags.Detector.GeometrysTGC or flags.Detector.GeometryMM:
238 rdoInputs += [
239 ('Muon::MM_RawDataContainer','MMRDO'),
240 ('Muon::STGC_RawDataContainer','sTGCRDO')
241 ]
242 if flags.Muon.enableNRPC and ("NRPCRDO" in flags.Input.Collections):
243 rdoInputs += [
244 ('xAOD::NRPCRDOContainer' , 'NRPCRDO'),
245 ('xAOD::NRPCRDOAuxContainer', 'NRPCRDOAux.')
246 ]
247 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
248 acc.merge(SGInputLoaderCfg(flags, Load=rdoInputs))
249
250 from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
251 acc.merge(MuonGeoModelCfg(flags))
252
253 from MuonConfig.MuonByteStreamCnvTestConfig import RpcRdoToRpcDigitCfg, TgcRdoToTgcDigitCfg, STGC_RdoToDigitCfg, MM_RdoToDigitCfg
254
255 acc.merge(RpcRdoToRpcDigitCfg(flags, RpcDigitContainer = "RPC_DIGITS_L1", RpcRdoContainer = RPCRdoName ))
256 acc.merge(TgcRdoToTgcDigitCfg(flags, TgcDigitContainer = "TGC_DIGITS_L1", TgcRdoContainer = TGCRdoName ))
257 if flags.Detector.GeometrysTGC:
258 acc.merge(STGC_RdoToDigitCfg(flags, sTgcRdoContainer = sTGCRdoName, sTgcDigitContainer = "sTGC_DIGITS_L1"))
259 if flags.Detector.GeometryMM:
260 acc.merge(MM_RdoToDigitCfg(flags, MmRdoContainer = MMRdoName, MmDigitContainer = "MM_DIGITS_L1" ))
261
262 return acc
263
264def NSWTriggerConfig(flags):
265 acc = ComponentAccumulator()
266 if not flags.Detector.GeometrysTGC and not flags.Detector.GeometryMM:
267 return acc
268
269 if flags.Input.Format is Format.POOL and flags.Input.isMC:
270 rdoInputs = [
271 ('McEventCollection','TruthEvent'), # for MM trigger
272 *( [('MuonSimDataCollection','sTGC_SDO')] if not flags.Muon.usePhaseIIGeoSetup else [] ), # for sTGC Pad trigger
273 ('TrackRecordCollection','MuonEntryLayer'), # for MM trigger
274 ]
275 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
276 acc.merge(SGInputLoaderCfg(flags, Load=rdoInputs))
277
278 PadEmulatorTool = CompFactory.NSWL1.PadEmulatorTool("NSWL1__PadEmulatorTool", DoNtuple=flags.Trigger.L1MuonSim.WritesTGCBranches, IsMC = flags.Input.isMC, sTGC_DigitContainerName="sTGC_DIGITS_L1")
279 MMTriggerTool = CompFactory.NSWL1.MMTriggerTool("NSWL1__MMTriggerTool",DoNtuple=flags.Trigger.L1MuonSim.WriteMMBranches, IsMC = flags.Input.isMC, MmDigitContainer="MM_DIGITS_L1")
280 TriggerProcessorTool = CompFactory.NSWL1.TriggerProcessorTool("NSWL1__TriggerProcessorTool")
281
282 # Include NswDcsDb Algorithm for data
283 if not flags.Input.isMC:
284 from MuonConfig.MuonCondAlgConfig import NswDcsDbAlgCfg
285 acc.merge(NswDcsDbAlgCfg(flags))
286
287 nswAlg = CompFactory.NSWL1.NSWL1Simulation("NSWL1Simulation",
288 DoNtuple = flags.Trigger.L1MuonSim.WriteNSWDebugNtuple,
289 DoMM = flags.Trigger.L1MuonSim.doMMTrigger,
290 DoMMDiamonds = flags.Trigger.L1MuonSim.doMMTrigger,
291 DosTGC = flags.Trigger.L1MuonSim.doPadTrigger or flags.Trigger.L1MuonSim.doStripTrigger,
292 DoPad = flags.Trigger.L1MuonSim.doPadTrigger,
293 PadEmulatorTool = PadEmulatorTool,
294 DoStrip = flags.Trigger.L1MuonSim.doStripTrigger,
295 MMTriggerTool = MMTriggerTool,
296 TriggerProcessorTool = TriggerProcessorTool,
297 NSWTrigRDOContainerName = "L1_NSWTrigContainer" )
298 acc.addEventAlgo(nswAlg)
299 return acc
300
301def RPCTriggerConfig(flags):
302 acc = ComponentAccumulator()
303 rpcAlg = CompFactory.TrigT1RPC("TrigT1RPC",
304 Hardware = True,
305 DataDetail = False,
306 RPCbytestream = False,
307 RPCbytestreamFile = "",
308 RPCDigitContainer = "RPC_DIGITS_L1",
309 useRun3Config = True,
310 NOBXS=flags.Trigger.L1MuonSim.RPCNBX,
311 BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
312 acc.addEventAlgo(rpcAlg)
313 from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
314 acc.merge( RPCCablingConfigCfg(flags) ) # trigger roads
315 return acc
316
317def TGCTriggerConfig(flags):
318 acc = ComponentAccumulator()
319 tgcAlg = CompFactory.LVL1TGCTrigger.LVL1TGCTrigger("LVL1TGCTrigger",
320 InputData_perEvent = "TGC_DIGITS_L1",
321 InputRDO = "TGCRDO" if flags.Input.isMC else "TGCRDO_L1",
322 useRun3Config = True,
323 TileMuRcv_Input = "rerunTileMuRcvCnt",
324 TILEMU = True)
325 if (flags.Detector.GeometrysTGC or flags.Detector.GeometryMM):
326 tgcAlg.MaskFileName12 = "TrigT1TGCMaskedChannel.noFI._12.db"
327 tgcAlg.USENSW = True
328 tgcAlg.NSWSideInfo = "AC"
329 tgcAlg.NSWTrigger_Input = "L1_NSWTrigContainer"
330 tgcAlg.FORCENSWCOIN = not flags.Trigger.L1MuonSim.NSWVetoMode
331 tgcAlg.USEBIS78 = flags.Trigger.L1MuonSim.doBIS78
332 else:
333 tgcAlg.MaskFileName12 = "TrigT1TGCMaskedChannel._12.db"
334
335 if flags.Trigger.L1MuonSim.EmulateNSW:
336 tgcAlg.MuctpiPhase1LocationTGC = "L1MuctpiStoreTGCint"
337
338 if flags.Input.Format is Format.BS:
339 from TriggerJobOpts.TriggerByteStreamConfig import ByteStreamReadCfg
340 readBSConfig = ByteStreamReadCfg(flags, ['ByteStreamMetadataContainer/ByteStreamMetadata'])
341 acc.merge(readBSConfig)
342 else:
343 tgcAlg.ByteStreamMetadataRHKey = ''
344 acc.addEventAlgo(tgcAlg)
345
346 from PathResolver import PathResolver
347 bwCW_Run3_filePath=PathResolver.FindCalibFile("TrigT1TGC_CW/BW/CW_BW_Run3.v01.db")
348 acc.merge(addFolders(flags, '<db>sqlite://;schema={0};dbname=OFLP200</db> /TGC/TRIGGER/CW_BW_RUN3'.format(bwCW_Run3_filePath),
349 tag='TgcTriggerCwBwRun3-01',
350 className='CondAttrListCollection'))
351 acc.addCondAlgo(CompFactory.TGCTriggerCondAlg())
352 from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
353 acc.merge( TGCCablingConfigCfg(flags) )
354 return acc
355
356def TGCModifierConfig(flags):
357 acc = ComponentAccumulator()
358 if not flags.Trigger.L1MuonSim.EmulateNSW:
359 return acc
360 recTool = CompFactory.LVL1.TrigT1TGCRecRoiTool("TrigT1TGCRecRoiToolLegacy")
361 recTool.UseRun3Config=False # this is intentional
362 tgcModifier = CompFactory.LVL1TGCTrigger.TGCOutputModifier("TGCOutputModifier",
363 TrigT1TGCRecRoiTool=recTool,
364 InputMuctpiLocation = "L1MuctpiStoreTGCint",
365 OutputMuctpiLocation = "L1MuctpiStoreTGC",
366 EmulateA = True,
367 EmulateC = True,
368 NSWVetoMode = flags.Trigger.L1MuonSim.NSWVetoMode )
369 acc.addEventAlgo(tgcModifier)
370 return acc
371
372def MuctpiConfig(flags):
373 acc = ComponentAccumulator()
374 rpcRecRoiTool = CompFactory.LVL1.TrigT1RPCRecRoiTool("TrigT1RPCRecRoiTool", UseRun3Config=True)
375 tgcRecRoiTool = CompFactory.LVL1.TrigT1TGCRecRoiTool("TrigT1TGCRecRoiTool", UseRun3Config=True)
376 trigThresholdDecTool = CompFactory.LVL1.TrigThresholdDecisionTool(name="TrigThresholdDecisionTool",
377 RPCRecRoiTool = rpcRecRoiTool,
378 TGCRecRoiTool = tgcRecRoiTool)
379 muctpiTool = CompFactory.LVL1MUCTPIPHASE1.MUCTPI_AthTool(name="MUCTPI_AthTool",
380 MuCTPICTPLocation = 'L1MuCTPItoCTPLocation',
381 OverlapStrategyName = flags.Trigger.MUCTPI.OverlapStrategy,
382 LUTXMLFile = flags.Trigger.MUCTPI.LUTXMLFile,
383 BarrelRoIFile = flags.Trigger.MUCTPI.BarrelRoIFile,
384 EndcapForwardRoIFile = flags.Trigger.MUCTPI.EndcapForwardRoIFile,
385 Side0LUTFile = flags.Trigger.MUCTPI.Side0LUTFile,
386 Side1LUTFile = flags.Trigger.MUCTPI.Side1LUTFile,
387 InputSource = 'DIGITIZATION',
388 RPCRecRoiTool = rpcRecRoiTool,
389 TGCRecRoiTool = tgcRecRoiTool,
390 TrigThresholdDecisionTool = trigThresholdDecTool)
391 muctpiAlg = CompFactory.LVL1MUCTPIPHASE1.MUCTPI_AthAlg(name="MUCTPI_AthAlg",
392 MUCTPI_AthTool = muctpiTool)
393 acc.addEventAlgo(muctpiAlg)
394 from TrigConfigSvc.TrigConfigSvcCfg import L1ConfigSvcCfg
395 acc.merge(L1ConfigSvcCfg(flags))
396 return acc
397
398
399def Lvl1MuonSimulationCfg(flags):
400 acc = ComponentAccumulator()
401
402 acc.merge(MuonBytestream2RdoConfig(flags)) # data prep for muon bytestream data
403 acc.merge(MuonRdo2DigitConfig(flags)) # input for rpc/tgc trigger simulation
404 acc.merge(RPCTriggerConfig(flags)) # rpc trigger simulation, including bis78 to prepare for bis78-tgc coincidence
405 acc.merge(TMDBConfig(flags)) # for tmdb decision to prepare for tile-muon coincidence
406 acc.merge(NSWTriggerConfig(flags)) # nsw trigger simulation to prepare input for nsw-tgc coincidence
407 acc.merge(TGCTriggerConfig(flags)) # tgc trigger simulation
408 acc.merge(MuonRdo2PrdConfig(flags)) # data prep for nsw-tgc coincidence emulator
409 acc.merge(RecoMuonSegmentSequence(flags)) # segment reco for nsw-tgc coincidence emulator
410 acc.merge(TGCModifierConfig(flags)) # overwrite output from tgc by nsw-tgc coincidence emulator
411 acc.merge(MuctpiConfig(flags)) # muctpi simulation
412
413 return acc
414
415if __name__ == "__main__":
416 import sys
417 from AthenaConfiguration.AllConfigFlags import initConfigFlags
418 flags = initConfigFlags()
419 flags.Input.Files = ['/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/TriggerTest/valid1.601229.PhPy8EG_A14_ttbar_hdamp258p75_SingleLep.recon.RDO.e8514_e8528_s4159_s4114_r14799_tid34171421_00/RDO.34171421._000011.pool.root.1']
420 flags.Exec.MaxEvents = 5
421 flags.Concurrency.NumThreads = 1
422 flags.Trigger.triggerMenuSetup = 'Dev_pp_run3_v1'
423 flags.fillFromArgs()
424 flags.lock()
425
426 from AthenaConfiguration.MainServicesConfig import MainServicesCfg
427 acc = MainServicesCfg(flags)
428
429 from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
430 acc.merge(PoolReadCfg(flags))
431
432 from TrigConfigSvc.TrigConfigSvcCfg import generateL1Menu
433 generateL1Menu(flags)
434
435 acc.merge(Lvl1MuonSimulationCfg(flags))
436
437 acc.printConfig(withDetails=True, summariseProps=True, printDefaults=True)
438 sys.exit(acc.run().isFailure())
PathResolver::FindCalibFile
static std::string FindCalibFile(const std::string &logical_file_name)
Definition PathResolver.h:63
python.Lvl1MuonSimulationConfig.MuonRdoToMuonDigitToolCfg
MuonRdoToMuonDigitToolCfg(flags, name="MuonRdoToMuonDigitTool", **kwargs)
Definition Lvl1MuonSimulationConfig.py:200
Generated on for ATLAS Offline Software by doxygen 1.14.0