ATLAS Offline Software
Classes | Functions | Variables
python.MuonBytestreamDecodeConfig Namespace Reference

Classes

class  MuonCacheNames
 Small class to hold the names for cache containers, should help to avoid copy / paste errors. More...
 

Functions

def MuonCacheCfg (flags)
 This configuration function creates the IdentifiableCaches for RDO. More...
 
def RpcBytestreamDecodeCfg (flags, name="RpcRawDataProvider", **kwargs)
 This configuration function sets up everything for decoding RPC bytestream data into RDOs. More...
 
def NrpcBytestreamDecodeCfg (flags, name="NrpcRawDataProvider", **kwargs)
 
def TgcBytestreamDecodeCfg (flags, name="TgcRawDataProvider", **kwargs)
 
def MdtBytestreamDecodeCfg (flags, name="MdtRawDataProvider", **kwargs)
 
def CscBytestreamDecodeCfg (flags, name="CscRawDataProvider", **kwargs)
 
def sTgcRODDecoderCfg (flags, name="sTgcROD_Decoder", **kwargs)
 
def sTgcBytestreamDecodeCfg (flags, name="sTgcRawDataProvider", **kwargs)
 
def NswTrigProcessorRodDecoderCfg (flags, name="NswTrigProcessorDecoder", **kwargs)
 
def NswTrigProcessorRawDataProviderToolCfg (flags, name="NswTrigProcessorRawDataTool", **kwargs)
 
def NswTrigProcByteStreamDecodeCfg (flags, name="NswProcByteStream")
 
def sTgcPadTriggerBytestreamDecodeCfg (flags, name="sTgcPadTriggerRawDataProvider", **kwargs)
 
def MmRDODDecoderCfg (flags, name="MmROD_Decoder", **kwargs)
 
def MmBytestreamDecodeCfg (flags, name="MmRawDataProvider", **kwargs)
 
def NswMMTPRodDecoderCfg (flags, name="NswMMTPRodDecoder", **kwargs)
 
def NswMMTPRawDataProviderToolCfg (flags, name="NswMMTPRawDataProviderTool", **kwargs)
 
def NswMMTPByteStreamDecodeCfg (flags, name="NswMMTPByteStreamDecode", **kwargs)
 
def MuonByteStreamDecodersCfg (flags)
 

Variables

 flags = initConfigFlags()
 
 Files
 
 GlobalTag
 
 AtlasVersion
 
 NumThreads
 
 MaxEvents
 
 args = flags.fillFromArgs()
 
 cfg = MainServicesCfg(flags)
 
 withDetails
 

Function Documentation

◆ CscBytestreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.CscBytestreamDecodeCfg (   flags,
  name = "CscRawDataProvider",
**  kwargs 
)

Definition at line 182 of file MuonBytestreamDecodeConfig.py.

182 def CscBytestreamDecodeCfg(flags, name="CscRawDataProvider", **kwargs):
183  acc = ComponentAccumulator()
184 
185  # We need the CSC cabling to be setup
186  from MuonConfig.MuonCablingConfig import CSCCablingConfigCfg # Not yet been prepared
187  acc.merge( CSCCablingConfigCfg(flags) )
188 
189  # Make sure muon geometry is configured
190  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
191  acc.merge(MuonGeoModelCfg(flags))
192 
193  # Setup the CSC ROD decoder
194  Muon__CscROD_Decoder=CompFactory.Muon.CscROD_Decoder
195  CSCRodDecoder = Muon__CscROD_Decoder(name = "CscROD_Decoder" )
196 
197 
198  # Setup the RAW data provider tool
199  keyName = flags.Overlay.BkgPrefix + "CSCRDO" if flags.Common.isOverlay else "CSCRDO"
200  Muon__CSC_RawDataProviderToolMT=CompFactory.Muon.CSC_RawDataProviderToolMT
201  MuonCscRawDataProviderTool = Muon__CSC_RawDataProviderToolMT(name = "CSC_RawDataProviderToolMT",
202  Decoder = CSCRodDecoder,
203  RdoLocation = keyName)
204  if flags.Muon.MuonTrigger:
205  MuonCscRawDataProviderTool.CscContainerCacheKey = MuonCacheNames.CscCache
206 
207  # Setup the RAW data provider algorithm
208  Muon__CscRawDataProvider=CompFactory.Muon.CscRawDataProvider
209  CscRawDataProvider = Muon__CscRawDataProvider(name = name,
210  ProviderTool = MuonCscRawDataProviderTool, **kwargs )
211  if flags.Muon.MuonTrigger:
212  # add RegSelTool
213  from RegionSelector.RegSelToolConfig import regSelTool_CSC_Cfg
214  CscRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_CSC_Cfg( flags ) )
215 
216 
217  acc.addEventAlgo(CscRawDataProvider,primary=True)
218 
219  return acc
220 
221 

