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

236 def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO", **kwargs):
237  """Return ComponentAccumulator with configured CscDigitToCscRDO algorithm"""
238  # for CSC, configuration is in the tool CscDigitToCscRDOTool
239  acc = ComponentAccumulator()
240  kwargs.setdefault("CscDigitToRDOTool", acc.popToolsAndMerge(CscDigitToCscRDOToolCfg(flags)))
241 
242  if flags.Concurrency.NumThreads > 0:
243  kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
244 
245  acc.addEventAlgo(CompFactory.CscDigitToCscRDO(name, **kwargs))
246  return acc
247 
248 

◆ CscDigitToCscRDOToolCfg()

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

Definition at line 211 of file MuonByteStreamCnvTestConfig.py.

211 def CscDigitToCscRDOToolCfg(flags, name="CscDigitToCscRDOTool", **kwargs):
212  """Return ComponentAccumulator with configured CscDigitToCscRDOTool"""
213  acc = ComponentAccumulator()
214  # configure basic parameters
215  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
216  from MuonConfig.MuonCalibrationConfig import CscCalibToolCfg
217  kwargs.setdefault("cscCalibTool", acc.popToolsAndMerge(CscCalibToolCfg(flags)))
218  kwargs.setdefault("NumSamples", 4)
219  kwargs.setdefault("Latency", 0)
220  kwargs.setdefault("addNoise", not flags.Common.isOverlay) # doMuonNoise flag not migrated
221 
222  if flags.Common.isOverlay:
223  kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}CSC_DIGITS")
224  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}CSCRDO")
225  elif flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
226  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}CSCRDO")
227  else:
228  kwargs.setdefault("OutputObjectName", "CSCRDO")
229 
230  from RngComps.RngCompsConfig import AthRNGSvcCfg
231  kwargs.setdefault("RndmSvc", acc.getPrimaryAndMerge(AthRNGSvcCfg(flags)).name)
232  acc.setPrivateTools(CompFactory.CscDigitToCscRDOTool("CscDigitToCscRDOTool", **kwargs))
233  return acc
234 
235 

◆ MdtDigitToMdtRDOCfg()

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

Definition at line 143 of file MuonByteStreamCnvTestConfig.py.

143 def MdtDigitToMdtRDOCfg(flags, name="MdtDigitToMdtRDO", **kwargs):
144  """Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm"""
145  acc = ComponentAccumulator()
146  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
147  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
148  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}MDTCSM")
149  else:
150  kwargs.setdefault("OutputObjectName", "MDTCSM")
151 
152  acc.addEventAlgo(CompFactory.MdtDigitToMdtRDO(name, **kwargs))
153  return acc
154 
155 

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

328 def MdtRdoDecoderCfg(flags,name= "MDT_RDO_Decoder", **kwargs):
329  result = ComponentAccumulator()
330  from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
331  result.merge(MDTCablingConfigCfg(flags))
332  the_tool = CompFactory.Muon.MdtRDO_Decoder(name, **kwargs)
333  result.setPrivateTools(the_tool)
334  return result
335 
336 

◆ 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  kwargs.setdefault("mdtRdoDecoderTool", acc.popToolsAndMerge(MdtRDO_DecoderCfg(flags)))
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  else:
28  kwargs.setdefault("MdtRdoContainer", "MDTCSM")
29  kwargs.setdefault("MdtDigitContainer", "MDT_DIGITS")
30 
31  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
32  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
33  acc.merge(SGInputLoaderCfg(flags, [f'MdtCsmContainer#{kwargs["MdtRdoContainer"]}']))
34 
35  acc.addEventAlgo(CompFactory.MdtRdoToMdtDigit(name, **kwargs))
36  return acc
37 
38 

◆ MM_DigitToRDOCfg()

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

Definition at line 266 of file MuonByteStreamCnvTestConfig.py.

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

◆ MM_RdoToDigitCfg()

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

Definition at line 123 of file MuonByteStreamCnvTestConfig.py.

123 def MM_RdoToDigitCfg(flags, name="MM_RdoToDigitAlg", **kwargs):
124  """Return ComponentAccumulator with configured MM_RdoToDigit algorithm"""
125  acc = ComponentAccumulator()
126  if flags.Common.isOverlay:
127  kwargs.setdefault("MmRdoContainer", f"{flags.Overlay.BkgPrefix}MMRDO")
128  kwargs.setdefault("MmDigitContainer", f"{flags.Overlay.BkgPrefix}MM_DIGITS")
129  else:
130  kwargs.setdefault("MmRdoContainer", "MMRDO")
131  kwargs.setdefault("MmDigitContainer", "MM_DIGITS")
132 
133  kwargs.setdefault("mmRdoDecoderTool", acc.popToolsAndMerge(MMRdoDecoderCfg(flags)))
134 
135  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
136  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
137  acc.merge(SGInputLoaderCfg(flags, [f'Muon::MM_RawDataContainer#{kwargs["MmRdoContainer"]}']))
138 
139  acc.addEventAlgo(CompFactory.MM_RdoToDigit(name, **kwargs))
140  return acc
141 
142 

