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