◆ MdtBytestreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.MdtBytestreamDecodeCfg (   flags,
  name = "MdtRawDataProvider",
**  kwargs 
)

Definition at line 138 of file MuonBytestreamDecodeConfig.py.

138 def MdtBytestreamDecodeCfg(flags, name="MdtRawDataProvider", **kwargs):
139  acc = ComponentAccumulator()
140 
141  # We need the MDT cabling to be setup
142  from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
143  acc.merge( MDTCablingConfigCfg(flags) )
144 
145  # need the MagFieldSvc since MdtRdoToMdtPrepData.MdtRdoToMdtPrepDataTool.MdtCalibrationTool wants to retrieve it
146  from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
147  acc.merge( AtlasFieldCacheCondAlgCfg(flags) )
148 
149  # Make sure muon geometry is configured
150  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
151  acc.merge(MuonGeoModelCfg(flags))
152 
153  # Setup the MDT ROD decoder
154  MdtROD_Decoder=CompFactory.MdtROD_Decoder
155  MDTRodDecoder = MdtROD_Decoder(name="MdtROD_Decoder")
156 
157 
158  # Setup the RAW data provider tool
159  keyName = flags.Overlay.BkgPrefix + "MDTCSM" if flags.Common.isOverlay else "MDTCSM"
160  Muon__MDT_RawDataProviderToolMT=CompFactory.Muon.MDT_RawDataProviderToolMT
161  MuonMdtRawDataProviderTool = Muon__MDT_RawDataProviderToolMT(name = "MDT_RawDataProviderToolMT",
162  Decoder = MDTRodDecoder,
163  RdoLocation = keyName)
164 
165  if flags.Muon.MuonTrigger:
166  MuonMdtRawDataProviderTool.CsmContainerCacheKey = MuonCacheNames.MdtCsmCache
167 
168  # Setup the RAW data provider algorithm
169  Muon__MdtRawDataProvider=CompFactory.Muon.MdtRawDataProvider
170  MdtRawDataProvider = Muon__MdtRawDataProvider(name = name,
171  ProviderTool = MuonMdtRawDataProviderTool, **kwargs )
172  if flags.Muon.MuonTrigger:
173  # add RegSelTool
174  from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
175  MdtRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_MDT_Cfg( flags ) )
176 
177 
178  acc.addEventAlgo(MdtRawDataProvider,primary=True)
179 
180  return acc
181 

◆ MmBytestreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.MmBytestreamDecodeCfg (   flags,
  name = "MmRawDataProvider",
**  kwargs 
)

Definition at line 341 of file MuonBytestreamDecodeConfig.py.

341 def MmBytestreamDecodeCfg(flags, name="MmRawDataProvider", **kwargs):
342  acc = ComponentAccumulator()
343 
344  # We need the MM cabling to be setup
345  #from MuonConfig.MuonCablingConfig import MM_CablingConfigCfg
346  #acc.merge( MM_CablingConfigCfg(flags) )
347 
348  # Make sure muon geometry is configured
349  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
350  acc.merge(MuonGeoModelCfg(flags))
351 
352  # Setup the RAW data provider tool
353  keyName = flags.Overlay.BkgPrefix + "MMRDO" if flags.Common.isOverlay else "MMRDO"
354  MuonMmRawDataProviderTool = CompFactory.Muon.MM_RawDataProviderToolMT(name = "MM_RawDataProviderToolMT",
355  Decoder = acc.popToolsAndMerge(MmRDODDecoderCfg(flags)),
356  RdoLocation = keyName,
357  SkipDecoding=flags.Muon.MuonTrigger and flags.Muon.runCommissioningChain)
358 
359  #if flags.Muon.MuonTrigger:
360  # MuonMmRawDataProviderTool.RawDataContainerCacheKey = MuonCacheNames.MicromegasCache
361 
362  # Setup the RAW data provider algorithm
363  Muon__MmRawDataProvider = CompFactory.Muon.MM_RawDataProvider
364  MmRawDataProvider = Muon__MmRawDataProvider(name = name, ProviderTool = MuonMmRawDataProviderTool, **kwargs )
365  if flags.Muon.MuonTrigger:
366  # add RegSelTool
367  from RegionSelector.RegSelToolConfig import regSelTool_MM_Cfg
368  MmRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_MM_Cfg( flags ) )
369 
370  acc.addEventAlgo(MmRawDataProvider,primary=True)
371 
372  return acc
373 

