ATLAS Offline Software
Loading...
Searching...
No Matches
Functions
MuonByteStreamCnvTestConfig Namespace Reference

Functions

 MdtRDO_DecoderCfg (flags, name="Muon::MdtRDO_Decoder", **kwargs)
 MdtRdoToMdtDigitCfg (flags, name="MdtRdoToMdtDigitAlg", **kwargs)
 RpcRdoToRpcDigitCfg (flags, name="RpcRdoToRpcDigitAlg", **kwargs)
 TgcRdoToTgcDigitCfg (flags, name="TgcRdoToTgcDigitAlg", **kwargs)
 STGC_RdoToDigitCfg (flags, name="STGC_RdoToDigitAlg", **kwargs)
 MM_RdoToDigitCfg (flags, name="MM_RdoToDigitAlg", **kwargs)
 MdtDigitToMdtRDOCfg (flags, name="MdtDigitToMdtRDO", **kwargs)
 RpcDigitToRpcRDOCfg (flags, name="RpcDigitToRpcRDO", **kwargs)
 NrpcDigitToNrpcRDOCfg (flags, name="NrpcDigitToNrpcRDO", **kwargs)
 TgcDigitToTgcRDOCfg (flags, name="TgcDigitToTgcRDO", **kwargs)
 CscDigitToCscRDOToolCfg (flags, name="CscDigitToCscRDOTool", **kwargs)
 CscDigitToCscRDOCfg (flags, name="CscDigitToCscRDO", **kwargs)
 STGC_DigitToRDOCfg (flags, name="STGC_DigitToRDO", **kwargs)
 MM_DigitToRDOCfg (flags, name="MM_DigitToRDO", **kwargs)
 SigMdtDigitToMdtRDOCfg (flags, name="SigMdtDigitToMdtRDO", **kwargs)
 SigRpcDigitToRpcRDOCfg (flags, name="SigRpcDigitToRpcRDO", **kwargs)
 SigTgcDigitToTgcRDOCfg (flags, name="SigTgcDigitToTgcRDO", **kwargs)
 STgcRdoDecoderCfg (flags, name="STGC_RDO_Decoder", **kwargs)
 MMRdoDecoderCfg (flags, name="MM_RDO_Decoder", **kwargs)
 MdtRdoDecoderCfg (flags, name="MDT_RDO_Decoder", **kwargs)

Detailed Description

Define ComponentAccumulator functions for configuration of muon data conversions

Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration

Function Documentation

◆ CscDigitToCscRDOCfg()

MuonByteStreamCnvTestConfig.CscDigitToCscRDOCfg ( flags,
name = "CscDigitToCscRDO",
** kwargs ) 
Return ComponentAccumulator with configured CscDigitToCscRDO algorithm

Definition at line 255 of file MuonByteStreamCnvTestConfig.py.

255def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO", **kwargs):
256 """Return ComponentAccumulator with configured CscDigitToCscRDO algorithm"""
257 # for CSC, configuration is in the tool CscDigitToCscRDOTool
258 acc = ComponentAccumulator()
259 kwargs.setdefault("CscDigitToRDOTool", acc.popToolsAndMerge(CscDigitToCscRDOToolCfg(flags)))
260
261 if flags.Concurrency.NumThreads > 0:
262 kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
263
264 acc.addEventAlgo(CompFactory.CscDigitToCscRDO(name, **kwargs))
265 return acc
266
267

◆ CscDigitToCscRDOToolCfg()

MuonByteStreamCnvTestConfig.CscDigitToCscRDOToolCfg ( flags,
name = "CscDigitToCscRDOTool",
** kwargs ) 
Return ComponentAccumulator with configured CscDigitToCscRDOTool

Definition at line 230 of file MuonByteStreamCnvTestConfig.py.

