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

214 def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO", **kwargs):
215  """Return ComponentAccumulator with configured CscDigitToCscRDO algorithm"""
216  # for CSC, configuration is in the tool CscDigitToCscRDOTool
217  acc = ComponentAccumulator()
218  kwargs.setdefault("CscDigitToRDOTool", acc.popToolsAndMerge(CscDigitToCscRDOToolCfg(flags)))
219 
220  if flags.Concurrency.NumThreads > 0:
221  kwargs.setdefault("Cardinality", flags.Concurrency.NumThreads)
222 
223  acc.addEventAlgo(CompFactory.CscDigitToCscRDO(name, **kwargs))
224  return acc
225 
226 

◆ CscDigitToCscRDOToolCfg()

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

Definition at line 189 of file MuonByteStreamCnvTestConfig.py.

189 def CscDigitToCscRDOToolCfg(flags, name="CscDigitToCscRDOTool", **kwargs):
190  """Return ComponentAccumulator with configured CscDigitToCscRDOTool"""
191  acc = ComponentAccumulator()
192  # configure basic parameters
193  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
194  from MuonConfig.MuonCalibrationConfig import CscCalibToolCfg
195  kwargs.setdefault("cscCalibTool", acc.popToolsAndMerge(CscCalibToolCfg(flags)))
196  kwargs.setdefault("NumSamples", 4)
197  kwargs.setdefault("Latency", 0)
198  kwargs.setdefault("addNoise", not flags.Common.isOverlay) # doMuonNoise flag not migrated
199 
200  if flags.Common.isOverlay:
201  kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}CSC_DIGITS")
202  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}CSCRDO")
203  elif flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
204  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}CSCRDO")
205  else:
206  kwargs.setdefault("OutputObjectName", "CSCRDO")
207 
208  from RngComps.RngCompsConfig import AthRNGSvcCfg
209  kwargs.setdefault("RndmSvc", acc.getPrimaryAndMerge(AthRNGSvcCfg(flags)).name)
210  acc.setPrivateTools(CompFactory.CscDigitToCscRDOTool("CscDigitToCscRDOTool", **kwargs))
211  return acc
212 
213 

◆ MdtDigitToMdtRDOCfg()

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

Definition at line 128 of file MuonByteStreamCnvTestConfig.py.

128 def MdtDigitToMdtRDOCfg(flags, name="MdtDigitToMdtRDO", **kwargs):
129  """Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm"""
130  acc = ComponentAccumulator()
131  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
132 
133  from AthenaConfiguration.Enums import LHCPeriod
134  kwargs.setdefault("isPhaseII", flags.GeoModel.Run >= LHCPeriod.Run4)
135  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
136  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}MDTCSM")
137  else:
138  kwargs.setdefault("OutputObjectName", "MDTCSM")
139 
140  acc.addEventAlgo(CompFactory.MdtDigitToMdtRDO(name, **kwargs))
141  return acc
142 
143 

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

306 def MdtRdoDecoderCfg(flags,name= "MDT_RDO_Decoder", **kwargs):
307  result = ComponentAccumulator()
308  from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
309  result.merge(MDTCablingConfigCfg(flags))
310  the_tool = CompFactory.Muon.MdtRDO_Decoder(name, **kwargs)
311  result.setPrivateTools(the_tool)
312  return result
313 
314 

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

244 def MM_DigitToRDOCfg(flags, name="MM_DigitToRDO", **kwargs):
245  """Return ComponentAccumulator with configured MM_DigitToRDO algorithm"""
246  acc = ComponentAccumulator()
247  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
248 
249  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
250  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}MMRDO")
251  else:
252  kwargs.setdefault("OutputObjectName", "MMRDO")
253 
254  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
255  kwargs.setdefault("CalibrationTool", acc.popToolsAndMerge(NSWCalibToolCfg(flags)))
256  the_alg = CompFactory.MM_DigitToRDO(name, **kwargs)
257  acc.addEventAlgo(the_alg)
258  return acc
259 
260 

◆ MM_RdoToDigitCfg()

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

Definition at line 108 of file MuonByteStreamCnvTestConfig.py.

108 def MM_RdoToDigitCfg(flags, name="MM_RdoToDigitAlg", **kwargs):
109  """Return ComponentAccumulator with configured MM_RdoToDigit algorithm"""
110  acc = ComponentAccumulator()
111  if flags.Common.isOverlay:
112  kwargs.setdefault("MmRdoContainer", f"{flags.Overlay.BkgPrefix}MMRDO")
113  kwargs.setdefault("MmDigitContainer", f"{flags.Overlay.BkgPrefix}MM_DIGITS")
114  else:
115  kwargs.setdefault("MmRdoContainer", "MMRDO")
116  kwargs.setdefault("MmDigitContainer", "MM_DIGITS")
117 
118  kwargs.setdefault("mmRdoDecoderTool", acc.popToolsAndMerge(MMRdoDecoderCfg(flags)))
119 
120  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
121  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
122  acc.merge(SGInputLoaderCfg(flags, [f'Muon::MM_RawDataContainer#{kwargs["MmRdoContainer"]}']))
123 
124  acc.addEventAlgo(CompFactory.MM_RdoToDigit(name, **kwargs))
125  return acc
126 
127 