◆ MmRDODDecoderCfg()

def python.MuonBytestreamDecodeConfig.MmRDODDecoderCfg (   flags,
  name = "MmROD_Decoder",
**  kwargs 
)

Definition at line 325 of file MuonBytestreamDecodeConfig.py.

325 def MmRDODDecoderCfg(flags, name="MmROD_Decoder", **kwargs):
326  result = ComponentAccumulator()
327 
328  if not flags.Muon.MuonTrigger and not flags.Input.isMC:
329  from MuonConfig.MuonCondAlgConfig import NswDcsDbAlgCfg
330  if False: result.merge(NswDcsDbAlgCfg(flags))
331  from MuonConfig.MuonCablingConfig import NswCablingCfg
332  result.merge(NswCablingCfg(flags))
333  else:
334  kwargs.setdefault("CablingMap", "")
335 
336  kwargs.setdefault("DcsKey", "")
337 
338  the_tool = CompFactory.Muon.MM_ROD_Decoder(name = name, **kwargs)
339  result.setPrivateTools(the_tool)
340  return result

◆ MuonByteStreamDecodersCfg()

def python.MuonBytestreamDecodeConfig.MuonByteStreamDecodersCfg (   flags)

Definition at line 400 of file MuonBytestreamDecodeConfig.py.

400 def MuonByteStreamDecodersCfg(flags):
401  cfg=ComponentAccumulator()
402 
403  # Adds all services needed to read BS
404  from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
405  cfg.merge(ByteStreamReadCfg(flags ))
406 
407  # Schedule Rpc data decoding
408  if flags.Detector.EnableRPC:
409  cfg.merge(RpcBytestreamDecodeCfg(flags))
410 
411  if flags.Muon.enableNRPC:
412  # Schedule Nrpc data decoding
413  cfg.merge(NrpcBytestreamDecodeCfg(flags))
414 
415  # Schedule Tgc data decoding
416  if flags.Detector.EnableTGC:
417  cfg.merge(TgcBytestreamDecodeCfg(flags))
418 
419  # Schedule Mdt data decoding
420  if flags.Detector.EnableMDT:
421  cfg.merge(MdtBytestreamDecodeCfg(flags))
422 
423  # Schedule Csc data decoding
424  if flags.Detector.GeometryCSC:
425  cfg.merge(CscBytestreamDecodeCfg(flags))
426 
427  if flags.Detector.GeometryMM:
428  # Schedule MM and MMTP data decoding
429  cfg.merge( MmBytestreamDecodeCfg( flags ) )
430  cfg.merge( NswMMTPByteStreamDecodeCfg(flags) )
431 
432  # Schedule sTGC data decoding
433  if flags.Detector.GeometrysTGC:
434  cfg.merge(sTgcBytestreamDecodeCfg(flags))
435  # Schedule sTGC Pad Trigger data decoding
436  cfg.merge( sTgcPadTriggerBytestreamDecodeCfg(flags))
437 
438  if flags.Detector.GeometrysTGC and flags.Detector.GeometryMM:
439  cfg.merge(NswTrigProcByteStreamDecodeCfg(flags))
440 
441  return cfg
442 
443 

◆ MuonCacheCfg()

def python.MuonBytestreamDecodeConfig.MuonCacheCfg (   flags)

This configuration function creates the IdentifiableCaches for RDO.

The function returns a ComponentAccumulator which should be loaded first If a configuration wants to use the cache, they need to use the same names as defined here

Definition at line 17 of file MuonBytestreamDecodeConfig.py.

17 def MuonCacheCfg(flags):
18 
19 
20  acc = ComponentAccumulator()
21 
22  MuonCacheCreator=CompFactory.MuonCacheCreator
23  cacheCreator = MuonCacheCreator(MdtCsmCacheKey = MuonCacheNames.MdtCsmCache,
24  CscCacheKey = (MuonCacheNames.CscCache if flags.Detector.GeometryCSC else ""),
25  RpcCacheKey = MuonCacheNames.RpcCache,
26  TgcCacheKey = MuonCacheNames.TgcCache)
27 
28  acc.addEventAlgo( cacheCreator, primary=True )
29  return acc
30 

◆ NrpcBytestreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.NrpcBytestreamDecodeCfg (   flags,
  name = "NrpcRawDataProvider",
**  kwargs 
)

Definition at line 73 of file MuonBytestreamDecodeConfig.py.