◆ MMRdoDecoderCfg()

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

Definition at line 320 of file MuonByteStreamCnvTestConfig.py.

320 def MMRdoDecoderCfg(flags, name="MM_RDO_Decoder", **kwargs):
321  result = ComponentAccumulator()
322  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
323  kwargs.setdefault("CalibrationTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
324  the_tool = CompFactory.Muon.MM_RDO_Decoder(name, **kwargs)
325  result.setPrivateTools(the_tool)
326  return result
327 

◆ NrpcDigitToNrpcRDOCfg()

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

Definition at line 177 of file MuonByteStreamCnvTestConfig.py.

177 def NrpcDigitToNrpcRDOCfg(flags, name="NrpcDigitToNrpcRDO", **kwargs):
178  """Return ComponentAccumulator with configured NrpcDigitToNrpcRDO algorithm"""
179  acc = ComponentAccumulator()
180  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
181 
182  from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
183  acc.merge(NRPCCablingConfigCfg(flags))
184 
185  if flags.Muon.usePhaseIIGeoSetup:
186  kwargs.setdefault("ConvertHitsFromStations", [])
187 
188  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
189  kwargs.setdefault("NrpcRdoKey", flags.Overlay.BkgPrefix + "NRPCRDO")
190  else:
191  kwargs.setdefault("NrpcRdoKey", "NRPCRDO")
192 
193  acc.addEventAlgo(CompFactory.NrpcDigitToNrpcRDO(name, **kwargs))
194  return acc
195 
196 

◆ RpcDigitToRpcRDOCfg()

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

Definition at line 156 of file MuonByteStreamCnvTestConfig.py.

156 def RpcDigitToRpcRDOCfg(flags, name="RpcDigitToRpcRDO", **kwargs):
157  """Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm"""
158  acc = ComponentAccumulator()
159  from MuonConfig.MuonCondAlgConfig import RpcCondDbAlgCfg
160  acc.merge(RpcCondDbAlgCfg(flags))
161  from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
162  acc.merge(RPCCablingConfigCfg(flags))
163  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
164 
165  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
166  kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "RPCPAD")
167  else:
168  kwargs.setdefault("OutputObjectName", "RPCPAD")
169 
170  kwargs.setdefault("NOBXS", flags.Trigger.L1MuonSim.RPCNBX)
171  kwargs.setdefault("BCZERO", flags.Trigger.L1MuonSim.RPCNBCZ)
172 
173  acc.addEventAlgo(CompFactory.RpcDigitToRpcRDO(name, **kwargs))
174  return acc
175 
176 

◆ RpcRdoToRpcDigitCfg()

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

Definition at line 39 of file MuonByteStreamCnvTestConfig.py.

39 def RpcRdoToRpcDigitCfg(flags, name="RpcRdoToRpcDigitAlg", **kwargs):
40  """Return ComponentAccumulator with configured RpcRdoToRpcDigit algorithm"""
41  result = ComponentAccumulator()
42 
43  if flags.Common.isOverlay:
44  kwargs.setdefault("RpcRdoContainer", f"{flags.Overlay.BkgPrefix}RPCPAD")
45  kwargs.setdefault("RpcDigitContainer", f"{flags.Overlay.BkgPrefix}RPC_DIGITS")
46  kwargs.setdefault("NRpcRdoContainer", f"{flags.Overlay.BkgPrefix}NRPCRDO")
47  else:
48  kwargs.setdefault("RpcRdoContainer", "RPCPAD")
49  kwargs.setdefault("RpcDigitContainer", "RPC_DIGITS")
50  kwargs.setdefault("NRpcRdoContainer", "NRPCRDO")
51 
52  container = [x for x in flags.Input.TypedCollections \
53  if x == "RpcPadContainer#{cont_name}".format(cont_name=kwargs["RpcRdoContainer"]) or \
54  x == "xAOD::NRPCRDOContainer#{cont_name}".format(cont_name=kwargs["NRpcRdoContainer"]) or \
55  x == "xAOD::NRPCRDOAuxContainer#{cont_name}Aux.".format(cont_name=kwargs["NRpcRdoContainer"]) ]
56 
57 
58 
60  kwargs.setdefault("DecodeNrpcRDO", len(container) > 1 )
61 
62  kwargs.setdefault("DecodeLegacyRDO", len(container) % 2 or \
63  not flags.Input.isMC)
64  if kwargs["DecodeNrpcRDO"]:
65  from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
66  result.merge(NRPCCablingConfigCfg(flags))
67  if kwargs["DecodeLegacyRDO"]:
68  from MuonConfig.MuonCablingConfig import RPCLegacyCablingConfigCfg
69  result.merge(RPCLegacyCablingConfigCfg(flags))
70  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
71  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
72  result.merge(SGInputLoaderCfg(flags, container))
73 
74  #Set N BCs and central BC consistently with RPC readout settings
75  rpcrdo_decode = CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder", BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
76  kwargs.setdefault("rpcRdoDecoderTool", rpcrdo_decode)
77 
78  result.addEventAlgo(CompFactory.RpcRdoToRpcDigit(name, **kwargs))
79  return result
80 
81 