◆ MMRdoDecoderCfg()

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

Definition at line 298 of file MuonByteStreamCnvTestConfig.py.

298 def MMRdoDecoderCfg(flags, name="MM_RDO_Decoder", **kwargs):
299  result = ComponentAccumulator()
300  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
301  kwargs.setdefault("CalibrationTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
302  the_tool = CompFactory.Muon.MM_RDO_Decoder(name, **kwargs)
303  result.setPrivateTools(the_tool)
304  return result
305 

◆ NrpcDigitToNrpcRDOCfg()

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

Definition at line 161 of file MuonByteStreamCnvTestConfig.py.

161 def NrpcDigitToNrpcRDOCfg(flags, name="NrpcDigitToNrpcRDO", **kwargs):
162  """Return ComponentAccumulator with configured NrpcDigitToNrpcRDO algorithm"""
163  acc = ComponentAccumulator()
164  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
165 
166  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
167  kwargs.setdefault("NrpcRdoKey", flags.Overlay.BkgPrefix + "NRPCRDO")
168  else:
169  kwargs.setdefault("NrpcRdoKey", "NRPCRDO")
170 
171  acc.addEventAlgo(CompFactory.NrpcDigitToNrpcRDO(name, **kwargs))
172  return acc
173 
174 

◆ RpcDigitToRpcRDOCfg()

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

Definition at line 144 of file MuonByteStreamCnvTestConfig.py.

144 def RpcDigitToRpcRDOCfg(flags, name="RpcDigitToRpcRDO", **kwargs):
145  """Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm"""
146  acc = ComponentAccumulator()
147  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
148 
149  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
150  kwargs.setdefault("OutputObjectName", flags.Overlay.BkgPrefix + "RPCPAD")
151  else:
152  kwargs.setdefault("OutputObjectName", "RPCPAD")
153 
154  kwargs.setdefault("NOBXS", flags.Trigger.L1MuonSim.RPCNBX)
155  kwargs.setdefault("BCZERO", flags.Trigger.L1MuonSim.RPCNBCZ)
156 
157  acc.addEventAlgo(CompFactory.RpcDigitToRpcRDO(name, **kwargs))
158  return acc
159 
160 

◆ 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  acc = ComponentAccumulator()
42  from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
43  acc.merge(RPCCablingConfigCfg(flags))
44  kwargs.setdefault("DecodeNrpcRDO", flags.Muon.enableNRPC)
45  if flags.Common.isOverlay:
46  kwargs.setdefault("RpcRdoContainer", f"{flags.Overlay.BkgPrefix}RPCPAD")
47  kwargs.setdefault("RpcDigitContainer", f"{flags.Overlay.BkgPrefix}RPC_DIGITS")
48  kwargs.setdefault("NRpcRdoContainer", f"{flags.Overlay.BkgPrefix}NRPCRDO")
49  else:
50  kwargs.setdefault("RpcRdoContainer", "RPCPAD")
51  kwargs.setdefault("RpcDigitContainer", "RPC_DIGITS")
52  kwargs.setdefault("NRpcRdoContainer", "NRPCRDO")
53 
54  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
55  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
56  acc.merge(SGInputLoaderCfg(flags, [f'RpcPadContainer#{kwargs["RpcRdoContainer"]}']))
57 
58 
59  #Set N BCs and central BC consistently with RPC readout settings
60  rpcrdo_decode = CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder", BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
61  kwargs.setdefault("rpcRdoDecoderTool", rpcrdo_decode)
62 
63  acc.addEventAlgo(CompFactory.RpcRdoToRpcDigit(name, **kwargs))
64  return acc
65 
66 

◆ SigMdtDigitToMdtRDOCfg()

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

Definition at line 261 of file MuonByteStreamCnvTestConfig.py.

261 def SigMdtDigitToMdtRDOCfg(flags, name="SigMdtDigitToMdtRDO", **kwargs):
262  """Return ComponentAccumulator with configured MdtDigitToMdtRDO algorithm"""
263  acc = ComponentAccumulator()
264  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
265  kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}MDT_DIGITS")
266  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}MDTCSM")
267  acc.addEventAlgo(CompFactory.MdtDigitToMdtRDO(name, **kwargs))
268  return acc
269 
270 

