ATLAS Offline Software
MuonRdoDecodeConfig.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2024 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 
51  kwargs.setdefault("DoSeededDecoding", flags.Trigger.doHLT )
52  the_alg = CompFactory.MuonRdoToPrepDataAlg(name, **kwargs)
53  result.addEventAlgo(the_alg, primary = True)
54  return result
55 
58 def RpcRdoToPrepDataToolCfg(flags, name ="RpcRdoToRpcPrepData",RDOContainer = None, **kwargs):
59  result = ComponentAccumulator()
60 
62  if flags.Input.isMC and flags.Muon.usePhaseIIGeoSetup and \
63  len([x for x in flags.Input.TypedCollections if x.find("RpcPadContainer#") != -1]):
64 
65  from MuonConfig.MuonByteStreamCnvTestConfig import RpcRdoToRpcDigitCfg, NrpcDigitToNrpcRDOCfg
66 
67  cnv_args = {}
68  if RDOContainer: cnv_args.setdefault("RpcRdoContainer", RDOContainer)
69  result.merge(RpcRdoToRpcDigitCfg(flags,
70  RpcDigitContainer="CnvRpcDigits", **cnv_args))
71 
72  result.merge(NrpcDigitToNrpcRDOCfg(flags,RpcDigitContainer="CnvRpcDigits",
73  NrpcRdoKey="CnvRpcRDOs"))
74 
75  kwargs.setdefault("RdoCollection", "CnvRpcRDOs")
76 
78  if RDOContainer:
79  kwargs.setdefault("RpcRdoContainer", RDOContainer)
80 
81  if flags.Input.isMC and flags.Muon.usePhaseIIGeoSetup:
82  from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
83  result.merge(NRPCCablingConfigCfg(flags))
84  from AthenaConfiguration.Enums import LHCPeriod
85  kwargs.setdefault("decode2DStrips", flags.GeoModel.Run >= LHCPeriod.Run4)
86  if not kwargs["decode2DStrips"]:
87  kwargs.setdefault("OutputContainer", "xRpcMeasurements")
88  the_tool = CompFactory.MuonR4.RpcRdoToRpcPrepDataTool(name, **kwargs)
89  result.setPrivateTools(the_tool)
90 
91  else:
92  # We need the RPC cabling to be setup
93  from MuonConfig.MuonCablingConfig import RPCLegacyCablingConfigCfg
94  result.merge(RPCLegacyCablingConfigCfg(flags))
95 
96  if not flags.Input.isMC:
97  kwargs["reduceCablingOverlap"] = True
98  kwargs["produceRpcCoinDatafromTriggerWords"] = True
99  kwargs["overlap_timeTolerance"] = 1000
100  kwargs["solvePhiAmbiguities"] = True
101  kwargs["etaphi_coincidenceTime"] = 1000
102  if not flags.Trigger.doHLT:
103  kwargs["RpcPrdContainerCacheKey"] = ""
104  kwargs["RpcCoinDataContainerCacheKey"] = ""
105 
106  from MuonConfig.MuonCondAlgConfig import RpcCondDbAlgCfg
107  result.merge(RpcCondDbAlgCfg(flags))
108  else:
109  kwargs["RPCInfoFromDb"] = False
110 
111  if not flags.Muon.enableNRPC:
112  kwargs["NrpcInputCollection"] = ""
113 
114  kwargs["xAODKey"] = "xRpcMeasurements" if flags.Muon.writexAODPRD or \
115  flags.Muon.usePhaseIIGeoSetup else ""
116 
117  #Setup RPC RDO decoder to be consistent with RPC readout settings
118  if flags.Muon.MuonTrigger:
119  kwargs["RdoDecoderTool"] = CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder", BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
120 
121  the_tool = CompFactory.Muon.RpcRdoToPrepDataToolMT(name="RpcPrepDataProviderTool",**kwargs)
122  result.setPrivateTools(the_tool)
123 
124  return result
125 
126 def RpcRDODecodeCfg(flags, name="RpcRdoToRpcPrepData", RDOContainer = None, **kwargs):
127  acc = ComponentAccumulator()
128 
129  # Conditions not needed for online
130  # Get the RDO -> PRD tool
131  kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(RpcRdoToPrepDataToolCfg(flags)))
132  # add RegSelTool
133  from RegionSelector.RegSelToolConfig import regSelTool_RPC_Cfg
134  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_RPC_Cfg(flags)))
135  kwargs.setdefault("useROBs", False)
136 
137  # Add the RDO -> PRD alorithm
138  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
139  return acc
140 
141 
142 def TgcRDODecodeCfg(flags, name="TgcRdoToTgcPrepData", RDOContainer = None, **kwargs):
143  acc = ComponentAccumulator()
144 
145  # We need the TGC cabling to be setup
146  from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
147  acc.merge(TGCCablingConfigCfg(flags))
148 
149  # Get the RDO -> PRD tool
150  tool_args = {}
151  if not flags.Trigger.doHLT:
152  tool_args.setdefault("PrdCacheString", "")
153  tool_args.setdefault("CoinCacheString", "")
154  tool_args.setdefault("xAODKey", "xTgcStrips" if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup else "")
155 
156  if RDOContainer: tool_args.setdefault("RDOContainer", RDOContainer)
157  kwargs.setdefault("DecodingTool", CompFactory.Muon.TgcRdoToPrepDataToolMT(name="TgcPrepDataProviderTool", **tool_args))
158 
159  # add RegSelTool
160  from RegionSelector.RegSelToolConfig import regSelTool_TGC_Cfg
161  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_TGC_Cfg(flags)))
162  kwargs.setdefault("useROBs", False)
163 
164 
165 
166  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
167  return acc
168 
169 def TgcPrepDataReplicationToolAllBCto3BC(flags, name = "TgcPrepDataAllBCto3BCTool", **kwargs):
170  acc = ComponentAccumulator()
171  the_tool = CompFactory.Muon.TgcPrepDataReplicationToolAllBCto3BC(name, **kwargs)
172  acc.setPrivateTools(the_tool)
173  return acc
174 
175 def TgcPrepDataAllBCto3BCCfg(flags, name="TgcPrepDataAllTo3Replicator", **kwargs):
176  acc = ComponentAccumulator()
177  kwargs.setdefault("Tool", acc.popToolsAndMerge(TgcPrepDataReplicationToolAllBCto3BC(flags)))
178  acc.addEventAlgo(CompFactory.Muon.TgcPrepDataReplicationAlg(name, **kwargs))
179  return acc
180 
181 
182 def StgcRdoToPrepDataToolCfg(flags, name="STGC_PrepDataProviderTool", **kwargs):
183  result = ComponentAccumulator()
184  kwargs.setdefault("PrdCacheKey" , MuonPrdCacheNames.sTgcCache if flags.Muon.MuonTrigger else "")
185  kwargs.setdefault("UseR4DetMgr", flags.Muon.usePhaseIIGeoSetup)
186  if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup:
187  kwargs.setdefault("xAODStripKey", "xAODsTgcStrips")
188  kwargs.setdefault("xAODWireKey", "xAODsTgcWires")
189  kwargs.setdefault("xAODPadKey", "xAODsTgcPads")
190 
191  from MuonConfig.MuonRecToolsConfig import SimpleSTgcClusterBuilderToolCfg
192  kwargs.setdefault("ClusterBuilderTool",result.popToolsAndMerge(SimpleSTgcClusterBuilderToolCfg(flags)))
193  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
194  kwargs.setdefault("NSWCalibTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
195  the_tool = CompFactory.Muon.sTgcRdoToPrepDataToolMT(name, **kwargs)
196  result.setPrivateTools(the_tool)
197  return result
198 
199 
200 def StgcRDODecodeCfg(flags, name="StgcRdoToStgcPrepData", **kwargs):
201  acc = ComponentAccumulator()
202  # Get the RDO -> PRD tool
203  kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(StgcRdoToPrepDataToolCfg(flags)))
204  # add RegSelTool
205  from RegionSelector.RegSelToolConfig import regSelTool_STGC_Cfg
206  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_STGC_Cfg(flags)))
207  kwargs.setdefault("useROBs", False)
208 
209 
210  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
211  return acc
212 
213 
214 def MMRdoToPrepDataToolCfg(flags, name="MmRdoToPrepDataTool", **kwargs):
215  result = ComponentAccumulator()
216  kwargs.setdefault("PrdCacheKey" , MuonPrdCacheNames.MmCache if flags.Trigger.doHLT else "")
217 
218  from MuonConfig.MuonRecToolsConfig import SimpleMMClusterBuilderToolCfg
219  kwargs.setdefault("ClusterBuilderTool",result.popToolsAndMerge(SimpleMMClusterBuilderToolCfg(flags)))
220  from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
221  kwargs.setdefault("NSWCalibTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
222  kwargs["xAODKey"] = "xAODMMClusters" if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup else ""
223 
224  the_tool = CompFactory.Muon.MmRdoToPrepDataToolMT(name, **kwargs)
225  result.setPrivateTools(the_tool)
226  return result
227 
228 
229 def MMRDODecodeCfg(flags, name="MM_RdoToMM_PrepData", **kwargs):
230  acc = ComponentAccumulator()
231 
232  kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(MMRdoToPrepDataToolCfg(flags)))
233  # add RegSelTool
234  from RegionSelector.RegSelToolConfig import regSelTool_MM_Cfg
235  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_MM_Cfg(flags)))
236  kwargs.setdefault("useROBs", False)
237  # Add the RDO -> PRD alorithm
238  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
239  return acc
240 
241 
242 def MdtRDODecodeCfg(flags, name="MdtRdoToMdtPrepData", RDOContainer = None, **kwargs):
243  acc = ComponentAccumulator()
244  from MuonConfig.MuonCalibrationConfig import MdtCalibrationToolCfg
245 
246  # We need the MDT cabling to be setup
247  from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg, MdtTwinTubeMapCondAlgCfg
248  acc.merge(MDTCablingConfigCfg(flags))
249  acc.merge(MdtTwinTubeMapCondAlgCfg(flags))
250 
251  tool_kwargs = {}
252  tool_kwargs["xAODKey"] = "xMdtDriftCircles" if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup else ""
253  tool_kwargs["xAODTwinKey"] = "xMdtTwinDriftCircles" if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup else ""
254 
255 
256  tool_kwargs["UseR4DetMgr"] = flags.Muon.usePhaseIIGeoSetup
257  tool_kwargs["CalibrationTool"] = acc.popToolsAndMerge(MdtCalibrationToolCfg(flags, TimeWindowSetting = 2, DoPropagationCorrection = False))
258  if RDOContainer: tool_kwargs["RDOContainer"] = RDOContainer
259  # Get the RDO -> PRD tool
260  kwargs.setdefault("DecodingTool", CompFactory.Muon.MdtRdoToPrepDataToolMT(name="MdtPrepDataProviderTool", **tool_kwargs))
261 
262  # add RegSelTool
263  from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
264  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_MDT_Cfg(flags)))
265 
266  # Add the RDO -> PRD alorithm
267  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
268  return acc
269 
270 
271 def CscRDODecodeCfg(flags, name="CscRdoToCscPrepData", RDOContainer = None, **kwargs):
272  acc = ComponentAccumulator()
273 
274  # We need the CSC cabling to be setup
275  from MuonConfig.MuonCablingConfig import CSCCablingConfigCfg # Not yet been prepared
276  acc.merge(CSCCablingConfigCfg(flags))
277 
278  from MuonConfig.MuonCondAlgConfig import CscCondDbAlgCfg
279  acc.merge(CscCondDbAlgCfg(flags))
280 
281  # Get the RDO -> PRD tool
282 
283  kwargs.setdefault("useROBs", False)
284  kwargs.setdefault("DecodingTool", CompFactory.Muon.CscRdoToCscPrepDataToolMT(name="CscPrepDataProviderTool"))
285  if RDOContainer:
286  kwargs["DecodingTool"].RDOContainer = RDOContainer
287  # add RegSelTool
288  from RegionSelector.RegSelToolConfig import regSelTool_CSC_Cfg
289  kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_CSC_Cfg(flags)))
290 
291  # Add the RDO -> PRD alorithm
292  acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
293  return acc
294 
295 
296 def CscClusterBuildCfg(flags, name="CscThresholdClusterBuilder"):
297  acc = ComponentAccumulator()
298  from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
299  from MuonConfig.MuonSegmentFindingConfig import CalibCscStripFitterCfg, QratCscClusterFitterCfg, CscAlignmentTool
300  from MuonConfig.MuonCalibrationConfig import CscCalibToolCfg
301 
302  # Get cluster creator tool
303 
304  MuonIdHelperSvc = acc.getPrimaryAndMerge( MuonIdHelperSvcCfg(flags) )
305  CalibCscStripFitter = acc.getPrimaryAndMerge( CalibCscStripFitterCfg(flags) )
306  QratCscClusterFitter = acc.getPrimaryAndMerge( QratCscClusterFitterCfg(flags) )
307  SimpleCscClusterFitter = CompFactory.SimpleCscClusterFitter(CscAlignmentTool = CscAlignmentTool(flags) )
308  CscSplitClusterFitter = CompFactory.CscSplitClusterFitter( precision_fitter = QratCscClusterFitter,
309  default_fitter = SimpleCscClusterFitter )
310  CscCalibTool = acc.getPrimaryAndMerge( CscCalibToolCfg(flags) )
311  CscThresholdClusterBuilderTool=CompFactory.CscThresholdClusterBuilderTool
312  CscClusterBuilderTool = CscThresholdClusterBuilderTool(name = "CscThresholdClusterBuilderTool" ,
313  MuonIdHelperSvc = MuonIdHelperSvc,
314  strip_fitter = CalibCscStripFitter,
315  precision_fitter = QratCscClusterFitter,
316  default_fitter = SimpleCscClusterFitter,
317  split_fitter = CscSplitClusterFitter,
318  cscCalibTool = CscCalibTool)
319 
320  #CSC cluster building
321  CscThresholdClusterBuilder=CompFactory.CscThresholdClusterBuilder
322  CscClusterBuilder = CscThresholdClusterBuilder(name = name,
323  cluster_builder = CscClusterBuilderTool,
324  MuonIdHelperSvc = MuonIdHelperSvc
325  )
326  acc.addEventAlgo(CscClusterBuilder)
327 
328  return acc
329 
330 
331 def MuonPRD_MultiTruthMakerCfg(flags, name="MuonPRD_MultiTruthMaker", **kwargs):
332  from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
333  result = ComponentAccumulator()
334  result.merge(MuonIdHelperSvcCfg(flags))
335 
336  if not flags.Detector.GeometryMDT: kwargs.setdefault("MdtPrdKey", "")
337  if not flags.Detector.GeometryRPC: kwargs.setdefault("RpcPrdKey", "")
338  if not flags.Detector.GeometryTGC: kwargs.setdefault("TgcPrdKey", "")
339  if not flags.Detector.GeometryCSC: kwargs.setdefault("CscPrdKey", "")
340 
341  if not flags.Detector.GeometrysTGC: kwargs.setdefault("sTgcPrdKey", "")
342  if not flags.Detector.GeometryMM: kwargs.setdefault("MmPrdKey", "")
343 
344  kwargs.setdefault("TgcPrdKey", 'TGC_MeasurementsAllBCs' if not flags.Muon.useTGCPriorNextBC else 'TGC_Measurements')
345  result.addEventAlgo(CompFactory.MuonPRD_MultiTruthMaker(name, **kwargs), primary = True)
346  return result
347 
348 
349 def MuonRDOtoPRDConvertorsCfg(flags):
350  # Schedule RDO conversion
351  acc = ComponentAccumulator()
352 
353  if flags.Detector.GeometryMDT:
354  acc.merge(MdtRDODecodeCfg(flags))
355 
356  if flags.Detector.GeometryRPC:
357  acc.merge(RpcRDODecodeCfg(flags))
358 
359  if flags.Detector.GeometryTGC:
360  acc.merge(TgcRDODecodeCfg(flags))
361 
362  if flags.Detector.GeometrysTGC:
363  acc.merge(StgcRDODecodeCfg(flags))
364 
365  if flags.Detector.GeometryMM:
366  acc.merge(MMRDODecodeCfg(flags))
367 
368 
369  if flags.Detector.GeometryCSC:
370  acc.merge(CscRDODecodeCfg(flags))
371  acc.merge(CscClusterBuildCfg(flags))
372 
373  if flags.Input.isMC and not flags.Muon.usePhaseIIGeoSetup:
374  acc.merge(MuonPRD_MultiTruthMakerCfg(flags))
375 
376  return acc
377 
378 
379 # This function runs the decoding on a data file
380 def muonRdoDecodeTestData( forTrigger = False ):
381  from AthenaConfiguration.AllConfigFlags import initConfigFlags
382  from AthenaConfiguration.TestDefaults import defaultConditionsTags, defaultGeometryTags, defaultTestFiles
383  flags = initConfigFlags()
384  flags.Input.Files = defaultTestFiles.RAW_RUN2
385  flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN2
386  flags.IOVDb.GlobalTag = defaultConditionsTags.RUN2_DATA
387 
388  flags.lock()
389  flags.dump()
390 
391  from AthenaCommon.Logging import log
392 
393  log.setLevel(INFO)
394  log.info('About to setup Raw data decoding')
395 
396  from AthenaConfiguration.MainServicesConfig import MainServicesCfg
397  cfg = MainServicesCfg(flags)
398 
399  # Add the MuonCache to ComponentAccumulator for trigger/RoI testing mode
400  if forTrigger:
401  # cache creators loaded independently
402  from MuonConfig.MuonBytestreamDecodeConfig import MuonCacheCfg
403  cfg.merge( MuonCacheCfg(flags) )
404 
405  if flags.Input.Format is Format.BS:
406  from MuonConfig.MuonBytestreamDecodeConfig import MuonByteStreamDecodersCfg
407  cfg.merge( MuonByteStreamDecodersCfg( flags) )
408 
409  cfg.merge( MuonRDOtoPRDConvertorsCfg( flags) )
410 
411  log.info('Print Config')
412  cfg.printConfig(withDetails=True)
413 
414  if forTrigger:
415  pklName = 'MuonRdoDecode_Cache.pkl'
416  else:
417  pklName = 'MuonRdoDecode.pkl'
418 
419  # Store config as pickle
420  log.info('Save Config')
421  with open(pklName,'wb') as f:
422  cfg.store(f)
423  f.close()
424  return cfg
425 
426 # This function runs the decoding on a MC file
427 def muonRdoDecodeTestMC():
428 
429  from AthenaConfiguration.AllConfigFlags import initConfigFlags
430  flags = initConfigFlags()
431  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"]
432 
433  flags.lock()
434  flags.dump()
435 
436  from AthenaCommon.Logging import log
437 
438  log.setLevel(DEBUG)
439  log.info('About to setup Rpc RDO data decoding')
440 
441  cfg=ComponentAccumulator()
442 
443  # We are reading a pool file for this test
444  from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
445  cfg.merge(PoolReadCfg(flags))
446 
447  # Schedule RDO conversion
448  cfg.merge( MuonRDOtoPRDConvertorsCfg( flags) )
449 
450  log.info('Print Config')
451  cfg.printConfig(withDetails=True)
452 
453  # Store config as pickle
454  log.info('Save Config')
455  with open('MuonRdoDecode.pkl','wb') as f:
456  cfg.store(f)
457  f.close()
458  return cfg
459 
460 if __name__=="__main__":
461  # To run this, do e.g.
462  # python ../athena/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
463  cfg = muonRdoDecodeTestData()
464  #muonRdoDecodeTestMC()
465 
466 
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:175
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.RpcRdoToPrepDataToolCfg
def RpcRdoToPrepDataToolCfg(flags, name="RpcRdoToRpcPrepData", RDOContainer=None, **kwargs)
This configuration function sets up everything for decoding RPC RDO to PRD conversion.
Definition: MuonRdoDecodeConfig.py:58
python.MuonRdoDecodeConfig.StgcRDODecodeCfg
def StgcRDODecodeCfg(flags, name="StgcRdoToStgcPrepData", **kwargs)
Definition: MuonRdoDecodeConfig.py:200
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:229
python.MuonCondAlgConfig.RpcCondDbAlgCfg
def RpcCondDbAlgCfg(flags, **kwargs)
Definition: MuonCondAlgConfig.py:78
python.MuonCablingConfig.TGCCablingConfigCfg
def TGCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:86
python.MuonCondAlgConfig.CscCondDbAlgCfg
def CscCondDbAlgCfg(flags, **kwargs)
Definition: MuonCondAlgConfig.py:90
python.MuonSegmentFindingConfig.QratCscClusterFitterCfg
def QratCscClusterFitterCfg(flags, **kwargs)
Definition: MuonSegmentFindingConfig.py:276
RegSelToolConfig.regSelTool_TGC_Cfg
def regSelTool_TGC_Cfg(flags)
Definition: RegSelToolConfig.py:161
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:306
CscAlignmentTool
Definition: CscAlignmentTool.h:22
python.MuonRdoDecodeConfig.CscRDODecodeCfg
def CscRDODecodeCfg(flags, name="CscRdoToCscPrepData", RDOContainer=None, **kwargs)
Definition: MuonRdoDecodeConfig.py:271
python.MuonRdoDecodeConfig.MMRdoToPrepDataToolCfg
def MMRdoToPrepDataToolCfg(flags, name="MmRdoToPrepDataTool", **kwargs)
Definition: MuonRdoDecodeConfig.py:214
python.MuonRdoDecodeConfig.TgcPrepDataReplicationToolAllBCto3BC
def TgcPrepDataReplicationToolAllBCto3BC(flags, name="TgcPrepDataAllBCto3BCTool", **kwargs)
Definition: MuonRdoDecodeConfig.py:169
python.MuonRdoDecodeConfig.RpcRDODecodeCfg
def RpcRDODecodeCfg(flags, name="RpcRdoToRpcPrepData", RDOContainer=None, **kwargs)
Definition: MuonRdoDecodeConfig.py:126
python.MuonGeometryConfig.MuonIdHelperSvcCfg
def MuonIdHelperSvcCfg(flags)
Definition: MuonGeometryConfig.py:15
python.MuonCalibrationConfig.NSWCalibToolCfg
def NSWCalibToolCfg(flags, name="NSWCalibTool", **kwargs)
Definition: MuonCalibrationConfig.py:143
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
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:331
python.MuonCablingConfig.CSCCablingConfigCfg
def CSCCablingConfigCfg(flags)
Definition: MuonCablingConfig.py:166
python.MuonRdoDecodeConfig.StgcRdoToPrepDataToolCfg
def StgcRdoToPrepDataToolCfg(flags, name="STGC_PrepDataProviderTool", **kwargs)
Definition: MuonRdoDecodeConfig.py:182
python.MuonByteStreamCnvTestConfig.NrpcDigitToNrpcRDOCfg
def NrpcDigitToNrpcRDOCfg(flags, name="NrpcDigitToNrpcRDO", **kwargs)
Definition: MuonByteStreamCnvTestConfig.py:198
python.MuonRecToolsConfig.SimpleSTgcClusterBuilderToolCfg
def SimpleSTgcClusterBuilderToolCfg(flags, name="SimpleSTgcClusterBuilderTool", **kwargs)
Definition: MuonRecToolsConfig.py:328
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:142
Trk::open
@ open
Definition: BinningType.h:40
python.MuonRdoDecodeConfig.muonRdoDecodeTestData
def muonRdoDecodeTestData(forTrigger=False)
Definition: MuonRdoDecodeConfig.py:380
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:427
python.MuonRdoDecodeConfig.MuonRDOtoPRDConvertorsCfg
def MuonRDOtoPRDConvertorsCfg(flags)
Definition: MuonRdoDecodeConfig.py:349
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:242
python.MuonRdoDecodeConfig.CscClusterBuildCfg
def CscClusterBuildCfg(flags, name="CscThresholdClusterBuilder")
Definition: MuonRdoDecodeConfig.py:296
python.MuonBytestreamDecodeConfig.MuonByteStreamDecodersCfg
def MuonByteStreamDecodersCfg(flags)
Definition: MuonBytestreamDecodeConfig.py:400
python.MuonRdoDecodeConfig.MuonPrdCacheCfg
def MuonPrdCacheCfg(flags)
This configuration function creates the IdentifiableCaches for PRD.
Definition: MuonRdoDecodeConfig.py:25
Generated on Sun Dec 22 2024 21:15:17 for ATLAS Offline Software by   doxygen 1.8.18