◆ SigMdtDigitToMdtRDOCfg()

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

Definition at line 283 of file MuonByteStreamCnvTestConfig.py.

283 def SigMdtDigitToMdtRDOCfg(flags, name="SigMdtDigitToMdtRDO", **kwargs):
284  """Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm"""
285  acc = ComponentAccumulator()
286  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
287  kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}MDT_DIGITS")
288  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}MDTCSM")
289  acc.addEventAlgo(CompFactory.MdtDigitToMdtRDO(name, **kwargs))
290  return acc
291 
292 

◆ SigRpcDigitToRpcRDOCfg()

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

Definition at line 293 of file MuonByteStreamCnvTestConfig.py.

293 def SigRpcDigitToRpcRDOCfg(flags, name="SigRpcDigitToRpcRDO", **kwargs):
294  """Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm"""
295  acc = ComponentAccumulator()
296  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
297  kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}RPC_DIGITS")
298  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}RPCPAD")
299  acc.addEventAlgo(CompFactory.RpcDigitToRpcRDO(name, **kwargs))
300  return acc
301 
302 

◆ SigTgcDigitToTgcRDOCfg()

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

Definition at line 303 of file MuonByteStreamCnvTestConfig.py.

303 def SigTgcDigitToTgcRDOCfg(flags, name="SigTgcDigitToTgcRDO", **kwargs):
304  """Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm"""
305  acc = ComponentAccumulator()
306  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
307  kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}TGC_DIGITS")
308  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}TGCRDO")
309  acc.addEventAlgo(CompFactory.TgcDigitToTgcRDO(name, **kwargs))
310  return acc
311 

◆ STGC_DigitToRDOCfg()

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

Definition at line 249 of file MuonByteStreamCnvTestConfig.py.

249 def STGC_DigitToRDOCfg(flags, name="STGC_DigitToRDO", **kwargs):
250  """Return ComponentAccumulator with configured STGC_DigitToRDO algorithm"""
251  acc = ComponentAccumulator()
252  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
253 
254  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
255  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}sTGCRDO")
256  else:
257  kwargs.setdefault("OutputObjectName", "sTGCRDO")
258 
259  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
260  kwargs.setdefault("CalibrationTool", acc.popToolsAndMerge(NSWCalibToolCfg(flags)))
261  the_alg = CompFactory.STGC_DigitToRDO(name, **kwargs)
262  acc.addEventAlgo(the_alg)
263  return acc
264 
265 

◆ STGC_RdoToDigitCfg()

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

Definition at line 103 of file MuonByteStreamCnvTestConfig.py.

103 def STGC_RdoToDigitCfg(flags, name="STGC_RdoToDigitAlg", **kwargs):
104  """Return ComponentAccumulator with configured STGC_RdoToDigit algorithm"""
105  acc = ComponentAccumulator()
106  if flags.Common.isOverlay:
107  kwargs.setdefault("sTgcRdoContainer", f"{flags.Overlay.BkgPrefix}sTGCRDO")
108  kwargs.setdefault("sTgcDigitContainer",f"{flags.Overlay.BkgPrefix}sTGC_DIGITS")
109  else:
110  kwargs.setdefault("sTgcRdoContainer", "sTGCRDO")
111  kwargs.setdefault("sTgcDigitContainer", "sTGC_DIGITS")
112 
113  kwargs.setdefault("sTgcRdoDecoderTool", acc.popToolsAndMerge(STgcRdoDecoderCfg(flags)))
114 
115  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
116  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
117  acc.merge(SGInputLoaderCfg(flags, [f'Muon::STGC_RawDataContainer#{kwargs["sTgcRdoContainer"]}']))
118 
119  acc.addEventAlgo(CompFactory.STGC_RdoToDigit(name, **kwargs))
120  return acc
121 
122 

◆ STgcRdoDecoderCfg()

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

Definition at line 312 of file MuonByteStreamCnvTestConfig.py.