◆ SigRpcDigitToRpcRDOCfg()

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

Definition at line 271 of file MuonByteStreamCnvTestConfig.py.

271 def SigRpcDigitToRpcRDOCfg(flags, name="SigRpcDigitToRpcRDO", **kwargs):
272  """Return ComponentAccumulator with configured RpcDigitToRpcRDO algorithm"""
273  acc = ComponentAccumulator()
274  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
275  kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}RPC_DIGITS")
276  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}RPCPAD")
277  acc.addEventAlgo(CompFactory.RpcDigitToRpcRDO(name, **kwargs))
278  return acc
279 
280 

◆ SigTgcDigitToTgcRDOCfg()

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

Definition at line 281 of file MuonByteStreamCnvTestConfig.py.

281 def SigTgcDigitToTgcRDOCfg(flags, name="SigTgcDigitToTgcRDO", **kwargs):
282  """Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm"""
283  acc = ComponentAccumulator()
284  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
285  kwargs.setdefault("InputObjectName", f"{flags.Overlay.SigPrefix}TGC_DIGITS")
286  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.SigPrefix}TGCRDO")
287  acc.addEventAlgo(CompFactory.TgcDigitToTgcRDO(name, **kwargs))
288  return acc
289 

◆ STGC_DigitToRDOCfg()

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

Definition at line 227 of file MuonByteStreamCnvTestConfig.py.

227 def STGC_DigitToRDOCfg(flags, name="STGC_DigitToRDO", **kwargs):
228  """Return ComponentAccumulator with configured STGC_DigitToRDO algorithm"""
229  acc = ComponentAccumulator()
230  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
231 
232  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
233  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}sTGCRDO")
234  else:
235  kwargs.setdefault("OutputObjectName", "sTGCRDO")
236 
237  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
238  kwargs.setdefault("CalibrationTool", acc.popToolsAndMerge(NSWCalibToolCfg(flags)))
239  the_alg = CompFactory.STGC_DigitToRDO(name, **kwargs)
240  acc.addEventAlgo(the_alg)
241  return acc
242 
243 

◆ STGC_RdoToDigitCfg()

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

Definition at line 88 of file MuonByteStreamCnvTestConfig.py.

88 def STGC_RdoToDigitCfg(flags, name="STGC_RdoToDigitAlg", **kwargs):
89  """Return ComponentAccumulator with configured STGC_RdoToDigit algorithm"""
90  acc = ComponentAccumulator()
91  if flags.Common.isOverlay:
92  kwargs.setdefault("sTgcRdoContainer", f"{flags.Overlay.BkgPrefix}sTGCRDO")
93  kwargs.setdefault("sTgcDigitContainer", f"{flags.Overlay.BkgPrefix}sTGC_DIGITS")
94  else:
95  kwargs.setdefault("sTgcRdoContainer", "sTGCRDO")
96  kwargs.setdefault("sTgcDigitContainer", "sTGC_DIGITS")
97 
98  kwargs.setdefault("sTgcRdoDecoderTool", acc.popToolsAndMerge(STgcRdoDecoderCfg(flags)))
99 
100  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
101  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
102  acc.merge(SGInputLoaderCfg(flags, [f'Muon::STGC_RawDataContainer#{kwargs["sTgcRdoContainer"]}']))
103 
104  acc.addEventAlgo(CompFactory.STGC_RdoToDigit(name, **kwargs))
105  return acc
106 
107 

◆ STgcRdoDecoderCfg()

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

Definition at line 290 of file MuonByteStreamCnvTestConfig.py.

