Loading [MathJax]/jax/input/TeX/config.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
Functions
python.MuonByteStreamCnvTestConfig Namespace Reference

Functions

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

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

Definition at line 255 of file MuonByteStreamCnvTestConfig.py.

255 def 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()

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

Definition at line 230 of file MuonByteStreamCnvTestConfig.py.

230 def 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)).name)
251  acc.setPrivateTools(CompFactory.CscDigitToCscRDOTool("CscDigitToCscRDOTool", **kwargs))
252  return acc
253 
254 

◆ MdtDigitToMdtRDOCfg()

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

Definition at line 164 of file MuonByteStreamCnvTestConfig.py.

164 def 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()

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

Definition at line 12 of file MuonByteStreamCnvTestConfig.py.

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

◆ MdtRdoDecoderCfg()

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

Definition at line 348 of file MuonByteStreamCnvTestConfig.py.

348 def 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()

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

Definition at line 20 of file MuonByteStreamCnvTestConfig.py.

20 def 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()

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

Definition at line 285 of file MuonByteStreamCnvTestConfig.py.

285 def 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()

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

Definition at line 140 of file MuonByteStreamCnvTestConfig.py.

140 def 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()

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

Definition at line 340 of file MuonByteStreamCnvTestConfig.py.

340 def 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()

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

Definition at line 196 of file MuonByteStreamCnvTestConfig.py.

196 def 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()

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

Definition at line 177 of file MuonByteStreamCnvTestConfig.py.

177 def 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()

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

Definition at line 44 of file MuonByteStreamCnvTestConfig.py.

44 def 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()

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

Definition at line 302 of file MuonByteStreamCnvTestConfig.py.

302 def 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()

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

Definition at line 312 of file MuonByteStreamCnvTestConfig.py.

312 def 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()

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

Definition at line 322 of file MuonByteStreamCnvTestConfig.py.

322 def 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()

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

Definition at line 268 of file MuonByteStreamCnvTestConfig.py.

268 def 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()

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

Definition at line 116 of file MuonByteStreamCnvTestConfig.py.

116 def 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()

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

Definition at line 332 of file MuonByteStreamCnvTestConfig.py.

332 def 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()

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

Definition at line 216 of file MuonByteStreamCnvTestConfig.py.

216 def 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()

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

Definition at line 91 of file MuonByteStreamCnvTestConfig.py.