73 def NrpcBytestreamDecodeCfg(flags, name="NrpcRawDataProvider", **kwargs):
74  acc = ComponentAccumulator()
75 
76  # We need the NRPC cabling to be setup
77  from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
78  acc.merge( NRPCCablingConfigCfg(flags) )
79 
80  # Make sure muon geometry is configured
81  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
82  acc.merge(MuonGeoModelCfg(flags))
83 
84 
85  # Setup the RAW data provider tool
86  keyName = flags.Overlay.BkgPrefix + "NRPCRDO" if flags.Common.isOverlay else "NRPCRDO"
87  MuonNrpcRawDataProviderTool = CompFactory.Muon.NRPC_RawDataProviderTool(name = "NRPC_RawDataProviderTool",
88  NrpcRdoKey = keyName )
89 
90  # Setup the RAW data provider algorithm
91  NrpcRawDataProvider = CompFactory.Muon.NrpcRawDataProvider(name = name,
92  ProviderTool = MuonNrpcRawDataProviderTool, **kwargs )
93 
94  acc.addEventAlgo(NrpcRawDataProvider, primary=True)
95  return acc
96 

◆ NswMMTPByteStreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.NswMMTPByteStreamDecodeCfg (   flags,
  name = "NswMMTPByteStreamDecode",
**  kwargs 
)

Definition at line 388 of file MuonBytestreamDecodeConfig.py.

388 def NswMMTPByteStreamDecodeCfg(flags, name = "NswMMTPByteStreamDecode", **kwargs ):
389  result = ComponentAccumulator()
390  # Make sure muon geometry is configured
391  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
392  result.merge(MuonGeoModelCfg(flags))
393 
394  #recycling Pad data provider since not it's not doing anything
395  the_alg = CompFactory.Muon.sTgcPadTriggerRawDataProvider(name = name, ProviderTool = result.popToolsAndMerge(NswMMTPRawDataProviderToolCfg(flags)), **kwargs )
396  result.addEventAlgo(the_alg, primary = True)
397  return result
398 
399 

◆ NswMMTPRawDataProviderToolCfg()

def python.MuonBytestreamDecodeConfig.NswMMTPRawDataProviderToolCfg (   flags,
  name = "NswMMTPRawDataProviderTool",
**  kwargs 
)

Definition at line 380 of file MuonBytestreamDecodeConfig.py.

380 def NswMMTPRawDataProviderToolCfg(flags, name = "NswMMTPRawDataProviderTool", **kwargs ):
381  result = ComponentAccumulator()
382  kwargs.setdefault( "Decoder", result.popToolsAndMerge(NswMMTPRodDecoderCfg(flags)))
383  kwargs.setdefault( "RdoLocation", ( flags.Overlay.BkgPrefix if flags.Common.isOverlay else "") + "NSW_MMTrigProcessor_RDO" )
384  the_tool = CompFactory.Muon.NSWMMTP_RawDataProviderToolMT(name = name, **kwargs)
385  result.setPrivateTools(the_tool)
386  return result
387 

◆ NswMMTPRodDecoderCfg()

def python.MuonBytestreamDecodeConfig.NswMMTPRodDecoderCfg (   flags,
  name = "NswMMTPRodDecoder",
**  kwargs 
)

Definition at line 374 of file MuonBytestreamDecodeConfig.py.

374 def NswMMTPRodDecoderCfg(flags, name ="NswMMTPRodDecoder", **kwargs):
375  result = ComponentAccumulator()
376  the_tool = CompFactory.Muon.NSWMMTP_ROD_Decoder(name = name, **kwargs)
377  result.setPrivateTools(the_tool)
378  return result
379 

◆ NswTrigProcByteStreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.NswTrigProcByteStreamDecodeCfg (   flags,
  name = "NswProcByteStream" 
)

Definition at line 286 of file MuonBytestreamDecodeConfig.py.

286 def NswTrigProcByteStreamDecodeCfg(flags, name = "NswProcByteStream"):
287  result = ComponentAccumulator()
288  # Make sure muon geometry is configured
289  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
290  result.merge(MuonGeoModelCfg(flags))
291  the_alg = CompFactory.Muon.sTgcPadTriggerRawDataProvider(name = name,
292  ProviderTool = result.popToolsAndMerge(NswTrigProcessorRawDataProviderToolCfg(flags)) )
293  result.addEventAlgo(the_alg, primary = True)
294  return result
295 

◆ NswTrigProcessorRawDataProviderToolCfg()

def python.MuonBytestreamDecodeConfig.NswTrigProcessorRawDataProviderToolCfg (   flags,
  name = "NswTrigProcessorRawDataTool",
**  kwargs 
)

Definition at line 279 of file MuonBytestreamDecodeConfig.py.