230def CscDigitToCscRDOToolCfg(flags, name="CscDigitToCscRDOTool", **kwargs):
231 """Return ComponentAccumulator with configured CscDigitToCscRDOTool"""
232 acc = ComponentAccumulator()
233 # configure basic parameters
234 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
235 from MuonConfig.MuonCalibrationConfig import CscCalibToolCfg
236 kwargs.setdefault("cscCalibTool", acc.popToolsAndMerge(CscCalibToolCfg(flags)))
237 kwargs.setdefault("NumSamples", 4)
238 kwargs.setdefault("Latency", 0)
239 kwargs.setdefault("addNoise", not flags.Common.isOverlay) # doMuonNoise flag not migrated
240
241 if flags.Common.isOverlay:
242 kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}CSC_DIGITS")
243 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}CSCRDO")
244 elif flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
245 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}CSCRDO")
246 else:
247 kwargs.setdefault("OutputObjectName", "CSCRDO")
248
249 from RngComps.RngCompsConfig import AthRNGSvcCfg
250 kwargs.setdefault("RndmSvc", acc.getPrimaryAndMerge(AthRNGSvcCfg(flags)))
251 acc.setPrivateTools(CompFactory.CscDigitToCscRDOTool("CscDigitToCscRDOTool", **kwargs))
252 return acc
253
254

◆ MdtDigitToMdtRDOCfg()

MuonByteStreamCnvTestConfig.MdtDigitToMdtRDOCfg ( flags,
name = "MdtDigitToMdtRDO",
** kwargs ) 
Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm

Definition at line 164 of file MuonByteStreamCnvTestConfig.py.

164def MdtDigitToMdtRDOCfg(flags, name="MdtDigitToMdtRDO", **kwargs):
165 """Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm"""
166 acc = ComponentAccumulator()
167 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
168 if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
169 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}MDTCSM")
170 else:
171 kwargs.setdefault("OutputObjectName", "MDTCSM")
172
173 acc.addEventAlgo(CompFactory.MdtDigitToMdtRDO(name, **kwargs))
174 return acc
175
176

◆ MdtRDO_DecoderCfg()

MuonByteStreamCnvTestConfig.MdtRDO_DecoderCfg ( flags,
name = "Muon::MdtRDO_Decoder",
** kwargs )

Definition at line 12 of file MuonByteStreamCnvTestConfig.py.

12def MdtRDO_DecoderCfg(flags, name="Muon::MdtRDO_Decoder", **kwargs):
13 acc = MuonIdHelperSvcCfg(flags)
14 acc.merge(MDTCablingConfigCfg(flags)) # To provide the Cabling map
15 kwargs.setdefault("MuonIdHelperSvc", acc.getService("MuonIdHelperSvc"))
16 acc.setPrivateTools(CompFactory.Muon.MdtRDO_Decoder(name, **kwargs))
17 return acc
18
19

◆ MdtRdoDecoderCfg()

MuonByteStreamCnvTestConfig.MdtRdoDecoderCfg ( flags,
name = "MDT_RDO_Decoder",
** kwargs )

Definition at line 348 of file MuonByteStreamCnvTestConfig.py.

348def MdtRdoDecoderCfg(flags, name="MDT_RDO_Decoder", **kwargs):
349 result = ComponentAccumulator()
350 from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
351 result.merge(MDTCablingConfigCfg(flags))
352 result.setPrivateTools(CompFactory.Muon.MdtRDO_Decoder(name, **kwargs))
353 return result

◆ MdtRdoToMdtDigitCfg()

MuonByteStreamCnvTestConfig.MdtRdoToMdtDigitCfg ( flags,
name = "MdtRdoToMdtDigitAlg",
** kwargs ) 
Return ComponentAccumulator with configured MdtRdoToMdtDigit algorithm

Definition at line 20 of file MuonByteStreamCnvTestConfig.py.

20def MdtRdoToMdtDigitCfg(flags, name="MdtRdoToMdtDigitAlg", **kwargs):
21 """Return ComponentAccumulator with configured MdtRdoToMdtDigit algorithm"""
22 acc = MuonIdHelperSvcCfg(flags)
23
24 if flags.Common.isOverlay:
25 kwargs.setdefault("MdtRdoContainer", f"{flags.Overlay.BkgPrefix}MDTCSM")
26 kwargs.setdefault("MdtDigitContainer", f"{flags.Overlay.BkgPrefix}MDT_DIGITS")
27
28 if flags.Overlay.ByteStream:
29 from MuonConfig.MuonBytestreamDecodeConfig import MdtBytestreamDecodeCfg
30 acc.merge(MdtBytestreamDecodeCfg(flags))
31 else:
32 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
33 acc.merge(SGInputLoaderCfg(flags, [f'MdtCsmContainer#{kwargs["MdtRdoContainer"]}']))
34 else:
35 kwargs.setdefault("MdtRdoContainer", "MDTCSM")
36 kwargs.setdefault("MdtDigitContainer", "MDT_DIGITS")
37
38 kwargs.setdefault("mdtRdoDecoderTool", acc.popToolsAndMerge(MdtRDO_DecoderCfg(flags)))
39
40 acc.addEventAlgo(CompFactory.MdtRdoToMdtDigit(name, **kwargs))
41 return acc
42
43