312 def STgcRdoDecoderCfg(flags, name="STGC_RDO_Decoder", **kwargs):
313  result = ComponentAccumulator()
314  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
315  kwargs.setdefault("CalibrationTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
316  the_tool = CompFactory.Muon.STGC_RDO_Decoder(name, **kwargs)
317  result.setPrivateTools(the_tool)
318  return result
319 

◆ TgcDigitToTgcRDOCfg()

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

Definition at line 197 of file MuonByteStreamCnvTestConfig.py.

197 def TgcDigitToTgcRDOCfg(flags, name="TgcDigitToTgcRDO", **kwargs):
198  """Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm"""
199  acc = ComponentAccumulator()
200  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)))
201 
202  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
203  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}TGCRDO")
204  else:
205  kwargs.setdefault("OutputObjectName", "TGCRDO")
206 
207  acc.addEventAlgo(CompFactory.TgcDigitToTgcRDO(name, **kwargs))
208  return acc
209 
210 

◆ TgcRdoToTgcDigitCfg()

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

Definition at line 82 of file MuonByteStreamCnvTestConfig.py.

82 def TgcRdoToTgcDigitCfg(flags, name="TgcRdoToTgcDigitAlg", **kwargs):
83  """Return ComponentAccumulator with configured TgcRdoToTgcDigit algorithm"""
84  acc = ComponentAccumulator()
85  from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
86  acc.merge(TGCCablingConfigCfg(flags))
87 
88  if flags.Common.isOverlay:
89  kwargs.setdefault("TgcRdoContainer", f"{flags.Overlay.BkgPrefix}TGCRDO")
90  kwargs.setdefault("TgcDigitContainer",f"{flags.Overlay.BkgPrefix}TGC_DIGITS")
91  else:
92  kwargs.setdefault("TgcRdoContainer", "TGCRDO")
93  kwargs.setdefault("TgcDigitContainer", "TGC_DIGITS")
94 
95  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
96  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
97  acc.merge(SGInputLoaderCfg(flags, [f'TgcRdoContainer#{kwargs["TgcRdoContainer"]}']))
98 
99  acc.addEventAlgo(CompFactory.TgcRdoToTgcDigit(name, **kwargs))
100  return acc
101 
102 
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:266
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:156
python.MuonByteStreamCnvTestConfig.MMRdoDecoderCfg
def MMRdoDecoderCfg(flags, name="MM_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:320
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:283
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:211
python.MuonGeometryConfig.MuonIdHelperSvcCfg
def MuonIdHelperSvcCfg(flags)
Definition: MuonGeometryConfig.py:15
python.MuonCalibrationConfig.NSWCalibToolCfg
def NSWCalibToolCfg(flags, name="NSWCalibTool", **kwargs)
Definition: MuonCalibrationConfig.py:142
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:249
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:39
python.MuonByteStreamCnvTestConfig.SigTgcDigitToTgcRDOCfg
def SigTgcDigitToTgcRDOCfg(flags, name="SigTgcDigitToTgcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:303
python.MuonByteStreamCnvTestConfig.TgcRdoToTgcDigitCfg
def TgcRdoToTgcDigitCfg(flags, name="TgcRdoToTgcDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:82
python.MuonByteStreamCnvTestConfig.STGC_RdoToDigitCfg
def STGC_RdoToDigitCfg(flags, name="STGC_RdoToDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:103
python.MuonByteStreamCnvTestConfig.NrpcDigitToNrpcRDOCfg
def NrpcDigitToNrpcRDOCfg(flags, name="NrpcDigitToNrpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:177
python.MuonByteStreamCnvTestConfig.SigRpcDigitToRpcRDOCfg
def SigRpcDigitToRpcRDOCfg(flags, name="SigRpcDigitToRpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:293
python.MuonByteStreamCnvTestConfig.MdtDigitToMdtRDOCfg
def MdtDigitToMdtRDOCfg(flags, name="MdtDigitToMdtRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:143
python.MuonCablingConfig.RPCCablingConfigCfg
def RPCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:33
python.MuonByteStreamCnvTestConfig.TgcDigitToTgcRDOCfg
def TgcDigitToTgcRDOCfg(flags, name="TgcDigitToTgcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:197
python.MuonByteStreamCnvTestConfig.CscDigitToCscRDOCfg
def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:236
python.MuonByteStreamCnvTestConfig.MdtRdoDecoderCfg
def MdtRdoDecoderCfg(flags, name="MDT_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:328
python.MuonCablingConfig.RPCLegacyCablingConfigCfg
def RPCLegacyCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:41
python.MuonByteStreamCnvTestConfig.STgcRdoDecoderCfg
def STgcRdoDecoderCfg(flags, name="STGC_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:312
python.MuonByteStreamCnvTestConfig.MM_RdoToDigitCfg
def MM_RdoToDigitCfg(flags, name="MM_RdoToDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:123
RngCompsConfig.AthRNGSvcCfg
def AthRNGSvcCfg(flags, name="AthRNGSvc")
Definition: RngCompsConfig.py:51
Generated on Thu Nov 7 2024 22:23:41 for ATLAS Offline Software by   doxygen 1.8.18