279 def NswTrigProcessorRawDataProviderToolCfg(flags, name = "NswTrigProcessorRawDataTool", **kwargs ):
280  result = ComponentAccumulator()
281  kwargs.setdefault("Decoder", result.popToolsAndMerge(NswTrigProcessorRodDecoderCfg(flags)))
282  kwargs.setdefault( "RdoLocation", ( flags.Overlay.BkgPrefix if flags.Common.isOverlay else "") + "NSW_TrigProcessor_RDO" )
283  the_tool = CompFactory.Muon.NSWTP_RawDataProviderToolMT(name = name, **kwargs)
284  result.setPrivateTools(the_tool)
285  return result

◆ NswTrigProcessorRodDecoderCfg()

def python.MuonBytestreamDecodeConfig.NswTrigProcessorRodDecoderCfg (   flags,
  name = "NswTrigProcessorDecoder",
**  kwargs 
)

Definition at line 274 of file MuonBytestreamDecodeConfig.py.

274 def NswTrigProcessorRodDecoderCfg(flags, name ="NswTrigProcessorDecoder", **kwargs):
275  result = ComponentAccumulator()
276  the_tool = CompFactory.Muon.NSWTP_ROD_Decoder(name = name, **kwargs)
277  result.setPrivateTools(the_tool)
278  return result

◆ RpcBytestreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.RpcBytestreamDecodeCfg (   flags,
  name = "RpcRawDataProvider",
**  kwargs 
)

This configuration function sets up everything for decoding RPC bytestream data into RDOs.

The function returns a ComponentAccumulator and the data-decoding algorithm, which should be added to the right sequence by the user

Definition at line 34 of file MuonBytestreamDecodeConfig.py.

34 def RpcBytestreamDecodeCfg(flags, name="RpcRawDataProvider", **kwargs):
35  acc = ComponentAccumulator()
36 
37  # We need the RPC cabling to be setup
38  from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
39  acc.merge( RPCCablingConfigCfg(flags) )
40 
41  # Make sure muon geometry is configured
42  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
43  acc.merge(MuonGeoModelCfg(flags))
44 
45  # Setup the RPC ROD decoder
46  RPCRodDecoder = CompFactory.Muon.RpcROD_Decoder(name = "RpcROD_Decoder",NOBXS=flags.Trigger.L1MuonSim.RPCNBX)
47 
48 
49  # Setup the RAW data provider tool
50  keyName = flags.Overlay.BkgPrefix + "RPCPAD" if flags.Common.isOverlay else "RPCPAD"
51  MuonRpcRawDataProviderTool = CompFactory.Muon.RPC_RawDataProviderToolMT(name = "RPC_RawDataProviderToolMT",
52  Decoder = RPCRodDecoder,
53  RdoLocation = keyName )
54  if flags.Muon.MuonTrigger:
55  MuonRpcRawDataProviderTool.RpcContainerCacheKey = MuonCacheNames.RpcCache
56  MuonRpcRawDataProviderTool.WriteOutRpcSectorLogic = False
57 
58 
59  # Setup the RAW data provider algorithm
60  Muon__RpcRawDataProvider=CompFactory.Muon.RpcRawDataProvider
61  RpcRawDataProvider = Muon__RpcRawDataProvider(name = name,
62  ProviderTool = MuonRpcRawDataProviderTool, **kwargs )
63 
64  if flags.Muon.MuonTrigger:
65  # add RegSelTool
66  from RegionSelector.RegSelToolConfig import regSelTool_RPC_Cfg
67  RpcRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_RPC_Cfg( flags ) )
68 
69 
70  acc.addEventAlgo(RpcRawDataProvider, primary=True)
71  return acc
72 

◆ sTgcBytestreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.sTgcBytestreamDecodeCfg (   flags,
  name = "sTgcRawDataProvider",
**  kwargs 
)

Definition at line 235 of file MuonBytestreamDecodeConfig.py.