◆ MM_DigitToRDOCfg()

MuonByteStreamCnvTestConfig.MM_DigitToRDOCfg ( flags,
name = "MM_DigitToRDO",
** kwargs ) 
Return ComponentAccumulator with configured MM_DigitToRDO algorithm

Definition at line 285 of file MuonByteStreamCnvTestConfig.py.

285def MM_DigitToRDOCfg(flags, name="MM_DigitToRDO", **kwargs):
286 """Return ComponentAccumulator with configured MM_DigitToRDO algorithm"""
287 acc = ComponentAccumulator()
288 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
289
290 if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
291 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}MMRDO")
292 else:
293 kwargs.setdefault("OutputObjectName", "MMRDO")
294
295 from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
296 kwargs.setdefault("CalibrationTool", acc.popToolsAndMerge(NSWCalibToolCfg(flags)))
297
298 acc.addEventAlgo(CompFactory.MM_DigitToRDO(name, **kwargs))
299 return acc
300
301

◆ MM_RdoToDigitCfg()

MuonByteStreamCnvTestConfig.MM_RdoToDigitCfg ( flags,
name = "MM_RdoToDigitAlg",
** kwargs ) 
Return ComponentAccumulator with configured MM_RdoToDigit algorithm

Definition at line 140 of file MuonByteStreamCnvTestConfig.py.

140def MM_RdoToDigitCfg(flags, name="MM_RdoToDigitAlg", **kwargs):
141 """Return ComponentAccumulator with configured MM_RdoToDigit algorithm"""
142 acc = ComponentAccumulator()
143
144 if flags.Common.isOverlay:
145 kwargs.setdefault("MmRdoContainer", f"{flags.Overlay.BkgPrefix}MMRDO")
146 kwargs.setdefault("MmDigitContainer", f"{flags.Overlay.BkgPrefix}MM_DIGITS")
147
148 if flags.Overlay.ByteStream:
149 from MuonConfig.MuonBytestreamDecodeConfig import MmBytestreamDecodeCfg
150 acc.merge(MmBytestreamDecodeCfg(flags))
151 else:
152 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
153 acc.merge(SGInputLoaderCfg(flags, [f'Muon::MM_RawDataContainer#{kwargs["MmRdoContainer"]}']))
154 else:
155 kwargs.setdefault("MmRdoContainer", "MMRDO")
156 kwargs.setdefault("MmDigitContainer", "MM_DIGITS")
157
158 kwargs.setdefault("mmRdoDecoderTool", acc.popToolsAndMerge(MMRdoDecoderCfg(flags)))
159
160 acc.addEventAlgo(CompFactory.MM_RdoToDigit(name, **kwargs))
161 return acc
162
163

◆ MMRdoDecoderCfg()

MuonByteStreamCnvTestConfig.MMRdoDecoderCfg ( flags,
name = "MM_RDO_Decoder",
** kwargs )

Definition at line 340 of file MuonByteStreamCnvTestConfig.py.