290 def STgcRdoDecoderCfg(flags, name="STGC_RDO_Decoder", **kwargs):
291  result = ComponentAccumulator()
292  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
293  kwargs.setdefault("CalibrationTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
294  the_tool = CompFactory.Muon.STGC_RDO_Decoder(name, **kwargs)
295  result.setPrivateTools(the_tool)
296  return result
297 

◆ TgcDigitToTgcRDOCfg()

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

Definition at line 175 of file MuonByteStreamCnvTestConfig.py.

175 def TgcDigitToTgcRDOCfg(flags, name="TgcDigitToTgcRDO", **kwargs):
176  """Return ComponentAccumulator with configured TgcDigitToTgcRDO algorithm"""
177  acc = ComponentAccumulator()
178  kwargs.setdefault("MuonIdHelperSvc", acc.getPrimaryAndMerge(MuonIdHelperSvcCfg(flags)).name)
179 
180  if flags.Common.ProductionStep == ProductionStep.PileUpPresampling:
181  kwargs.setdefault("OutputObjectName", f"{flags.Overlay.BkgPrefix}TGCRDO")
182  else:
183  kwargs.setdefault("OutputObjectName", "TGCRDO")
184 
185  acc.addEventAlgo(CompFactory.TgcDigitToTgcRDO(name, **kwargs))
186  return acc
187 
188 

◆ TgcRdoToTgcDigitCfg()

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

Definition at line 67 of file MuonByteStreamCnvTestConfig.py.

67 def TgcRdoToTgcDigitCfg(flags, name="TgcRdoToTgcDigitAlg", **kwargs):
68  """Return ComponentAccumulator with configured TgcRdoToTgcDigit algorithm"""
69  acc = ComponentAccumulator()
70  from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
71  acc.merge(TGCCablingConfigCfg(flags))
72 
73  if flags.Common.isOverlay:
74  kwargs.setdefault("TgcRdoContainer", f"{flags.Overlay.BkgPrefix}TGCRDO")
75  kwargs.setdefault("TgcDigitContainer",f"{flags.Overlay.BkgPrefix}TGC_DIGITS")
76  else:
77  kwargs.setdefault("TgcRdoContainer", "TGCRDO")
78  kwargs.setdefault("TgcDigitContainer", "TGC_DIGITS")
79 
80  if flags.Common.isOverlay and not flags.Overlay.DataOverlay:
81  from SGComps.SGInputLoaderConfig import SGInputLoaderCfg
82  acc.merge(SGInputLoaderCfg(flags, [f'TgcRdoContainer#{kwargs["TgcRdoContainer"]}']))
83 
84  acc.addEventAlgo(CompFactory.TgcRdoToTgcDigit(name, **kwargs))
85  return acc
86 
87 
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
python.MuonByteStreamCnvTestConfig.MM_DigitToRDOCfg
def MM_DigitToRDOCfg(flags, name="MM_DigitToRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:244
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:74
python.MuonByteStreamCnvTestConfig.RpcDigitToRpcRDOCfg
def RpcDigitToRpcRDOCfg(flags, name="RpcDigitToRpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:144
python.MuonByteStreamCnvTestConfig.MMRdoDecoderCfg
def MMRdoDecoderCfg(flags, name="MM_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:298
python.MuonCablingConfig.MDTCablingConfigCfg
def MDTCablingConfigCfg(flags, name="MuonMDT_CablingAlg", **kwargs)
Definition: MuonCablingConfig.py:91
python.MuonByteStreamCnvTestConfig.SigMdtDigitToMdtRDOCfg
def SigMdtDigitToMdtRDOCfg(flags, name="SigMdtDigitToMdtRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:261
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:189
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:227
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:281
python.MuonByteStreamCnvTestConfig.TgcRdoToTgcDigitCfg
def TgcRdoToTgcDigitCfg(flags, name="TgcRdoToTgcDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:67
python.MuonByteStreamCnvTestConfig.STGC_RdoToDigitCfg
def STGC_RdoToDigitCfg(flags, name="STGC_RdoToDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:88
python.MuonByteStreamCnvTestConfig.NrpcDigitToNrpcRDOCfg
def NrpcDigitToNrpcRDOCfg(flags, name="NrpcDigitToNrpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:161
python.MuonByteStreamCnvTestConfig.SigRpcDigitToRpcRDOCfg
def SigRpcDigitToRpcRDOCfg(flags, name="SigRpcDigitToRpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:271
python.MuonByteStreamCnvTestConfig.MdtDigitToMdtRDOCfg
def MdtDigitToMdtRDOCfg(flags, name="MdtDigitToMdtRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:128
python.MuonCablingConfig.RPCCablingConfigCfg
def RPCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:26
python.MuonByteStreamCnvTestConfig.TgcDigitToTgcRDOCfg
def TgcDigitToTgcRDOCfg(flags, name="TgcDigitToTgcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:175
python.MuonByteStreamCnvTestConfig.CscDigitToCscRDOCfg
def CscDigitToCscRDOCfg(flags, name="CscDigitToCscRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:214
python.MuonByteStreamCnvTestConfig.MdtRdoDecoderCfg
def MdtRdoDecoderCfg(flags, name="MDT_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:306
python.MuonByteStreamCnvTestConfig.STgcRdoDecoderCfg
def STgcRdoDecoderCfg(flags, name="STGC_RDO_Decoder", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:290
python.MuonByteStreamCnvTestConfig.MM_RdoToDigitCfg
def MM_RdoToDigitCfg(flags, name="MM_RdoToDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:108
RngCompsConfig.AthRNGSvcCfg
def AthRNGSvcCfg(flags, name="AthRNGSvc")
Definition: RngCompsConfig.py:51
Generated on Thu Jul 4 2024 22:25:06 for ATLAS Offline Software by   doxygen 1.8.18