ATLAS Offline Software
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 257 of file MuonByteStreamCnvTestConfig.py.

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

◆ CscDigitToCscRDOToolCfg()

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

Definition at line 232 of file MuonByteStreamCnvTestConfig.py.

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

◆ 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 350 of file MuonByteStreamCnvTestConfig.py.

350 def MdtRdoDecoderCfg(flags, name="MDT_RDO_Decoder", **kwargs):
351  result = ComponentAccumulator()
352  from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
353  result.merge(MDTCablingConfigCfg(flags))
354  result.setPrivateTools(CompFactory.Muon.MdtRDO_Decoder(name, **kwargs))
355  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 287 of file MuonByteStreamCnvTestConfig.py.

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

◆ 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 342 of file MuonByteStreamCnvTestConfig.py.

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

◆ NrpcDigitToNrpcRDOCfg()

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

Definition at line 198 of file MuonByteStreamCnvTestConfig.py.

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

◆ 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.MuonCondAlgConfig import RpcCondDbAlgCfg
181  acc.merge(RpcCondDbAlgCfg(flags))
182  from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
183  acc.merge(RPCCablingConfigCfg(flags))
184  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
185 
186  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
187  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}RPCPAD")
188  else:
189  kwargs.setdefault("OutputObjectName", "RPCPAD")
190 
191  kwargs.setdefault("NOBXS", flags.Trigger.L1MuonSim.RPCNBX)
192  kwargs.setdefault("BCZERO", flags.Trigger.L1MuonSim.RPCNBCZ)
193 
194  acc.addEventAlgo(CompFactory.RpcDigitToRpcRDO(name, **kwargs))
195  return acc
196 
197 

◆ 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:
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 304 of file MuonByteStreamCnvTestConfig.py.

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

◆ SigRpcDigitToRpcRDOCfg()

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

Definition at line 314 of file MuonByteStreamCnvTestConfig.py.

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

◆ SigTgcDigitToTgcRDOCfg()

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

Definition at line 324 of file MuonByteStreamCnvTestConfig.py.

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

◆ STGC_DigitToRDOCfg()

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

Definition at line 270 of file MuonByteStreamCnvTestConfig.py.

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

◆ 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 334 of file MuonByteStreamCnvTestConfig.py.

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

◆ TgcDigitToTgcRDOCfg()

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

Definition at line 218 of file MuonByteStreamCnvTestConfig.py.

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

◆ 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:287
python.MuonBytestreamDecodeConfig.MmBytestreamDecodeCfg
def MmBytestreamDecodeCfg(flags, name="MmRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:341
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.MuonCondAlgConfig.RpcCondDbAlgCfg
def RpcCondDbAlgCfg(flags, **kwargs)
Definition: MuonCondAlgConfig.py:78
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:342
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:304
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:232
python.MuonGeometryConfig.MuonIdHelperSvcCfg
def MuonIdHelperSvcCfg(flags)
Definition: MuonGeometryConfig.py:15
python.MuonCalibrationConfig.NSWCalibToolCfg
def NSWCalibToolCfg(flags, name="NSWCalibTool", **kwargs)
Definition: MuonCalibrationConfig.py:143
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:270
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:324
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:198
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:314
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:218
python.MuonByteStreamCnvTestConfig.CscDigitToCscRDOCfg
def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:257
python.MuonByteStreamCnvTestConfig.MdtRdoDecoderCfg
def MdtRdoDecoderCfg(flags, name="MDT_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:350
python.MuonCablingConfig.RPCLegacyCablingConfigCfg
def RPCLegacyCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:41
python.MuonByteStreamCnvTestConfig.STgcRdoDecoderCfg
def STgcRdoDecoderCfg(flags, name="STGC_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:334
python.MuonBytestreamDecodeConfig.sTgcBytestreamDecodeCfg
def sTgcBytestreamDecodeCfg(flags, name="sTgcRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:235
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 Dec 22 2024 22:06:42 for ATLAS Offline Software by   doxygen 1.8.18