91 def 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 
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
vtune_athena.format
format
Definition: vtune_athena.py:14
python.MuonByteStreamCnvTestConfig.MM_DigitToRDOCfg
def MM_DigitToRDOCfg(flags, name="MM_DigitToRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:285
python.MuonBytestreamDecodeConfig.MmBytestreamDecodeCfg
def MmBytestreamDecodeCfg(flags, name="MmRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:348
python.MuonCalibrationConfig.CscCalibToolCfg
def CscCalibToolCfg(flags, name="CscCalibTool", **kwargs)
CSC calibration.
Definition: MuonCalibrationConfig.py:21
python.MuonByteStreamCnvTestConfig.MdtRdoToMdtDigitCfg
def MdtRdoToMdtDigitCfg(flags, name="MdtRdoToMdtDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:20
python.MuonCablingConfig.TGCCablingConfigCfg
def TGCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:86
python.MuonByteStreamCnvTestConfig.RpcDigitToRpcRDOCfg
def RpcDigitToRpcRDOCfg(flags, name="RpcDigitToRpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:177
python.MuonByteStreamCnvTestConfig.MMRdoDecoderCfg
def MMRdoDecoderCfg(flags, name="MM_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:340
python.MuonCablingConfig.MDTCablingConfigCfg
def MDTCablingConfigCfg(flags, name="MuonMDT_CablingAlg", **kwargs)
Definition: MuonCablingConfig.py:100
python.MuonByteStreamCnvTestConfig.SigMdtDigitToMdtRDOCfg
def SigMdtDigitToMdtRDOCfg(flags, name="SigMdtDigitToMdtRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:302
python.MuonByteStreamCnvTestConfig.MdtRDO_DecoderCfg
def MdtRDO_DecoderCfg(flags, name="Muon::MdtRDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:12
python.MuonByteStreamCnvTestConfig.CscDigitToCscRDOToolCfg
def CscDigitToCscRDOToolCfg(flags, name="CscDigitToCscRDOTool", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:230
python.MuonGeometryConfig.MuonIdHelperSvcCfg
def MuonIdHelperSvcCfg(flags)
Definition: MuonGeometryConfig.py:15
python.MuonCalibrationConfig.NSWCalibToolCfg
def NSWCalibToolCfg(flags, name="NSWCalibTool", **kwargs)
Definition: MuonCalibrationConfig.py:177
SGInputLoaderConfig.SGInputLoaderCfg
def SGInputLoaderCfg(flags, Load=None, **kwargs)
Definition: SGInputLoaderConfig.py:7
python.MuonByteStreamCnvTestConfig.STGC_DigitToRDOCfg
def STGC_DigitToRDOCfg(flags, name="STGC_DigitToRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:268
python.MuonCablingConfig.NRPCCablingConfigCfg
def NRPCCablingConfigCfg(flags, name="MuonNRPC_CablingAlg", **kwargs)
Definition: MuonCablingConfig.py:6
python.MuonByteStreamCnvTestConfig.RpcRdoToRpcDigitCfg
def RpcRdoToRpcDigitCfg(flags, name="RpcRdoToRpcDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:44
python.MuonBytestreamDecodeConfig.RpcBytestreamDecodeCfg
def RpcBytestreamDecodeCfg(flags, name="RpcRawDataProvider", **kwargs)
This configuration function sets up everything for decoding RPC bytestream data into RDOs.
Definition: MuonBytestreamDecodeConfig.py:34
python.MuonByteStreamCnvTestConfig.SigTgcDigitToTgcRDOCfg
def SigTgcDigitToTgcRDOCfg(flags, name="SigTgcDigitToTgcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:322
python.MuonByteStreamCnvTestConfig.TgcRdoToTgcDigitCfg
def TgcRdoToTgcDigitCfg(flags, name="TgcRdoToTgcDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:91
python.MuonBytestreamDecodeConfig.TgcBytestreamDecodeCfg
def TgcBytestreamDecodeCfg(flags, name="TgcRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:97
python.MuonByteStreamCnvTestConfig.STGC_RdoToDigitCfg
def STGC_RdoToDigitCfg(flags, name="STGC_RdoToDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:116
python.MuonByteStreamCnvTestConfig.NrpcDigitToNrpcRDOCfg
def NrpcDigitToNrpcRDOCfg(flags, name="NrpcDigitToNrpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:196
python.MuonBytestreamDecodeConfig.MdtBytestreamDecodeCfg
def MdtBytestreamDecodeCfg(flags, name="MdtRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:138
python.MuonByteStreamCnvTestConfig.SigRpcDigitToRpcRDOCfg
def SigRpcDigitToRpcRDOCfg(flags, name="SigRpcDigitToRpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:312
python.MuonByteStreamCnvTestConfig.MdtDigitToMdtRDOCfg
def MdtDigitToMdtRDOCfg(flags, name="MdtDigitToMdtRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:164
python.MuonCablingConfig.RPCCablingConfigCfg
def RPCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:33
python.MuonByteStreamCnvTestConfig.TgcDigitToTgcRDOCfg
def TgcDigitToTgcRDOCfg(flags, name="TgcDigitToTgcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:216
python.MuonByteStreamCnvTestConfig.CscDigitToCscRDOCfg
def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:255
python.MuonByteStreamCnvTestConfig.MdtRdoDecoderCfg
def MdtRdoDecoderCfg(flags, name="MDT_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:348
python.MuonCablingConfig.RPCLegacyCablingConfigCfg
def RPCLegacyCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:41
python.MuonByteStreamCnvTestConfig.STgcRdoDecoderCfg
def STgcRdoDecoderCfg(flags, name="STGC_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:332
python.MuonBytestreamDecodeConfig.sTgcBytestreamDecodeCfg
def sTgcBytestreamDecodeCfg(flags, name="sTgcRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:245
python.MuonByteStreamCnvTestConfig.MM_RdoToDigitCfg
def MM_RdoToDigitCfg(flags, name="MM_RdoToDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:140
RngCompsConfig.AthRNGSvcCfg
def AthRNGSvcCfg(flags, name="AthRNGSvc")
Definition: RngCompsConfig.py:51
Generated on Sun Apr 27 2025 22:03:01 for ATLAS Offline Software by   doxygen 1.8.18