235 def sTgcBytestreamDecodeCfg(flags, name="sTgcRawDataProvider", **kwargs):
236 
237  acc = ComponentAccumulator()
238 
239  # We need the sTGC cabling to be setup
240  #from MuonConfig.MuonCablingConfig import STGCCablingConfigCfg
241  #acc.merge( STGCCablingConfigCfg(flags) )
242 
243  # Make sure muon geometry is configured
244  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
245  acc.merge(MuonGeoModelCfg(flags))
246 
247 
248 
249  # Setup the RAW data provider tool
250  keyName = flags.Overlay.BkgPrefix + "sTGCRDO" if flags.Common.isOverlay else "sTGCRDO"
251  Muon__STGC_RawDataProviderToolMT=CompFactory.Muon.STGC_RawDataProviderToolMT
252  MuonsTgcRawDataProviderTool = Muon__STGC_RawDataProviderToolMT(name = "sTgcRawDataProviderTool",
253  Decoder = acc.popToolsAndMerge(sTgcRODDecoderCfg(flags)),
254  RdoLocation = keyName,
255  SkipDecoding=flags.Muon.MuonTrigger and flags.Muon.runCommissioningChain )
256 
257  #if flags.Muon.MuonTrigger:
258  # MuonsTgcRawDataProviderTool.sTgcContainerCacheKey = MuonCacheNames.sTgcCache
259 
260  # Setup the RAW data provider algorithm
261  Muon__sTgcRawDataProvider=CompFactory.Muon.sTgcRawDataProvider
262  sTgcRawDataProvider = Muon__sTgcRawDataProvider(name = name,
263  ProviderTool = MuonsTgcRawDataProviderTool, **kwargs )
264  if flags.Muon.MuonTrigger:
265  # add RegSelTool
266  from RegionSelector.RegSelToolConfig import regSelTool_STGC_Cfg
267  sTgcRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_STGC_Cfg( flags ) )
268 
269 
270  acc.addEventAlgo(sTgcRawDataProvider,primary=True)
271 
272  return acc
273 

◆ sTgcPadTriggerBytestreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.sTgcPadTriggerBytestreamDecodeCfg (   flags,
  name = "sTgcPadTriggerRawDataProvider",
**  kwargs 
)

Definition at line 296 of file MuonBytestreamDecodeConfig.py.

296 def sTgcPadTriggerBytestreamDecodeCfg(flags, name="sTgcPadTriggerRawDataProvider", **kwargs):
297 
298  acc = ComponentAccumulator()
299 
300  # Make sure muon geometry is configured
301  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
302  acc.merge(MuonGeoModelCfg(flags))
303 
304  # Setup the sTGC ROD decoder
305  Muon__PadTrig_ROD_Decoder = CompFactory.Muon.PadTrig_ROD_Decoder
306  STGCPadTriggerRodDecoder = Muon__PadTrig_ROD_Decoder(name = "sTgcPadTriggerROD_Decoder")
307 
308 
309  # Setup the RAW data provider tool
310  keyName = flags.Overlay.BkgPrefix + "NSW_PadTrigger_RDO" if flags.Common.isOverlay else "NSW_PadTrigger_RDO"
311  Muon__PadTrig_RawDataProviderToolMT = CompFactory.Muon.PadTrig_RawDataProviderToolMT
312  MuonsTgcPadTriggerRawDataProviderTool = Muon__PadTrig_RawDataProviderToolMT(name = "sTgcPadTriggerRawDataProviderTool",
313  Decoder = STGCPadTriggerRodDecoder,
314  RdoLocation = keyName)
315 
316 
317  # Setup the RAW data provider algorithm
318  the_alg = CompFactory.Muon.sTgcPadTriggerRawDataProvider(name = name,
319  ProviderTool = MuonsTgcPadTriggerRawDataProviderTool, **kwargs )
320 
321  acc.addEventAlgo(the_alg, primary = True)
322 
323  return acc
324 

◆ sTgcRODDecoderCfg()

def python.MuonBytestreamDecodeConfig.sTgcRODDecoderCfg (   flags,
  name = "sTgcROD_Decoder",
**  kwargs 
)

Definition at line 222 of file MuonBytestreamDecodeConfig.py.

222 def sTgcRODDecoderCfg(flags, name = "sTgcROD_Decoder", **kwargs):
223  result = ComponentAccumulator()
224 
225  if False and not flags.Muon.MuonTrigger and not flags.Input.isMC:
226  from MuonConfig.MuonCondAlgConfig import NswDcsDbAlgCfg
227  result.merge(NswDcsDbAlgCfg(flags))
228  else:
229  kwargs.setdefault("DcsKey", "")
230  # Setup the sTGC ROD decoder
231  STGCRodDecoder = CompFactory.Muon.STGC_ROD_Decoder(name = name, **kwargs)
232  result.setPrivateTools(STGCRodDecoder)
233  return result
234 

◆ TgcBytestreamDecodeCfg()

def python.MuonBytestreamDecodeConfig.TgcBytestreamDecodeCfg (   flags,
  name = "TgcRawDataProvider",
**  kwargs 
)

Definition at line 97 of file MuonBytestreamDecodeConfig.py.