340def MMRdoDecoderCfg(flags, name="MM_RDO_Decoder", **kwargs):
341 result = ComponentAccumulator()
342 from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
343 kwargs.setdefault("CalibrationTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
344 result.setPrivateTools(CompFactory.Muon.MM_RDO_Decoder(name, **kwargs))
345 return result
346
347

◆ NrpcDigitToNrpcRDOCfg()

MuonByteStreamCnvTestConfig.NrpcDigitToNrpcRDOCfg ( flags,
name = "NrpcDigitToNrpcRDO",
** kwargs ) 
Return ComponentAccumulator with configured NrpcDigitToNrpcRDO algorithm

Definition at line 196 of file MuonByteStreamCnvTestConfig.py.

196def NrpcDigitToNrpcRDOCfg(flags, name="NrpcDigitToNrpcRDO", **kwargs):
197 """Return ComponentAccumulator with configured NrpcDigitToNrpcRDO algorithm"""
198 acc = ComponentAccumulator()
199 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
200
201 from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
202 acc.merge(NRPCCablingConfigCfg(flags))
203
204 if flags.Muon.usePhaseIIGeoSetup:
205 kwargs.setdefault("ConvertHitsFromStations", [])
206
207 if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
208 kwargs.setdefault("NrpcRdoKey", f"{flags.Overlay.BkgPrefix}NRPCRDO")
209 else:
210 kwargs.setdefault("NrpcRdoKey", "NRPCRDO")
211
212 acc.addEventAlgo(CompFactory.Muon.NrpcDigitToNrpcRDO(name, **kwargs))
213 return acc
214
215

◆ RpcDigitToRpcRDOCfg()

MuonByteStreamCnvTestConfig.RpcDigitToRpcRDOCfg ( flags,
name = "RpcDigitToRpcRDO",
** kwargs ) 
Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm

Definition at line 177 of file MuonByteStreamCnvTestConfig.py.

177def RpcDigitToRpcRDOCfg(flags, name="RpcDigitToRpcRDO", **kwargs):
178 """Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm"""
179 acc = ComponentAccumulator()
180 from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
181 acc.merge(RPCCablingConfigCfg(flags))
182 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
183
184 if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
185 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}RPCPAD")
186 else:
187 kwargs.setdefault("OutputObjectName", "RPCPAD")
188
189 kwargs.setdefault("NOBXS", flags.Trigger.L1MuonSim.RPCNBX)
190 kwargs.setdefault("BCZERO", flags.Trigger.L1MuonSim.RPCNBCZ)
191
192 acc.addEventAlgo(CompFactory.RpcDigitToRpcRDO(name, **kwargs))
193 return acc
194
195

◆ RpcRdoToRpcDigitCfg()

MuonByteStreamCnvTestConfig.RpcRdoToRpcDigitCfg ( flags,
name = "RpcRdoToRpcDigitAlg",
** kwargs ) 
Return ComponentAccumulator with configured RpcRdoToRpcDigit algorithm

Definition at line 44 of file MuonByteStreamCnvTestConfig.py.

44def RpcRdoToRpcDigitCfg(flags, name="RpcRdoToRpcDigitAlg", **kwargs):
45 """Return ComponentAccumulator with configured RpcRdoToRpcDigit algorithm"""
46 acc = ComponentAccumulator()
47
48 if flags.Common.isOverlay or flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
49 kwargs.setdefault("RpcRdoContainer", f"{flags.Overlay.BkgPrefix}RPCPAD")
50 kwargs.setdefault("RpcDigitContainer", f"{flags.Overlay.BkgPrefix}RPC_DIGITS")
51 kwargs.setdefault("NRpcRdoContainer", f"{flags.Overlay.BkgPrefix}NRPCRDO")
52 else:
53 kwargs.setdefault("RpcRdoContainer", "RPCPAD")
54 kwargs.setdefault("RpcDigitContainer", "RPC_DIGITS")
55 kwargs.setdefault("NRpcRdoContainer", "NRPCRDO")
56
57 container = [x for x in flags.Input.TypedCollections \
58 if x == "RpcPadContainer#{cont_name}".format(cont_name=kwargs["RpcRdoContainer"]) or \
59 x == "xAOD::NRPCRDOContainer#{cont_name}".format(cont_name=kwargs["NRpcRdoContainer"]) or \
60 x == "xAOD::NRPCRDOAuxContainer#{cont_name}Aux.".format(cont_name=kwargs["NRpcRdoContainer"]) ]
61
62 if flags.Common.isOverlay:
63 if flags.Overlay.ByteStream:
64 from MuonConfig.MuonBytestreamDecodeConfig import RpcBytestreamDecodeCfg
65 acc.merge(RpcBytestreamDecodeCfg(flags))
66 else:
67 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
68 acc.merge(SGInputLoaderCfg(flags, container))
69
70 # If the length of the list is > 1, then the NRPC container is in the file
71 # and shall be decoded. Same is true if the length is 1 or 3
72 kwargs.setdefault("DecodeNrpcRDO", len(container) > 1 )
73 # If it's data overlay, there's only the legacy container...
74 kwargs.setdefault("DecodeLegacyRDO", len(container) % 2 or \
75 not flags.Input.isMC)
76 if kwargs["DecodeNrpcRDO"]:
77 from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
78 acc.merge(NRPCCablingConfigCfg(flags))
79 if kwargs["DecodeLegacyRDO"]:
80 from MuonConfig.MuonCablingConfig import RPCLegacyCablingConfigCfg
81 acc.merge(RPCLegacyCablingConfigCfg(flags))
82
83 # Set N BCs and central BC consistently with RPC readout settings
84 kwargs.setdefault("rpcRdoDecoderTool", CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder",
85 BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ))
86
87 acc.addEventAlgo(CompFactory.Muon.RpcRdoToRpcDigit(name, **kwargs))
88 return acc
89
90

