Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
MuonRdoDecodeConfig.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
2 
3 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
4 from AthenaConfiguration.ComponentFactory import CompFactory
5 from AthenaConfiguration.Enums import Format
6 from AthenaCommon.Constants import DEBUG, INFO
7 
8 
9 class MuonPrdCacheNames(object):
10  MdtCache = "MdtPrdCache"
11  CscCache = "CscPrdCache"
12  CscStripCache = "CscStripPrdCache"
13  RpcCache = "RpcPrdCache"
14  TgcCache = "TgcPrdCache"
15  sTgcCache = "sTgcPrdCache"
16  MmCache = "MmPrdCache"
17  RpcCoinCache = "RpcCoinCache"
18  TgcCoinCache = "TgcCoinCache"
19 
20 
21 
25 def MuonPrdCacheCfg(flags):
26  # Use MuonGeometryFlags to identify which configuration is being used
27 
28  acc = ComponentAccumulator()
29 
30  MuonPRDCacheCreator=CompFactory.MuonPRDCacheCreator
31  cacheCreator = MuonPRDCacheCreator(CscStripCacheKey = (MuonPrdCacheNames.CscStripCache if flags.Detector.GeometryCSC else ""),
32  MdtCacheKey = MuonPrdCacheNames.MdtCache,
33  CscCacheKey = (MuonPrdCacheNames.CscCache if flags.Detector.GeometryCSC else ""),
34  RpcCacheKey = MuonPrdCacheNames.RpcCache,
35  TgcCacheStr = MuonPrdCacheNames.TgcCache,
36  sTgcCacheKey = (MuonPrdCacheNames.sTgcCache if flags.Detector.GeometrysTGC else ""),
37  MmCacheKey = (MuonPrdCacheNames.MmCache if flags.Detector.GeometryMM else ""),
38  TgcCoinCacheStr = MuonPrdCacheNames.TgcCoinCache,
39  RpcCoinCacheKey = MuonPrdCacheNames.RpcCoinCache,
40  )
41 
42  acc.addEventAlgo( cacheCreator, primary=True )
43  return acc
44 
45 def MuonRdoToPrepDataAlgCfg(flags, name="MuonRdoToPrepDataAlg", **kwargs):
46  result = ComponentAccumulator()
47  # Make sure muon geometry is configured
48  from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
49  result.merge(MuonGeoModelCfg(flags))
50  if flags.Muon.usePhaseIIGeoSetup:
51  from ActsAlignmentAlgs.AlignmentAlgsConfig import ActsGeometryContextAlgCfg
52  result.merge(ActsGeometryContextAlgCfg(flags))
53 
54  kwargs.setdefault("DoSeededDecoding", flags.Trigger.doHLT )
55  the_alg = CompFactory.MuonRdoToPrepDataAlg(name, **kwargs)
56  result.addEventAlgo(the_alg, primary = True)
57  return result
58 
61 def RpcRdoToPrepDataToolCfg(flags, suffix ="", RDOContainer = None, **kwargs):
62  result = ComponentAccumulator()
63 
65  if flags.Input.isMC and flags.Muon.usePhaseIIGeoSetup and \
66  len([x for x in flags.Input.TypedCollections if x.find("RpcPadContainer#") != -1]):
67 
68  from MuonConfig.MuonByteStreamCnvTestConfig import RpcRdoToRpcDigitCfg, NrpcDigitToNrpcRDOCfg
69 
70  cnv_args = {}
71  if RDOContainer: cnv_args.setdefault("RpcRdoContainer", RDOContainer)
72 
73  result.merge(RpcRdoToRpcDigitCfg(flags,
74  name="RpcRdoDigitPatchAlg" + suffix,
75  RpcDigitContainer="CnvRpcDigits",
76  **cnv_args))
77 
78  result.merge(NrpcDigitToNrpcRDOCfg(flags,
79  name="RpcBackConverterAlg" + suffix,
80  RpcDigitContainer="CnvRpcDigits",
81  NrpcRdoKey="CnvRpcRDOs"))
82  kwargs.setdefault("RpcRdoContainer", "CnvRpcRDOs")
83 
85  if RDOContainer:
86  kwargs.setdefault("RpcRdoContainer", RDOContainer)
87 
88  if flags.Input.isMC and flags.Muon.usePhaseIIGeoSetup:
89  from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
90  result.merge(NRPCCablingConfigCfg(flags))
91  from AthenaConfiguration.Enums import LHCPeriod
92  kwargs.setdefault("decode2DStrips", flags.GeoModel.Run >= LHCPeriod.Run4)
93  if not kwargs["decode2DStrips"]:
94  kwargs.setdefault("OutputContainer", "xRpcMeasurements")
95  the_tool = CompFactory.MuonR4.RpcRdoToRpcPrepDataTool(name="RpcPrepDataProviderTool", **kwargs)
96  result.setPrivateTools(the_tool)
97  else:
98  # We need the RPC cabling to be setup
99  from MuonConfig.MuonCablingConfig import RPCLegacyCablingConfigCfg
100  result.merge(RPCLegacyCablingConfigCfg(flags))
101 
102  if not flags.Input.isMC:
103  kwargs["reduceCablingOverlap"] = True
104  kwargs["produceRpcCoinDatafromTriggerWords"] = True
105  kwargs["overlap_timeTolerance"] = 1000
106  kwargs["solvePhiAmbiguities"] = True
107  kwargs["etaphi_coincidenceTime"] = 1000
108  if not flags.Trigger.doHLT:
109  kwargs["RpcPrdContainerCacheKey"] = ""
110  kwargs["RpcCoinDataContainerCacheKey"] = ""
111 
112  from MuonConfig.MuonCondAlgConfig import RpcCondDbAlgCfg
113  result.merge(RpcCondDbAlgCfg(flags))
114  else:
115  kwargs["RPCInfoFromDb"] = False
116 
117  if not flags.Muon.enableNRPC:
118  kwargs["NrpcInputCollection"] = ""
119 
120  kwargs["xAODKey"] = "xRpcMeasurements" if flags.Muon.writexAODPRD or \
121  flags.Muon.usePhaseIIGeoSetup else ""
122 
123 
128  if not flags.Input.isMC and (flags.Muon.MuonTrigger or flags.Input.RunNumbers[0] >= 454434):
129  kwargs["timeShift"] = 37.5
130  #Setup RPC RDO decoder to be consistent with RPC readout settings
131  if flags.Muon.MuonTrigger:
132  kwargs["RdoDecoderTool"] = CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder", BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
133 
134  kwargs.setdefault("isMC", flags.Input.isMC)
135  the_tool = CompFactory.Muon.RpcRdoToPrepDataToolMT(name="RpcPrepDataProviderTool",**kwargs)
136  result.setPrivateTools(the_tool)
137 
138  return result
139 
140 def RpcRDODecodeCfg(flags, name="RpcRdoToRpcPrepData", RDOContainer = None, **kwargs):
141  acc = ComponentAccumulator()
142 
143  suffix = name[name.find("_") :] if name.find("_") != -1 else ""
144  # Conditions not needed for online
145  # Get the RDO -> PRD tool
146  kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(RpcRdoToPrepDataToolCfg(flags, suffix=suffix, RDOContainer=RDOContainer)))
147  # add RegSelTool
148  from RegionSelector.RegSelToolConfig import regSelTool_RPC_Cfg
149  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_RPC_Cfg(flags)))
150  kwargs.setdefault("useROBs", False)
151 
152  # Add the RDO -> PRD alorithm
153  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
154 
155 
156  if flags.Muon.usePhaseIIGeoSetup and flags.Input.isMC:
157  from xAODMuonTrkPrepDataCnv.MuonPrepDataCnvCfg import xRpcToRpcPrepDataCnvAlgCfg
158  acc.merge(xRpcToRpcPrepDataCnvAlgCfg(flags, name=f"xAODRpcToPrepDataCnvAlg{suffix}"))
159  from AthenaConfiguration.Enums import LHCPeriod
160  if flags.GeoModel.Run >= LHCPeriod.Run4:
161  from xAODMuonViewAlgs.ViewAlgsConfig import RpcMeasViewAlgCfg
162  acc.merge(RpcMeasViewAlgCfg(flags, name=f"RpcMeasViewAlg{suffix}"))
163  return acc
164 
165 
166 def TgcRDODecodeCfg(flags, name="TgcRdoToTgcPrepData", RDOContainer = None, **kwargs):
167  acc = ComponentAccumulator()
168 
169  # We need the TGC cabling to be setup
170  from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
171  acc.merge(TGCCablingConfigCfg(flags))
172 
173  # Get the RDO -> PRD tool
174  tool_args = {}
175  if not flags.Trigger.doHLT:
176  tool_args.setdefault("PrdCacheString", "")
177  tool_args.setdefault("CoinCacheString", "")
178  tool_args.setdefault("xAODKey", "xTgcStrips" if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup else "")
179 
180  if RDOContainer: tool_args.setdefault("RDOContainer", RDOContainer)
181  kwargs.setdefault("DecodingTool", CompFactory.Muon.TgcRdoToPrepDataToolMT(name="TgcPrepDataProviderTool", **tool_args))
182 
183  # add RegSelTool
184  from RegionSelector.RegSelToolConfig import regSelTool_TGC_Cfg
185  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_TGC_Cfg(flags)))
186  kwargs.setdefault("useROBs", False)
187 
188 
189 
190  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
191  return acc
192 
193 def TgcPrepDataReplicationToolAllBCto3BC(flags, name = "TgcPrepDataAllBCto3BCTool", **kwargs):
194  acc = ComponentAccumulator()
195  the_tool = CompFactory.Muon.TgcPrepDataReplicationToolAllBCto3BC(name, **kwargs)
196  acc.setPrivateTools(the_tool)
197  return acc
198 
199 def TgcPrepDataAllBCto3BCCfg(flags, name="TgcPrepDataAllTo3Replicator", **kwargs):
200  acc = ComponentAccumulator()
201  kwargs.setdefault("Tool", acc.popToolsAndMerge(TgcPrepDataReplicationToolAllBCto3BC(flags)))
202  acc.addEventAlgo(CompFactory.Muon.TgcPrepDataReplicationAlg(name, **kwargs))
203  return acc
204 
205 
206 def StgcRdoToPrepDataToolCfg(flags, name="STGC_PrepDataProviderTool", **kwargs):
207  result = ComponentAccumulator()
208  kwargs.setdefault("PrdCacheKey" , MuonPrdCacheNames.sTgcCache if flags.Muon.MuonTrigger else "")
209  kwargs.setdefault("UseR4DetMgr", flags.Muon.usePhaseIIGeoSetup)
210  if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup:
211  kwargs.setdefault("xAODStripKey", "xAODsTgcStrips")
212  kwargs.setdefault("xAODWireKey", "xAODsTgcWires")
213  kwargs.setdefault("xAODPadKey", "xAODsTgcPads")
214 
215  from MuonConfig.MuonRecToolsConfig import SimpleSTgcClusterBuilderToolCfg
216  kwargs.setdefault("ClusterBuilderTool",result.popToolsAndMerge(SimpleSTgcClusterBuilderToolCfg(flags)))
217  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
218  kwargs.setdefault("NSWCalibTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
219  the_tool = CompFactory.Muon.sTgcRdoToPrepDataToolMT(name, **kwargs)
220  result.setPrivateTools(the_tool)
221  return result
222 
223 
224 def StgcRDODecodeCfg(flags, name="StgcRdoToStgcPrepData", **kwargs):
225  acc = ComponentAccumulator()
226  # Get the RDO -> PRD tool
227  kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(StgcRdoToPrepDataToolCfg(flags)))
228  # add RegSelTool
229  from RegionSelector.RegSelToolConfig import regSelTool_STGC_Cfg
230  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_STGC_Cfg(flags)))
231  kwargs.setdefault("useROBs", False)
232 
233 
234 
235  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
236  if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup:
237  suffix = name[name.find("_") :] if name.find("_") != -1 else ""
238  from xAODMuonViewAlgs.ViewAlgsConfig import sTgcMeasViewAlgCfg
239  acc.merge(sTgcMeasViewAlgCfg(flags, name=f"sTgcMeasViewAlg{suffix}"))
240 
241  return acc
242 
243 
244 def MMRdoToPrepDataToolCfg(flags, name="MmRdoToPrepDataTool", **kwargs):
245  result = ComponentAccumulator()
246  kwargs.setdefault("PrdCacheKey" , MuonPrdCacheNames.MmCache if flags.Trigger.doHLT else "")
247 
248  from MuonConfig.MuonRecToolsConfig import SimpleMMClusterBuilderToolCfg
249  kwargs.setdefault("ClusterBuilderTool",result.popToolsAndMerge(SimpleMMClusterBuilderToolCfg(flags)))
250  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
251  kwargs.setdefault("NSWCalibTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
252  kwargs["xAODKey"] = "xAODMMClusters" if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup else ""
253 
254  the_tool = CompFactory.Muon.MmRdoToPrepDataToolMT(name, **kwargs)
255  result.setPrivateTools(the_tool)
256  return result
257 
258 
259 def MMRDODecodeCfg(flags, name="MM_RdoToMM_PrepData", **kwargs):
260  acc = ComponentAccumulator()
261 
262  kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(MMRdoToPrepDataToolCfg(flags)))
263  # add RegSelTool
264  from RegionSelector.RegSelToolConfig import regSelTool_MM_Cfg
265  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_MM_Cfg(flags)))
266  kwargs.setdefault("useROBs", False)
267  # Add the RDO -> PRD alorithm
268  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
269  return acc
270 
271 
272 def MdtRDODecodeCfg(flags, name="MdtRdoToMdtPrepData", RDOContainer = None, **kwargs):
273  acc = ComponentAccumulator()
274  from MuonConfig.MuonCalibrationConfig import MdtCalibrationToolCfg
275 
276  tool_kwargs = {}
277 
278  # Twin tube conditions not available in COMP200.
279  tool_kwargs.setdefault('UseTwin', True)
280  if flags.IOVDb.DatabaseInstance == 'COMP200':
281  tool_kwargs['UseTwin'] = False
282 
283  # We need the MDT cabling to be setup
284  from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg, MdtTwinTubeMapCondAlgCfg
285  acc.merge(MDTCablingConfigCfg(flags))
286  if tool_kwargs['UseTwin']:
287  acc.merge(MdtTwinTubeMapCondAlgCfg(flags))
288 
289  writexAOD = flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup
290  tool_kwargs["xAODKey"] = "xMdtDriftCircles" if writexAOD else ""
291  tool_kwargs["xAODTwinKey"] = "xMdtTwinDriftCircles" if writexAOD else ""
292 
293 
294  tool_kwargs["UseR4DetMgr"] = flags.Muon.usePhaseIIGeoSetup
295  tool_kwargs["CalibrationTool"] = acc.popToolsAndMerge(MdtCalibrationToolCfg(flags, TimeWindowSetting = 2,
296  DoPropagationCorrection = False))
297  if RDOContainer: tool_kwargs["RDOContainer"] = RDOContainer
298  # Get the RDO -> PRD tool
299  kwargs.setdefault("DecodingTool", CompFactory.Muon.MdtRdoToPrepDataToolMT(name="MdtPrepDataProviderTool", **tool_kwargs))
300 
301  # add RegSelTool
302  from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
303  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_MDT_Cfg(flags)))
304 
305  # Add the RDO -> PRD alorithm
306  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
307  if writexAOD:
308  suffix = name[name.find("_") :] if name.find("_") != -1 else ""
309  from xAODMuonViewAlgs.ViewAlgsConfig import MdtMeasViewAlgCfg
310  acc.merge(MdtMeasViewAlgCfg(flags, name=f"MdtMeasViewAlg{suffix}"))
311  return acc
312 
313 
314 def CscRDODecodeCfg(flags, name="CscRdoToCscPrepData", RDOContainer = None, **kwargs):
315  acc = ComponentAccumulator()
316 
317  # We need the CSC cabling to be setup
318  from MuonConfig.MuonCablingConfig import CSCCablingConfigCfg # Not yet been prepared
319  acc.merge(CSCCablingConfigCfg(flags))
320 
321  from MuonConfig.MuonCondAlgConfig import CscCondDbAlgCfg
322  acc.merge(CscCondDbAlgCfg(flags))
323 
324  # Get the RDO -> PRD tool
325 
326  kwargs.setdefault("useROBs", False)
327  kwargs.setdefault("DecodingTool", CompFactory.Muon.CscRdoToCscPrepDataToolMT(name="CscPrepDataProviderTool"))
328  if RDOContainer:
329  kwargs["DecodingTool"].RDOContainer = RDOContainer
330  # add RegSelTool
331  from RegionSelector.RegSelToolConfig import regSelTool_CSC_Cfg
332  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_CSC_Cfg(flags)))
333 
334  # Add the RDO -> PRD alorithm
335  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
336  return acc
337 
338 
339 def CscClusterBuildCfg(flags, name="CscThresholdClusterBuilder"):
340  acc = ComponentAccumulator()
341  from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
342  from MuonConfig.MuonSegmentFindingConfig import CalibCscStripFitterCfg, QratCscClusterFitterCfg, CscAlignmentTool
343  from MuonConfig.MuonCalibrationConfig import CscCalibToolCfg
344 
345  # Get cluster creator tool
346 
347  MuonIdHelperSvc = acc.getPrimaryAndMerge( MuonIdHelperSvcCfg(flags) )
348  CalibCscStripFitter = acc.getPrimaryAndMerge( CalibCscStripFitterCfg(flags) )
349  QratCscClusterFitter = acc.getPrimaryAndMerge( QratCscClusterFitterCfg(flags) )
350  SimpleCscClusterFitter = CompFactory.SimpleCscClusterFitter(CscAlignmentTool = CscAlignmentTool(flags) )
351  CscSplitClusterFitter = CompFactory.CscSplitClusterFitter( precision_fitter = QratCscClusterFitter,
352  default_fitter = SimpleCscClusterFitter )
353  CscCalibTool = acc.getPrimaryAndMerge( CscCalibToolCfg(flags) )
354  CscThresholdClusterBuilderTool=CompFactory.CscThresholdClusterBuilderTool
355  CscClusterBuilderTool = CscThresholdClusterBuilderTool(name = "CscThresholdClusterBuilderTool" ,
356  MuonIdHelperSvc = MuonIdHelperSvc,
357  strip_fitter = CalibCscStripFitter,
358  precision_fitter = QratCscClusterFitter,
359  default_fitter = SimpleCscClusterFitter,
360  split_fitter = CscSplitClusterFitter,
361  cscCalibTool = CscCalibTool)
362 
363  #CSC cluster building
364  CscThresholdClusterBuilder=CompFactory.CscThresholdClusterBuilder
365  CscClusterBuilder = CscThresholdClusterBuilder(name = name,
366  cluster_builder = CscClusterBuilderTool,
367  MuonIdHelperSvc = MuonIdHelperSvc
368  )
369  acc.addEventAlgo(CscClusterBuilder)
370 
371  return acc
372 
373 
374 def MuonPRD_MultiTruthMakerCfg(flags, name="MuonPRD_MultiTruthMaker", **kwargs):
375  from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
376  result = ComponentAccumulator()
377  result.merge(MuonIdHelperSvcCfg(flags))
378 
379  if not flags.Detector.GeometryMDT: kwargs.setdefault("MdtPrdKey", "")
380  if not flags.Detector.GeometryRPC: kwargs.setdefault("RpcPrdKey", "")
381  if not flags.Detector.GeometryTGC: kwargs.setdefault("TgcPrdKey", "")
382  if not flags.Detector.GeometryCSC: kwargs.setdefault("CscPrdKey", "")
383 
384  if not flags.Detector.GeometrysTGC: kwargs.setdefault("sTgcPrdKey", "")
385  if not flags.Detector.GeometryMM: kwargs.setdefault("MmPrdKey", "")
386 
387  kwargs.setdefault("TgcPrdKey", 'TGC_MeasurementsAllBCs' if not flags.Muon.useTGCPriorNextBC else 'TGC_Measurements')
388  result.addEventAlgo(CompFactory.MuonPRD_MultiTruthMaker(name, **kwargs), primary = True)
389  return result
390 
391 
392 def MuonRDOtoPRDConvertorsCfg(flags):
393  # Schedule RDO conversion
394  acc = ComponentAccumulator()
395 
396  if flags.Detector.GeometryMDT:
397  acc.merge(MdtRDODecodeCfg(flags))
398 
399  if flags.Detector.GeometryRPC:
400  acc.merge(RpcRDODecodeCfg(flags))
401 
402  if flags.Detector.GeometryTGC:
403  acc.merge(TgcRDODecodeCfg(flags))
404 
405  if flags.Detector.GeometrysTGC:
406  acc.merge(StgcRDODecodeCfg(flags))
407 
408  if flags.Detector.GeometryMM:
409  acc.merge(MMRDODecodeCfg(flags))
410 
411 
412  if flags.Detector.GeometryCSC:
413  acc.merge(CscRDODecodeCfg(flags))
414  acc.merge(CscClusterBuildCfg(flags))
415 
416  if flags.Input.isMC and not flags.Muon.usePhaseIIGeoSetup:
417  acc.merge(MuonPRD_MultiTruthMakerCfg(flags))
418  return acc
419 
420 
421 # This function runs the decoding on a data file
422 def muonRdoDecodeTestData( forTrigger = False ):
423  from AthenaConfiguration.AllConfigFlags import initConfigFlags
424  from AthenaConfiguration.TestDefaults import defaultConditionsTags, defaultGeometryTags, defaultTestFiles
425  flags = initConfigFlags()
426  flags.Input.Files = defaultTestFiles.RAW_RUN2
427  flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN2
428  flags.IOVDb.GlobalTag = defaultConditionsTags.RUN2_DATA
429 
430  flags.lock()
431  flags.dump()
432 
433  from AthenaCommon.Logging import log
434 
435  log.setLevel(INFO)
436  log.info('About to setup Raw data decoding')
437 
438  from AthenaConfiguration.MainServicesConfig import MainServicesCfg
439  cfg = MainServicesCfg(flags)
440 
441  # Add the MuonCache to ComponentAccumulator for trigger/RoI testing mode
442  if forTrigger:
443  # cache creators loaded independently
444  from MuonConfig.MuonBytestreamDecodeConfig import MuonCacheCfg
445  cfg.merge( MuonCacheCfg(flags) )
446 
447  if flags.Input.Format is Format.BS:
448  from MuonConfig.MuonBytestreamDecodeConfig import MuonByteStreamDecodersCfg
449  cfg.merge( MuonByteStreamDecodersCfg( flags) )
450 
451  cfg.merge( MuonRDOtoPRDConvertorsCfg( flags) )
452 
453  log.info('Print Config')
454  cfg.printConfig(withDetails=True)
455 
456  if forTrigger:
457  pklName = 'MuonRdoDecode_Cache.pkl'
458  else:
459  pklName = 'MuonRdoDecode.pkl'
460 
461  # Store config as pickle
462  log.info('Save Config')
463  with open(pklName,'wb') as f:
464  cfg.store(f)
465  f.close()
466  return cfg
467 
468 # This function runs the decoding on a MC file
469 def muonRdoDecodeTestMC():
470 
471  from AthenaConfiguration.AllConfigFlags import initConfigFlags
472  flags = initConfigFlags()
473  flags.Input.Files = ["/cvmfs/atlas-nightlies.cern.ch/repo/data/data-art/TriggerTest/valid1.110401.PowhegPythia_P2012_ttbar_nonallhad.recon.RDO.e3099_s2578_r7572_tid07644622_00/RDO.07644622._000001.pool.root.1"]
474 
475  flags.lock()
476  flags.dump()
477 
478  from AthenaCommon.Logging import log
479 
480  log.setLevel(DEBUG)
481  log.info('About to setup Rpc RDO data decoding')
482 
483  cfg=ComponentAccumulator()
484 
485  # We are reading a pool file for this test
486  from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
487  cfg.merge(PoolReadCfg(flags))
488 
489  # Schedule RDO conversion
490  cfg.merge( MuonRDOtoPRDConvertorsCfg( flags) )
491 
492  log.info('Print Config')
493  cfg.printConfig(withDetails=True)
494 
495  # Store config as pickle
496  log.info('Save Config')
497  with open('MuonRdoDecode.pkl','wb') as f:
498  cfg.store(f)
499  f.close()
500  return cfg
501 
502 if __name__=="__main__":
503  # To run this, do e.g.
504  # python ../athena/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
505  cfg = muonRdoDecodeTestData()
506  #muonRdoDecodeTestMC()
507 
508 
ViewAlgsConfig.RpcMeasViewAlgCfg
def RpcMeasViewAlgCfg(flags, name="RpcMeasViewAlg", **kwargs)
Definition: ViewAlgsConfig.py:14
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:134
python.JetAnalysisCommon.ComponentAccumulator
ComponentAccumulator
Definition: JetAnalysisCommon.py:302
python.MuonRdoDecodeConfig.TgcPrepDataAllBCto3BCCfg
def TgcPrepDataAllBCto3BCCfg(flags, name="TgcPrepDataAllTo3Replicator", **kwargs)
Definition: MuonRdoDecodeConfig.py:199
RegSelToolConfig.regSelTool_STGC_Cfg
def regSelTool_STGC_Cfg(flags)
Definition: RegSelToolConfig.py:185
python.MuonCablingConfig.MdtTwinTubeMapCondAlgCfg
def MdtTwinTubeMapCondAlgCfg(flags, name="MdtTwinTubeCondAlg", **kwargs)
Definition: MuonCablingConfig.py:150
python.MuonRecToolsConfig.SimpleMMClusterBuilderToolCfg
def SimpleMMClusterBuilderToolCfg(flags, name="SimpleMMClusterBuilderTool", **kwargs)
Definition: MuonRecToolsConfig.py:304
python.MuonRdoDecodeConfig.StgcRDODecodeCfg
def StgcRDODecodeCfg(flags, name="StgcRdoToStgcPrepData", **kwargs)
Definition: MuonRdoDecodeConfig.py:224
python.MuonCalibrationConfig.CscCalibToolCfg
def CscCalibToolCfg(flags, name="CscCalibTool", **kwargs)
CSC calibration.
Definition: MuonCalibrationConfig.py:21
CscThresholdClusterBuilderTool
Definition: CscThresholdClusterBuilderTool.h:75
python.MuonRdoDecodeConfig.MMRDODecodeCfg
def MMRDODecodeCfg(flags, name="MM_RdoToMM_PrepData", **kwargs)
Definition: MuonRdoDecodeConfig.py:259
ViewAlgsConfig.sTgcMeasViewAlgCfg
def sTgcMeasViewAlgCfg(flags, name="sTgcMeasViewAlg", **kwargs)
Definition: ViewAlgsConfig.py:6
python.MuonCondAlgConfig.RpcCondDbAlgCfg
def RpcCondDbAlgCfg(flags, **kwargs)
Definition: MuonCondAlgConfig.py:78
python.MuonCablingConfig.TGCCablingConfigCfg
def TGCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:86
python.MuonRdoDecodeConfig.RpcRdoToPrepDataToolCfg
def RpcRdoToPrepDataToolCfg(flags, suffix="", RDOContainer=None, **kwargs)
This configuration function sets up everything for decoding RPC RDO to PRD conversion.
Definition: MuonRdoDecodeConfig.py:61
python.MuonCondAlgConfig.CscCondDbAlgCfg
def CscCondDbAlgCfg(flags, **kwargs)
Definition: MuonCondAlgConfig.py:90
python.MuonSegmentFindingConfig.QratCscClusterFitterCfg
def QratCscClusterFitterCfg(flags, **kwargs)
Definition: MuonSegmentFindingConfig.py:256
RegSelToolConfig.regSelTool_TGC_Cfg
def regSelTool_TGC_Cfg(flags)
Definition: RegSelToolConfig.py:161
ViewAlgsConfig.MdtMeasViewAlgCfg
def MdtMeasViewAlgCfg(flags, name="MdtMeasViewAlg", **kwargs)
Definition: ViewAlgsConfig.py:22
python.MuonCablingConfig.MDTCablingConfigCfg
def MDTCablingConfigCfg(flags, name="MuonMDT_CablingAlg", **kwargs)
Definition: MuonCablingConfig.py:100
CscThresholdClusterBuilder
Definition: CscThresholdClusterBuilder.h:77
MuonPRDCacheCreator
Definition: MuonPRDCacheCreator.h:14
python.MuonSegmentFindingConfig.CalibCscStripFitterCfg
def CalibCscStripFitterCfg(flags, name="CalibCscStripFitter", **kwargs)
Definition: MuonSegmentFindingConfig.py:286
CscAlignmentTool
Definition: CscAlignmentTool.h:22
python.MuonRdoDecodeConfig.CscRDODecodeCfg
def CscRDODecodeCfg(flags, name="CscRdoToCscPrepData", RDOContainer=None, **kwargs)
Definition: MuonRdoDecodeConfig.py:314
python.MuonRdoDecodeConfig.MMRdoToPrepDataToolCfg
def MMRdoToPrepDataToolCfg(flags, name="MmRdoToPrepDataTool", **kwargs)
Definition: MuonRdoDecodeConfig.py:244
python.MuonRdoDecodeConfig.TgcPrepDataReplicationToolAllBCto3BC
def TgcPrepDataReplicationToolAllBCto3BC(flags, name="TgcPrepDataAllBCto3BCTool", **kwargs)
Definition: MuonRdoDecodeConfig.py:193
python.MuonRdoDecodeConfig.RpcRDODecodeCfg
def RpcRDODecodeCfg(flags, name="RpcRdoToRpcPrepData", RDOContainer=None, **kwargs)
Definition: MuonRdoDecodeConfig.py:140
python.MuonGeometryConfig.MuonIdHelperSvcCfg
def MuonIdHelperSvcCfg(flags)
Definition: MuonGeometryConfig.py:15
python.MuonCalibrationConfig.NSWCalibToolCfg
def NSWCalibToolCfg(flags, name="NSWCalibTool", **kwargs)
Definition: MuonCalibrationConfig.py:177
python.MuonRdoDecodeConfig.MuonPrdCacheNames
Small class to hold the names for cache containers, should help to avoid copy / paste errors.
Definition: MuonRdoDecodeConfig.py:9
RegSelToolConfig.regSelTool_CSC_Cfg
def regSelTool_CSC_Cfg(flags)
Definition: RegSelToolConfig.py:173
MuonPrepDataCnvCfg.xRpcToRpcPrepDataCnvAlgCfg
def xRpcToRpcPrepDataCnvAlgCfg(flags, name="xAODRpcToPrepDataCnvAlg", **kwargs)
Definition: MuonPrepDataCnvCfg.py:7
AlignmentAlgsConfig.ActsGeometryContextAlgCfg
def ActsGeometryContextAlgCfg(flags, name="GeometryContextAlg", **kwargs)
Setup the Geometry context algorithm.
Definition: AlignmentAlgsConfig.py:125
python.MuonCablingConfig.NRPCCablingConfigCfg
def NRPCCablingConfigCfg(flags, name="MuonNRPC_CablingAlg", **kwargs)
Definition: MuonCablingConfig.py:6
python.MainServicesConfig.MainServicesCfg
def MainServicesCfg(flags, LoopMgr='AthenaEventLoopMgr')
Definition: MainServicesConfig.py:260
python.MuonByteStreamCnvTestConfig.RpcRdoToRpcDigitCfg
def RpcRdoToRpcDigitCfg(flags, name="RpcRdoToRpcDigitAlg", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:44
python.MuonCalibrationConfig.MdtCalibrationToolCfg
def MdtCalibrationToolCfg(flags, name="MdtCalibrationTool", **kwargs)
Definition: MuonCalibrationConfig.py:82
Constants
some useful constants -------------------------------------------------—
RegSelToolConfig.regSelTool_MM_Cfg
def regSelTool_MM_Cfg(flags)
Definition: RegSelToolConfig.py:191
python.MuonRdoDecodeConfig.MuonPRD_MultiTruthMakerCfg
def MuonPRD_MultiTruthMakerCfg(flags, name="MuonPRD_MultiTruthMaker", **kwargs)
Definition: MuonRdoDecodeConfig.py:374
python.MuonCablingConfig.CSCCablingConfigCfg
def CSCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:166
python.MuonRdoDecodeConfig.StgcRdoToPrepDataToolCfg
def StgcRdoToPrepDataToolCfg(flags, name="STGC_PrepDataProviderTool", **kwargs)
Definition: MuonRdoDecodeConfig.py:206
python.MuonByteStreamCnvTestConfig.NrpcDigitToNrpcRDOCfg
def NrpcDigitToNrpcRDOCfg(flags, name="NrpcDigitToNrpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:196
python.MuonRecToolsConfig.SimpleSTgcClusterBuilderToolCfg
def SimpleSTgcClusterBuilderToolCfg(flags, name="SimpleSTgcClusterBuilderTool", **kwargs)
Definition: MuonRecToolsConfig.py:335
python.MuonRdoDecodeConfig.MuonRdoToPrepDataAlgCfg
def MuonRdoToPrepDataAlgCfg(flags, name="MuonRdoToPrepDataAlg", **kwargs)
Definition: MuonRdoDecodeConfig.py:45
python.MuonRdoDecodeConfig.TgcRDODecodeCfg
def TgcRDODecodeCfg(flags, name="TgcRdoToTgcPrepData", RDOContainer=None, **kwargs)
Definition: MuonRdoDecodeConfig.py:166
Trk::open
@ open
Definition: BinningType.h:40
python.MuonRdoDecodeConfig.muonRdoDecodeTestData
def muonRdoDecodeTestData(forTrigger=False)
Definition: MuonRdoDecodeConfig.py:422
python.MuonGeometryConfig.MuonGeoModelCfg
def MuonGeoModelCfg(flags)
Definition: MuonGeometryConfig.py:28
python.AllConfigFlags.initConfigFlags
def initConfigFlags()
Definition: AllConfigFlags.py:19
python.MuonRdoDecodeConfig.muonRdoDecodeTestMC
def muonRdoDecodeTestMC()
Definition: MuonRdoDecodeConfig.py:469
python.MuonRdoDecodeConfig.MuonRDOtoPRDConvertorsCfg
def MuonRDOtoPRDConvertorsCfg(flags)
Definition: MuonRdoDecodeConfig.py:392
pickleTool.object
object
Definition: pickleTool.py:30
python.MuonCablingConfig.RPCLegacyCablingConfigCfg
def RPCLegacyCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:41
python.PoolReadConfig.PoolReadCfg
def PoolReadCfg(flags)
Definition: PoolReadConfig.py:69
RegSelToolConfig.regSelTool_RPC_Cfg
def regSelTool_RPC_Cfg(flags)
Definition: RegSelToolConfig.py:149
python.MuonRdoDecodeConfig.MdtRDODecodeCfg
def MdtRDODecodeCfg(flags, name="MdtRdoToMdtPrepData", RDOContainer=None, **kwargs)
Definition: MuonRdoDecodeConfig.py:272
python.MuonRdoDecodeConfig.CscClusterBuildCfg
def CscClusterBuildCfg(flags, name="CscThresholdClusterBuilder")
Definition: MuonRdoDecodeConfig.py:339
python.MuonBytestreamDecodeConfig.MuonByteStreamDecodersCfg
def MuonByteStreamDecodersCfg(flags)
Definition: MuonBytestreamDecodeConfig.py:407
python.MuonRdoDecodeConfig.MuonPrdCacheCfg
def MuonPrdCacheCfg(flags)
This configuration function creates the IdentifiableCaches for PRD.
Definition: MuonRdoDecodeConfig.py:25
Generated on Sat Apr 12 2025 21:15:49 for ATLAS Offline Software by   doxygen 1.8.18