97 def TgcBytestreamDecodeCfg(flags, name="TgcRawDataProvider", **kwargs):
98  acc = ComponentAccumulator()
99 
100  # We need the TGC cabling to be setup
101  from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
102  acc.merge( TGCCablingConfigCfg(flags) )
103 
104  # Make sure muon geometry is configured
105  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
106  acc.merge(MuonGeoModelCfg(flags))
107 
108  # Setup the TGC ROD decoder
109  Muon__TGC_RodDecoderReadout=CompFactory.Muon.TGC_RodDecoderReadout
110  TGCRodDecoder = Muon__TGC_RodDecoderReadout(name = "TgcROD_Decoder")
111 
112 
113  # Setup the RAW data provider tool
114  keyName = flags.Overlay.BkgPrefix + "TGCRDO" if flags.Common.isOverlay else "TGCRDO"
115  Muon__TGC_RawDataProviderToolMT=CompFactory.Muon.TGC_RawDataProviderToolMT
116  MuonTgcRawDataProviderTool = Muon__TGC_RawDataProviderToolMT(name = "TGC_RawDataProviderToolMT",
117  Decoder = TGCRodDecoder,
118  RdoLocation = keyName )
119 
120  if flags.Muon.MuonTrigger:
121  MuonTgcRawDataProviderTool.TgcContainerCacheKey = MuonCacheNames.TgcCache
122 
123 
124  # Setup the RAW data provider algorithm
125  Muon__TgcRawDataProvider=CompFactory.Muon.TgcRawDataProvider
126  TgcRawDataProvider = Muon__TgcRawDataProvider(name = name,
127  ProviderTool = MuonTgcRawDataProviderTool, **kwargs )
128  if flags.Muon.MuonTrigger:
129  # add RegSelTool
130  from RegionSelector.RegSelToolConfig import regSelTool_TGC_Cfg
131  TgcRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_TGC_Cfg( flags ) )
132 
133 
134  acc.addEventAlgo(TgcRawDataProvider,primary=True)
135 
136  return acc
137 

Variable Documentation

◆ args

python.MuonBytestreamDecodeConfig.args = flags.fillFromArgs()

Definition at line 458 of file MuonBytestreamDecodeConfig.py.

◆ AtlasVersion

python.MuonBytestreamDecodeConfig.AtlasVersion

Definition at line 454 of file MuonBytestreamDecodeConfig.py.

◆ cfg

python.MuonBytestreamDecodeConfig.cfg = MainServicesCfg(flags)

Definition at line 463 of file MuonBytestreamDecodeConfig.py.

◆ Files

python.MuonBytestreamDecodeConfig.Files

Definition at line 452 of file MuonBytestreamDecodeConfig.py.

◆ flags

python.MuonBytestreamDecodeConfig.flags = initConfigFlags()

Definition at line 450 of file MuonBytestreamDecodeConfig.py.

◆ GlobalTag

python.MuonBytestreamDecodeConfig.GlobalTag

Definition at line 453 of file MuonBytestreamDecodeConfig.py.

◆ MaxEvents

python.MuonBytestreamDecodeConfig.MaxEvents

Definition at line 456 of file MuonBytestreamDecodeConfig.py.

◆ NumThreads

python.MuonBytestreamDecodeConfig.NumThreads

Definition at line 455 of file MuonBytestreamDecodeConfig.py.

◆ withDetails

python.MuonBytestreamDecodeConfig.withDetails

Definition at line 468 of file MuonBytestreamDecodeConfig.py.