◆ SigMdtDigitToMdtRDOCfg()

MuonByteStreamCnvTestConfig.SigMdtDigitToMdtRDOCfg ( flags,
name = "SigMdtDigitToMdtRDO",
** kwargs ) 
Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm

Definition at line 302 of file MuonByteStreamCnvTestConfig.py.

302def SigMdtDigitToMdtRDOCfg(flags, name="SigMdtDigitToMdtRDO", **kwargs):
303 """Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm"""
304 acc = ComponentAccumulator()
305 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
306 kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}MDT_DIGITS")
307 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}MDTCSM")
308 acc.addEventAlgo(CompFactory.MdtDigitToMdtRDO(name, **kwargs))
309 return acc
310
311

◆ SigRpcDigitToRpcRDOCfg()

MuonByteStreamCnvTestConfig.SigRpcDigitToRpcRDOCfg ( flags,
name = "SigRpcDigitToRpcRDO",
** kwargs ) 
Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm

Definition at line 312 of file MuonByteStreamCnvTestConfig.py.

312def SigRpcDigitToRpcRDOCfg(flags, name="SigRpcDigitToRpcRDO", **kwargs):
313 """Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm"""
314 acc = ComponentAccumulator()
315 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
316 kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}RPC_DIGITS")
317 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}RPCPAD")
318 acc.addEventAlgo(CompFactory.RpcDigitToRpcRDO(name, **kwargs))
319 return acc
320
321

◆ SigTgcDigitToTgcRDOCfg()

MuonByteStreamCnvTestConfig.SigTgcDigitToTgcRDOCfg ( flags,
name = "SigTgcDigitToTgcRDO",
** kwargs ) 
Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm

Definition at line 322 of file MuonByteStreamCnvTestConfig.py.

322def SigTgcDigitToTgcRDOCfg(flags, name="SigTgcDigitToTgcRDO", **kwargs):
323 """Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm"""
324 acc = ComponentAccumulator()
325 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
326 kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}TGC_DIGITS")
327 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}TGCRDO")
328 acc.addEventAlgo(CompFactory.TgcDigitToTgcRDO(name, **kwargs))
329 return acc
330
331

◆ STGC_DigitToRDOCfg()

MuonByteStreamCnvTestConfig.STGC_DigitToRDOCfg ( flags,
name = "STGC_DigitToRDO",
** kwargs ) 
Return ComponentAccumulator with configured STGC_DigitToRDO algorithm

Definition at line 268 of file MuonByteStreamCnvTestConfig.py.

268def STGC_DigitToRDOCfg(flags, name="STGC_DigitToRDO", **kwargs):
269 """Return ComponentAccumulator with configured STGC_DigitToRDO algorithm"""
270 acc = ComponentAccumulator()
271 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
272
273 if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
274 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}sTGCRDO")
275 else:
276 kwargs.setdefault("OutputObjectName", "sTGCRDO")
277
278 from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
279 kwargs.setdefault("CalibrationTool", acc.popToolsAndMerge(NSWCalibToolCfg(flags)))
280
281 acc.addEventAlgo(CompFactory.STGC_DigitToRDO(name, **kwargs))
282 return acc
283
284

◆ STGC_RdoToDigitCfg()

MuonByteStreamCnvTestConfig.STGC_RdoToDigitCfg ( flags,
name = "STGC_RdoToDigitAlg",
** kwargs ) 
Return ComponentAccumulator with configured STGC_RdoToDigit algorithm

Definition at line 116 of file MuonByteStreamCnvTestConfig.py.