python.MuonBytestreamDecodeConfig.MuonCacheCfg
def MuonCacheCfg(flags)
This configuration function creates the IdentifiableCaches for RDO.
Definition: MuonBytestreamDecodeConfig.py:17
RegSelToolConfig.regSelTool_MDT_Cfg
def regSelTool_MDT_Cfg(flags)
Definition: RegSelToolConfig.py:129
python.MuonBytestreamDecodeConfig.NrpcBytestreamDecodeCfg
def NrpcBytestreamDecodeCfg(flags, name="NrpcRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:73
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
python.MuonBytestreamDecodeConfig.NswMMTPRodDecoderCfg
def NswMMTPRodDecoderCfg(flags, name="NswMMTPRodDecoder", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:374
python.MuonBytestreamDecodeConfig.MmBytestreamDecodeCfg
def MmBytestreamDecodeCfg(flags, name="MmRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:341
python.MuonCablingConfig.NswCablingCfg
def NswCablingCfg(flags, name="MuonNSW_CablingAlg", **kwargs)
Definition: MuonCablingConfig.py:125
RegSelToolConfig.regSelTool_STGC_Cfg
def regSelTool_STGC_Cfg(flags)
Definition: RegSelToolConfig.py:180
python.MuonCablingConfig.TGCCablingConfigCfg
def TGCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:74
RegSelToolConfig.regSelTool_TGC_Cfg
def regSelTool_TGC_Cfg(flags)
Definition: RegSelToolConfig.py:156
python.ByteStreamConfig.ByteStreamReadCfg
def ByteStreamReadCfg(flags, type_names=None)
Definition: Event/ByteStreamCnvSvc/python/ByteStreamConfig.py:25
python.MuonCablingConfig.MDTCablingConfigCfg
def MDTCablingConfigCfg(flags, name="MuonMDT_CablingAlg", **kwargs)
Definition: MuonCablingConfig.py:91
python.MuonBytestreamDecodeConfig.NswTrigProcessorRawDataProviderToolCfg
def NswTrigProcessorRawDataProviderToolCfg(flags, name="NswTrigProcessorRawDataTool", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:279
python.MuonBytestreamDecodeConfig.CscBytestreamDecodeCfg
def CscBytestreamDecodeCfg(flags, name="CscRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:182
MuonCacheCreator
Definition: MuonCacheCreator.h:15
RegSelToolConfig.regSelTool_CSC_Cfg
def regSelTool_CSC_Cfg(flags)
Definition: RegSelToolConfig.py:168
python.MuonBytestreamDecodeConfig.sTgcPadTriggerBytestreamDecodeCfg
def sTgcPadTriggerBytestreamDecodeCfg(flags, name="sTgcPadTriggerRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:296
python.MuonCablingConfig.NRPCCablingConfigCfg
def NRPCCablingConfigCfg(flags, name="MuonNRPC_CablingAlg", **kwargs)
Definition: MuonCablingConfig.py:6
python.MuonBytestreamDecodeConfig.NswTrigProcessorRodDecoderCfg
def NswTrigProcessorRodDecoderCfg(flags, name="NswTrigProcessorDecoder", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:274
MdtROD_Decoder
Definition: MdtROD_Decoder.h:31
RegSelToolConfig.regSelTool_MM_Cfg
def regSelTool_MM_Cfg(flags)
Definition: RegSelToolConfig.py:186
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.MuonCablingConfig.CSCCablingConfigCfg
def CSCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:115
python.MuonBytestreamDecodeConfig.TgcBytestreamDecodeCfg
def TgcBytestreamDecodeCfg(flags, name="TgcRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:97
python.MuonCondAlgConfig.NswDcsDbAlgCfg
def NswDcsDbAlgCfg(flags, **kwargs)
Definition: MuonCondAlgConfig.py:349
python.MuonBytestreamDecodeConfig.sTgcRODDecoderCfg
def sTgcRODDecoderCfg(flags, name="sTgcROD_Decoder", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:222
python.MuonBytestreamDecodeConfig.MdtBytestreamDecodeCfg
def MdtBytestreamDecodeCfg(flags, name="MdtRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:138
python.MuonCablingConfig.RPCCablingConfigCfg
def RPCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:26
python.MuonGeometryConfig.MuonGeoModelCfg
def MuonGeoModelCfg(flags)
Definition: MuonGeometryConfig.py:28
python.MuonBytestreamDecodeConfig.NswMMTPByteStreamDecodeCfg
def NswMMTPByteStreamDecodeCfg(flags, name="NswMMTPByteStreamDecode", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:388
python.MuonBytestreamDecodeConfig.MmRDODDecoderCfg
def MmRDODDecoderCfg(flags, name="MmROD_Decoder", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:325
python.MagFieldServicesConfig.AtlasFieldCacheCondAlgCfg
def AtlasFieldCacheCondAlgCfg(flags, **kwargs)
Definition: MagFieldServicesConfig.py:8
python.MuonBytestreamDecodeConfig.NswMMTPRawDataProviderToolCfg
def NswMMTPRawDataProviderToolCfg(flags, name="NswMMTPRawDataProviderTool", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:380
RegSelToolConfig.regSelTool_RPC_Cfg
def regSelTool_RPC_Cfg(flags)
Definition: RegSelToolConfig.py:144
python.MuonBytestreamDecodeConfig.NswTrigProcByteStreamDecodeCfg
def NswTrigProcByteStreamDecodeCfg(flags, name="NswProcByteStream")
Definition: MuonBytestreamDecodeConfig.py:286
python.MuonBytestreamDecodeConfig.sTgcBytestreamDecodeCfg
def sTgcBytestreamDecodeCfg(flags, name="sTgcRawDataProvider", **kwargs)
Definition: MuonBytestreamDecodeConfig.py:235
python.MuonBytestreamDecodeConfig.MuonByteStreamDecodersCfg
def MuonByteStreamDecodersCfg(flags)
Definition: MuonBytestreamDecodeConfig.py:400
Generated on Tue Jul 2 2024 22:25:16 for ATLAS Offline Software by   doxygen 1.8.18