116def STGC_RdoToDigitCfg(flags, name="STGC_RdoToDigitAlg", **kwargs):
117 """Return ComponentAccumulator with configured STGC_RdoToDigit algorithm"""
118 acc = ComponentAccumulator()
119
120 if flags.Common.isOverlay:
121 kwargs.setdefault("sTgcRdoContainer", f"{flags.Overlay.BkgPrefix}sTGCRDO")
122 kwargs.setdefault("sTgcDigitContainer",f"{flags.Overlay.BkgPrefix}sTGC_DIGITS")
123
124 if flags.Overlay.ByteStream:
125 from MuonConfig.MuonBytestreamDecodeConfig import sTgcBytestreamDecodeCfg
126 acc.merge(sTgcBytestreamDecodeCfg(flags))
127 else:
128 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
129 acc.merge(SGInputLoaderCfg(flags, [f'Muon::STGC_RawDataContainer#{kwargs["sTgcRdoContainer"]}']))
130 else:
131 kwargs.setdefault("sTgcRdoContainer", "sTGCRDO")
132 kwargs.setdefault("sTgcDigitContainer", "sTGC_DIGITS")
133
134 kwargs.setdefault("sTgcRdoDecoderTool", acc.popToolsAndMerge(STgcRdoDecoderCfg(flags)))
135
136 acc.addEventAlgo(CompFactory.STGC_RdoToDigit(name, **kwargs))
137 return acc
138
139

◆ STgcRdoDecoderCfg()

MuonByteStreamCnvTestConfig.STgcRdoDecoderCfg ( flags,
name = "STGC_RDO_Decoder",
** kwargs )

Definition at line 332 of file MuonByteStreamCnvTestConfig.py.

332def STgcRdoDecoderCfg(flags, name="STGC_RDO_Decoder", **kwargs):
333 result = ComponentAccumulator()
334 from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
335 kwargs.setdefault("CalibrationTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
336 result.setPrivateTools(CompFactory.Muon.STGC_RDO_Decoder(name, **kwargs))
337 return result
338
339

◆ TgcDigitToTgcRDOCfg()

MuonByteStreamCnvTestConfig.TgcDigitToTgcRDOCfg ( flags,
name = "TgcDigitToTgcRDO",
** kwargs ) 
Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm

Definition at line 216 of file MuonByteStreamCnvTestConfig.py.

216def TgcDigitToTgcRDOCfg(flags, name="TgcDigitToTgcRDO", **kwargs):
217 """Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm"""
218 acc = ComponentAccumulator()
219 kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
220
221 if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
222 kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}TGCRDO")
223 else:
224 kwargs.setdefault("OutputObjectName", "TGCRDO")
225
226 acc.addEventAlgo(CompFactory.TgcDigitToTgcRDO(name, **kwargs))
227 return acc
228
229

◆ TgcRdoToTgcDigitCfg()

MuonByteStreamCnvTestConfig.TgcRdoToTgcDigitCfg ( flags,
name = "TgcRdoToTgcDigitAlg",
** kwargs ) 
Return ComponentAccumulator with configured TgcRdoToTgcDigit algorithm

Definition at line 91 of file MuonByteStreamCnvTestConfig.py.

91def TgcRdoToTgcDigitCfg(flags, name="TgcRdoToTgcDigitAlg", **kwargs):
92 """Return ComponentAccumulator with configured TgcRdoToTgcDigit algorithm"""
93 acc = ComponentAccumulator()
94
95 from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
96 acc.merge(TGCCablingConfigCfg(flags))
97
98 if flags.Common.isOverlay:
99 kwargs.setdefault("TgcRdoContainer", f"{flags.Overlay.BkgPrefix}TGCRDO")
100 kwargs.setdefault("TgcDigitContainer",f"{flags.Overlay.BkgPrefix}TGC_DIGITS")
101
102 if flags.Overlay.ByteStream:
103 from MuonConfig.MuonBytestreamDecodeConfig import TgcBytestreamDecodeCfg
104 acc.merge(TgcBytestreamDecodeCfg(flags))
105 else:
106 from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
107 acc.merge(SGInputLoaderCfg(flags, [f'TgcRdoContainer#{kwargs["TgcRdoContainer"]}']))
108 else:
109 kwargs.setdefault("TgcRdoContainer", "TGCRDO")
110 kwargs.setdefault("TgcDigitContainer", "TGC_DIGITS")
111
112 acc.addEventAlgo(CompFactory.TgcRdoToTgcDigit(name, **kwargs))
113 return acc
114
115
Generated on for ATLAS Offline Software by doxygen 1.14.0