ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Functions | Variables
MuonRdoDecodeConfig Namespace Reference

Classes

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

Functions

 MuonPrdCacheCfg (flags)
 This configuration function creates the IdentifiableCaches for PRD.
 MuonRdoToPrepDataAlgCfg (flags, name="MuonRdoToPrepDataAlg", **kwargs)
 RpcRdoToPrepDataToolCfg (flags, suffix="", RDOContainer=None, **kwargs)
 This configuration function sets up everything for decoding RPC RDO to PRD conversion.
 RpcRDODecodeCfg (flags, name="MuonRpcRdoToPrdConv", RDOContainer=None, **kwargs)
 TgcRDODecodeCfg (flags, name="MuonTgcRdoToPrdConv", RDOContainer=None, **kwargs)
 StgcRdoToPrepDataToolCfg (flags, name="STGC_PrepDataProviderTool", **kwargs)
 StgcRDODecodeCfg (flags, name="MuonStgcRdoToPrdConv", **kwargs)
 MMRdoToPrepDataToolCfg (flags, name="MmRdoToPrepDataTool", **kwargs)
 MMRDODecodeCfg (flags, name="MuonMmRdoToPrdConv", **kwargs)
 MdtRDODecodeCfg (flags, name="MuonMdtRdoToPrdConv", RDOContainer=None, **kwargs)
 CscRDODecodeCfg (flags, name="CscRdoToCscPrepData", RDOContainer=None, **kwargs)
 CscClusterBuildCfg (flags, name="CscThresholdClusterBuilder")
 MuonPRD_MultiTruthMakerCfg (flags, name="MuonPRD_MultiTruthMaker", **kwargs)
 MuonRDOtoPRDConvertorsCfg (flags)
 muonRdoDecodeTestData (forTrigger=False)
 muonRdoDecodeTestMC ()

Variables

 cfg = muonRdoDecodeTestData()

Function Documentation

◆ CscClusterBuildCfg()

CscClusterBuildCfg ( flags,
name = "CscThresholdClusterBuilder" )

Definition at line 344 of file MuonRdoDecodeConfig.py.

344def CscClusterBuildCfg(flags, name="CscThresholdClusterBuilder"):
345 acc = ComponentAccumulator()
346 from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
347 from MuonConfig.MuonSegmentFindingConfig import CalibCscStripFitterCfg, QratCscClusterFitterCfg, CscAlignmentTool
348 from MuonConfig.MuonCalibrationConfig import CscCalibToolCfg
349
350 # Get cluster creator tool
351
352 MuonIdHelperSvc = acc.getPrimaryAndMerge( MuonIdHelperSvcCfg(flags) )
353 CalibCscStripFitter = acc.getPrimaryAndMerge( CalibCscStripFitterCfg(flags) )
354 QratCscClusterFitter = acc.getPrimaryAndMerge( QratCscClusterFitterCfg(flags) )
355 SimpleCscClusterFitter = CompFactory.SimpleCscClusterFitter(CscAlignmentTool = CscAlignmentTool(flags) )
356 CscSplitClusterFitter = CompFactory.CscSplitClusterFitter( precision_fitter = QratCscClusterFitter,
357 default_fitter = SimpleCscClusterFitter )
358 CscCalibTool = acc.getPrimaryAndMerge( CscCalibToolCfg(flags) )
359 CscThresholdClusterBuilderTool=CompFactory.CscThresholdClusterBuilderTool
360 CscClusterBuilderTool = CscThresholdClusterBuilderTool(name = "CscThresholdClusterBuilderTool" ,
361 MuonIdHelperSvc = MuonIdHelperSvc,
362 strip_fitter = CalibCscStripFitter,
363 precision_fitter = QratCscClusterFitter,
364 default_fitter = SimpleCscClusterFitter,
365 split_fitter = CscSplitClusterFitter,
366 cscCalibTool = CscCalibTool)
367
368 #CSC cluster building
369 CscThresholdClusterBuilder=CompFactory.CscThresholdClusterBuilder
370 CscClusterBuilder = CscThresholdClusterBuilder(name = name,
371 cluster_builder = CscClusterBuilderTool,
372 MuonIdHelperSvc = MuonIdHelperSvc
373 )
374 acc.addEventAlgo(CscClusterBuilder)
375
376 return acc
377
378

◆ CscRDODecodeCfg()

CscRDODecodeCfg ( flags,
name = "CscRdoToCscPrepData",
RDOContainer = None,
** kwargs )

Definition at line 319 of file MuonRdoDecodeConfig.py.

319def CscRDODecodeCfg(flags, name="CscRdoToCscPrepData", RDOContainer = None, **kwargs):
320 acc = ComponentAccumulator()
321
322 # We need the CSC cabling to be setup
323 from MuonConfig.MuonCablingConfig import CSCCablingConfigCfg # Not yet been prepared
324 acc.merge(CSCCablingConfigCfg(flags))
325
326 from MuonConfig.MuonCondAlgConfig import CscCondDbAlgCfg
327 acc.merge(CscCondDbAlgCfg(flags))
328
329 # Get the RDO -> PRD tool
330
331 kwargs.setdefault("useROBs", False)
332 kwargs.setdefault("DecodingTool", CompFactory.Muon.CscRdoToCscPrepDataToolMT(name="CscPrepDataProviderTool"))
333 if RDOContainer:
334 kwargs["DecodingTool"].RDOContainer = RDOContainer
335 # add RegSelTool
336 from RegionSelector.RegSelToolConfig import regSelTool_CSC_Cfg
337 kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_CSC_Cfg(flags)))
338
339 # Add the RDO -> PRD alorithm
340 acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
341 return acc
342
343

◆ MdtRDODecodeCfg()

MdtRDODecodeCfg ( flags,
name = "MuonMdtRdoToPrdConv",
RDOContainer = None,
** kwargs )

Definition at line 277 of file MuonRdoDecodeConfig.py.

277def MdtRDODecodeCfg(flags, name="MuonMdtRdoToPrdConv", RDOContainer = None, **kwargs):
278 acc = ComponentAccumulator()
279 from MuonConfig.MuonCalibrationConfig import MdtCalibrationToolCfg
280
281 tool_kwargs = {}
282
283 # Twin tube conditions not available in COMP200.
284 tool_kwargs.setdefault('UseTwin', True)
285 if flags.IOVDb.DatabaseInstance == 'COMP200':
286 tool_kwargs['UseTwin'] = False
287
288 # We need the MDT cabling to be setup
289 from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg, MdtTwinTubeMapCondAlgCfg
290 acc.merge(MDTCablingConfigCfg(flags))
291 if tool_kwargs['UseTwin']:
292 acc.merge(MdtTwinTubeMapCondAlgCfg(flags))
293
294 tool_kwargs["CalibrationTool"] = acc.popToolsAndMerge(MdtCalibrationToolCfg(flags, TimeWindowSetting = 2,
295 DoPropagationCorrection = False))
296 if RDOContainer: tool_kwargs["RDOContainer"] = RDOContainer
297
298 # add RegSelTool
299 from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
300 kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_MDT_Cfg(flags)))
301
302 # Add RDO -> PRD algorithm for Phase II
303 if flags.Muon.usePhaseIIGeoSetup:
304 kwargs["DecodingTool"] = CompFactory.MuonR4.MdtRdoToMdtPrepDataTool(name="MdtRdoToMdtPrepDataTool", **tool_kwargs)
305 acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
306 suffix = name[name.find("_") :] if name.find("_") != -1 else ""
307 from xAODMuonViewAlgs.ViewAlgsConfig import MdtMeasViewAlgCfg
308 acc.merge(MdtMeasViewAlgCfg(flags, name=f"MdtMeasViewAlg{suffix}"))
309 from xAODMuonTrkPrepDataCnv.MuonPrepDataCnvCfg import xMdtToPrepDataCnvAlgCfg
310 acc.merge(xMdtToPrepDataCnvAlgCfg(flags, name=f"xAODMdtToPrepDataCnvAlg{suffix}"))
311 # else, use legacy
312 else:
313 kwargs.setdefault("DecodingTool", CompFactory.Muon.MdtRdoToPrepDataToolMT(name="MdtPrepDataProviderTool", **tool_kwargs))
314 acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
315
316 return acc
317
318

◆ MMRDODecodeCfg()

MMRDODecodeCfg ( flags,
name = "MuonMmRdoToPrdConv",
** kwargs )

Definition at line 264 of file MuonRdoDecodeConfig.py.

264def MMRDODecodeCfg(flags, name="MuonMmRdoToPrdConv", **kwargs):
265 acc = ComponentAccumulator()
266
267 kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(MMRdoToPrepDataToolCfg(flags)))
268 # add RegSelTool
269 from RegionSelector.RegSelToolConfig import regSelTool_MM_Cfg
270 kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_MM_Cfg(flags)))
271 kwargs.setdefault("useROBs", False)
272 # Add the RDO -> PRD alorithm
273 acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
274 return acc
275
276

◆ MMRdoToPrepDataToolCfg()

MMRdoToPrepDataToolCfg ( flags,
name = "MmRdoToPrepDataTool",
** kwargs )

Definition at line 249 of file MuonRdoDecodeConfig.py.

249def MMRdoToPrepDataToolCfg(flags, name="MmRdoToPrepDataTool", **kwargs):
250 result = ComponentAccumulator()
251 kwargs.setdefault("PrdCacheKey" , MuonPrdCacheNames.MmCache if flags.Trigger.doHLT else "")
252
253 from MuonConfig.MuonRecToolsConfig import SimpleMMClusterBuilderToolCfg
254 kwargs.setdefault("ClusterBuilderTool",result.popToolsAndMerge(SimpleMMClusterBuilderToolCfg(flags)))
255 from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
256 kwargs.setdefault("NSWCalibTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
257 kwargs["xAODKey"] = "xAODMMClusters" if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup else ""
258 kwargs["UseR4DetMgr"] = flags.Muon.usePhaseIIGeoSetup
259 the_tool = CompFactory.Muon.MmRdoToPrepDataToolMT(name, **kwargs)
260 result.setPrivateTools(the_tool)
261 return result
262
263

◆ MuonPRD_MultiTruthMakerCfg()

MuonPRD_MultiTruthMakerCfg ( flags,
name = "MuonPRD_MultiTruthMaker",
** kwargs )

Definition at line 379 of file MuonRdoDecodeConfig.py.

379def MuonPRD_MultiTruthMakerCfg(flags, name="MuonPRD_MultiTruthMaker", **kwargs):
380 from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
381 result = ComponentAccumulator()
382 result.merge(MuonIdHelperSvcCfg(flags))
383
384 if not flags.Detector.GeometryMDT: kwargs.setdefault("MdtPrdKey", "")
385 if not flags.Detector.GeometryRPC: kwargs.setdefault("RpcPrdKey", "")
386 if not flags.Detector.GeometryTGC: kwargs.setdefault("TgcPrdKey", "")
387 if not flags.Detector.GeometryCSC: kwargs.setdefault("CscPrdKey", "")
388
389 if not flags.Detector.GeometrysTGC: kwargs.setdefault("sTgcPrdKey", "")
390 if not flags.Detector.GeometryMM: kwargs.setdefault("MmPrdKey", "")
391
392 kwargs.setdefault("TgcPrdKey", 'TGC_MeasurementsAllBCs')
393 result.addEventAlgo(CompFactory.MuonPRD_MultiTruthMaker(name, **kwargs), primary = True)
394 return result
395
396

◆ MuonPrdCacheCfg()

MuonPrdCacheCfg ( flags)

This configuration function creates the IdentifiableCaches for PRD.

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 25 of file MuonRdoDecodeConfig.py.

25def MuonPrdCacheCfg(flags):
26 # Use MuonGeometryFlags to identify which configuration is being used
27
28 acc = ComponentAccumulator()
29 from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
30 MuonIdHelperSvc = acc.getPrimaryAndMerge( MuonIdHelperSvcCfg(flags) )
31
32 MuonPRDCacheCreator=CompFactory.MuonPRDCacheCreator
33 cacheCreator = MuonPRDCacheCreator(CscStripCacheKey = (MuonPrdCacheNames.CscStripCache if flags.Detector.GeometryCSC else ""),
34 MdtCacheKey = MuonPrdCacheNames.MdtCache,
35 CscCacheKey = (MuonPrdCacheNames.CscCache if flags.Detector.GeometryCSC else ""),
36 RpcCacheKey = MuonPrdCacheNames.RpcCache,
37 TgcCacheKey = MuonPrdCacheNames.TgcCache,
38 sTgcCacheKey = (MuonPrdCacheNames.sTgcCache if flags.Detector.GeometrysTGC else ""),
39 MmCacheKey = (MuonPrdCacheNames.MmCache if flags.Detector.GeometryMM else ""),
40 TgcCoinCacheStr = MuonPrdCacheNames.TgcCoinCache,
41 RpcCoinCacheKey = MuonPrdCacheNames.RpcCoinCache,
42 MuonIdHelperSvc = MuonIdHelperSvc
43 )
44
45 acc.addEventAlgo( cacheCreator, primary=True )
46 return acc
47

◆ muonRdoDecodeTestData()

muonRdoDecodeTestData ( forTrigger = False)

Definition at line 436 of file MuonRdoDecodeConfig.py.

436def muonRdoDecodeTestData( forTrigger = False ):
437 from AthenaConfiguration.AllConfigFlags import initConfigFlags
438 from AthenaConfiguration.TestDefaults import defaultConditionsTags, defaultGeometryTags, defaultTestFiles
439 flags = initConfigFlags()
440 flags.Input.Files = defaultTestFiles.RAW_RUN2
441 flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN2
442 flags.IOVDb.GlobalTag = defaultConditionsTags.RUN2_DATA
443
444 flags.lock()
445 flags.dump()
446
447 from AthenaCommon.Logging import log
448
449 log.setLevel(INFO)
450 log.info('About to setup Raw data decoding')
451
452 from AthenaConfiguration.MainServicesConfig import MainServicesCfg
453 cfg = MainServicesCfg(flags)
454
455 # Add the MuonCache to ComponentAccumulator for trigger/RoI testing mode
456 if forTrigger:
457 # cache creators loaded independently
458 from MuonConfig.MuonBytestreamDecodeConfig import MuonCacheCfg
459 cfg.merge( MuonCacheCfg(flags) )
460
461 if flags.Input.Format is Format.BS:
462 from MuonConfig.MuonBytestreamDecodeConfig import MuonByteStreamDecodersCfg
463 cfg.merge( MuonByteStreamDecodersCfg( flags) )
464
465 cfg.merge( MuonRDOtoPRDConvertorsCfg( flags) )
466
467 log.info('Print Config')
468 cfg.printConfig(withDetails=True)
469
470 if forTrigger:
471 pklName = 'MuonRdoDecode_Cache.pkl'
472 else:
473 pklName = 'MuonRdoDecode.pkl'
474
475 # Store config as pickle
476 log.info('Save Config')
477 with open(pklName,'wb') as f:
478 cfg.store(f)
479 f.close()
480 return cfg
481
482# This function runs the decoding on a MC file

◆ muonRdoDecodeTestMC()

muonRdoDecodeTestMC ( )

Definition at line 483 of file MuonRdoDecodeConfig.py.

483def muonRdoDecodeTestMC():
484
485 from AthenaConfiguration.AllConfigFlags import initConfigFlags
486 from AthenaConfiguration.TestDefaults import defaultTestFiles
487 flags = initConfigFlags()
488 flags.Input.Files = defaultTestFiles.RDO_RUN3
489
490 flags.lock()
491 flags.dump()
492
493 from AthenaCommon.Logging import log
494
495 log.setLevel(DEBUG)
496 log.info('About to setup Rpc RDO data decoding')
497
498 cfg=ComponentAccumulator()
499
500 # We are reading a pool file for this test
501 from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
502 cfg.merge(PoolReadCfg(flags))
503
504 # Schedule RDO conversion
505 cfg.merge( MuonRDOtoPRDConvertorsCfg( flags) )
506
507 log.info('Print Config')
508 cfg.printConfig(withDetails=True)
509
510 # Store config as pickle
511 log.info('Save Config')
512 with open('MuonRdoDecode.pkl','wb') as f:
513 cfg.store(f)
514 f.close()
515 return cfg
516

◆ MuonRDOtoPRDConvertorsCfg()

MuonRDOtoPRDConvertorsCfg ( flags)

Definition at line 397 of file MuonRdoDecodeConfig.py.

397def MuonRDOtoPRDConvertorsCfg(flags):
398 # Schedule RDO conversion
399 acc = ComponentAccumulator()
400
401 if flags.Detector.GeometryMDT:
402 acc.merge(MdtRDODecodeCfg(flags))
403
404 if flags.Detector.GeometryRPC:
405 acc.merge(RpcRDODecodeCfg(flags))
406
407 if flags.Detector.GeometryTGC:
408 acc.merge(TgcRDODecodeCfg(flags))
409
410 if flags.Detector.GeometrysTGC:
411 acc.merge(StgcRDODecodeCfg(flags))
412
413 if flags.Detector.GeometryMM:
414 acc.merge(MMRDODecodeCfg(flags))
415
416
417 if flags.Detector.GeometryCSC:
418 acc.merge(CscRDODecodeCfg(flags))
419 acc.merge(CscClusterBuildCfg(flags))
420
421 if flags.Muon.scheduleActsReco:
422 from MuonSpacePointFormation.SpacePointFormationConfig import MuonSpacePointFormationCfg
423 acc.merge(MuonSpacePointFormationCfg(flags))
424
425 from AthenaConfiguration.Enums import Format
426 if flags.Input.isMC and flags.Input.Format!=Format.BS:
427 if not flags.Muon.usePhaseIIGeoSetup:
428 acc.merge(MuonPRD_MultiTruthMakerCfg(flags))
429 elif flags.Muon.setupTruthAlgorithms:
430 from MuonTruthAlgsR4.MuonTruthAlgsConfig import MuonTruthAlgsCfg
431 acc.merge(MuonTruthAlgsCfg(flags))
432 return acc
433
434
435# This function runs the decoding on a data file

◆ MuonRdoToPrepDataAlgCfg()

MuonRdoToPrepDataAlgCfg ( flags,
name = "MuonRdoToPrepDataAlg",
** kwargs )

Definition at line 48 of file MuonRdoDecodeConfig.py.

48def MuonRdoToPrepDataAlgCfg(flags, name="MuonRdoToPrepDataAlg", **kwargs):
49 result = ComponentAccumulator()
50 # Make sure muon geometry is configured
51 from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
52 result.merge(MuonGeoModelCfg(flags))
53 if flags.Muon.usePhaseIIGeoSetup:
54 from ActsAlignmentAlgs.AlignmentAlgsConfig import ActsGeometryContextAlgCfg
55 result.merge(ActsGeometryContextAlgCfg(flags))
56
57 kwargs.setdefault("DoSeededDecoding", flags.Trigger.doHLT )
58 the_alg = CompFactory.MuonRdoToPrepDataAlg(name, **kwargs)
59 result.addEventAlgo(the_alg, primary = True)
60 return result

◆ RpcRDODecodeCfg()

RpcRDODecodeCfg ( flags,
name = "MuonRpcRdoToPrdConv",
RDOContainer = None,
** kwargs )

Definition at line 141 of file MuonRdoDecodeConfig.py.

141def RpcRDODecodeCfg(flags, name="MuonRpcRdoToPrdConv", RDOContainer = None, **kwargs):
142 acc = ComponentAccumulator()
143
144 suffix = name[name.find("_") :] if name.find("_") != -1 else ""
145 # Conditions not needed for online
146 # Get the RDO -> PRD tool
147 kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(RpcRdoToPrepDataToolCfg(flags, suffix=suffix, RDOContainer=RDOContainer)))
148 # add RegSelTool
149 from RegionSelector.RegSelToolConfig import regSelTool_RPC_Cfg
150 kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_RPC_Cfg(flags)))
151 kwargs.setdefault("useROBs", False)
152
153 # Add the RDO -> PRD alorithm
154 acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
155
156
157 if flags.Muon.usePhaseIIGeoSetup:
158 from xAODMuonTrkPrepDataCnv.MuonPrepDataCnvCfg import xRpcToPrepDataCnvAlgCfg
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 acc.merge(xRpcToPrepDataCnvAlgCfg(flags, name=f"xAODRpcToPrepDataCnvAlg{suffix}"))
164
165 return acc
166
167

◆ RpcRdoToPrepDataToolCfg()

RpcRdoToPrepDataToolCfg ( flags,
suffix = "",
RDOContainer = None,
** kwargs )

This configuration function sets up everything for decoding RPC RDO to PRD conversion.

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

Definition at line 64 of file MuonRdoDecodeConfig.py.

64def RpcRdoToPrepDataToolCfg(flags, suffix ="", RDOContainer = None, **kwargs):
65 result = ComponentAccumulator()
66
68 if flags.Muon.usePhaseIIGeoSetup and ( \
69 not flags.Input.isMC or len([x for x in flags.Input.TypedCollections if x.find("RpcPadContainer#") != -1])):
70
71 from MuonConfig.MuonByteStreamCnvTestConfig import RpcRdoToRpcDigitCfg, NrpcDigitToNrpcRDOCfg
72
73 cnv_args = {}
74 if RDOContainer: cnv_args.setdefault("RpcRdoContainer", RDOContainer)
75
76 result.merge(RpcRdoToRpcDigitCfg(flags,
77 name="RpcRdoDigitPatchAlg" + suffix,
78 RpcDigitContainer="CnvRpcDigits",
79 **cnv_args))
80
81 result.merge(NrpcDigitToNrpcRDOCfg(flags,
82 name="RpcBackConverterAlg" + suffix,
83 RpcDigitContainer="CnvRpcDigits",
84 NrpcRdoKey="CnvRpcRDOs"))
85 kwargs.setdefault("RpcRdoContainer", "CnvRpcRDOs")
86
88 if RDOContainer:
89 kwargs.setdefault("RpcRdoContainer", RDOContainer)
90
91 if flags.Muon.usePhaseIIGeoSetup:
92 from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
93 result.merge(NRPCCablingConfigCfg(flags))
94 from AthenaConfiguration.Enums import LHCPeriod
95 kwargs.setdefault("decode2DStrips", flags.GeoModel.Run >= LHCPeriod.Run4)
96 if not kwargs["decode2DStrips"]:
97 kwargs.setdefault("OutputContainer", "xRpcMeasurements")
98 the_tool = CompFactory.MuonR4.RpcRdoToRpcPrepDataTool(name="RpcPrepDataProviderTool", **kwargs)
99 result.setPrivateTools(the_tool)
100 else:
101 # We need the RPC cabling to be setup
102 from MuonConfig.MuonCablingConfig import RPCLegacyCablingConfigCfg
103 result.merge(RPCLegacyCablingConfigCfg(flags))
104
105 if not flags.Input.isMC:
106 kwargs["reduceCablingOverlap"] = True
107 kwargs["produceRpcCoinDatafromTriggerWords"] = True
108 kwargs["overlap_timeTolerance"] = 1000
109 kwargs["solvePhiAmbiguities"] = True
110 kwargs["etaphi_coincidenceTime"] = 1000
111 if not flags.Trigger.doHLT:
112 kwargs["RpcPrdContainerCacheKey"] = ""
113 kwargs["RpcCoinDataContainerCacheKey"] = ""
114
115 from MuonConfig.MuonCondAlgConfig import RpcCondDbAlgCfg
116 result.merge(RpcCondDbAlgCfg(flags))
117 else:
118 kwargs["RPCInfoFromDb"] = False
119
120 if not flags.Muon.enableNRPC:
121 kwargs["NrpcInputCollection"] = ""
122
123
124
129 if not flags.Input.isMC and (flags.Muon.MuonTrigger or flags.Input.RunNumbers[0] >= 454434):
130 kwargs["timeShift"] = 37.5
131 #Setup RPC RDO decoder to be consistent with RPC readout settings
132 if flags.Muon.MuonTrigger:
133 kwargs["RdoDecoderTool"] = CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder", BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
134
135 kwargs.setdefault("isMC", flags.Input.isMC)
136 the_tool = CompFactory.Muon.RpcRdoToPrepDataToolMT(name="RpcPrepDataProviderTool",**kwargs)
137 result.setPrivateTools(the_tool)
138
139 return result
140

◆ StgcRDODecodeCfg()

StgcRDODecodeCfg ( flags,
name = "MuonStgcRdoToPrdConv",
** kwargs )

Definition at line 229 of file MuonRdoDecodeConfig.py.

229def StgcRDODecodeCfg(flags, name="MuonStgcRdoToPrdConv", **kwargs):
230 acc = ComponentAccumulator()
231 # Get the RDO -> PRD tool
232 kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(StgcRdoToPrepDataToolCfg(flags)))
233 # add RegSelTool
234 from RegionSelector.RegSelToolConfig import regSelTool_STGC_Cfg
235 kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_STGC_Cfg(flags)))
236 kwargs.setdefault("useROBs", False)
237
238
239
240 acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
241 if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup:
242 suffix = name[name.find("_") :] if name.find("_") != -1 else ""
243 from xAODMuonViewAlgs.ViewAlgsConfig import sTgcMeasViewAlgCfg
244 acc.merge(sTgcMeasViewAlgCfg(flags, name=f"sTgcMeasViewAlg{suffix}"))
245
246 return acc
247
248

◆ StgcRdoToPrepDataToolCfg()

StgcRdoToPrepDataToolCfg ( flags,
name = "STGC_PrepDataProviderTool",
** kwargs )

Definition at line 211 of file MuonRdoDecodeConfig.py.

211def StgcRdoToPrepDataToolCfg(flags, name="STGC_PrepDataProviderTool", **kwargs):
212 result = ComponentAccumulator()
213 kwargs.setdefault("PrdCacheKey" , MuonPrdCacheNames.sTgcCache if flags.Muon.MuonTrigger else "")
214 kwargs.setdefault("UseR4DetMgr", flags.Muon.usePhaseIIGeoSetup)
215 if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup:
216 kwargs.setdefault("xAODStripKey", "xAODsTgcStrips")
217 kwargs.setdefault("xAODWireKey", "xAODsTgcWires")
218 kwargs.setdefault("xAODPadKey", "xAODsTgcPads")
219
220 from MuonConfig.MuonRecToolsConfig import SimpleSTgcClusterBuilderToolCfg
221 kwargs.setdefault("ClusterBuilderTool",result.popToolsAndMerge(SimpleSTgcClusterBuilderToolCfg(flags)))
222 from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
223 kwargs.setdefault("NSWCalibTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))
224 the_tool = CompFactory.Muon.sTgcRdoToPrepDataToolMT(name, **kwargs)
225 result.setPrivateTools(the_tool)
226 return result
227
228

◆ TgcRDODecodeCfg()

TgcRDODecodeCfg ( flags,
name = "MuonTgcRdoToPrdConv",
RDOContainer = None,
** kwargs )

Definition at line 168 of file MuonRdoDecodeConfig.py.

168def TgcRDODecodeCfg(flags, name="MuonTgcRdoToPrdConv", RDOContainer = None, **kwargs):
169 acc = ComponentAccumulator()
170 suffix = name[name.find("_") :] if name.find("_") != -1 else ""
171
172 # We need the TGC cabling to be setup
173 from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
174 acc.merge(TGCCablingConfigCfg(flags))
175
176 # Get the RDO -> PRD tool
177 tool_args = {}
178
179 if flags.Muon.usePhaseIIGeoSetup:
180 from MuonConfig.MuonByteStreamCnvTestConfig import TgcRdoToTgcDigitCfg
181 acc.merge(TgcRdoToTgcDigitCfg(flags, name=f"MuonTgcRdoToDigitR4{suffix}",
182 TgcRdoContainer = "TGCRDO" if not RDOContainer else RDOContainer,
183 TgcDigitContainer="TgcDigitsRdoConv"))
184 kwargs.setdefault("DecodingTool",
185 CompFactory.MuonR4.TgcDigitToPrepDataCnvTool(name="TgcPrepDataProviderTool",
186 ReadKey="TgcDigitsRdoConv",
187 convertAllBCs = not flags.Muon.useTGCPriorNextBC))
188 from xAODMuonTrkPrepDataCnv.MuonPrepDataCnvCfg import xTgcToPrepDataCnvAlgCfg
189 acc.merge(xTgcToPrepDataCnvAlgCfg(flags, name=f"xAODTgcToPrepDataCnvAlg{suffix}"))
190
191 else:
192 if not flags.Trigger.doHLT:
193 tool_args.setdefault("UpdateKeyPrd", "")
194 tool_args.setdefault("CoinCacheString", "")
195
196 if RDOContainer:
197 tool_args.setdefault("RDOContainer", RDOContainer)
198 tool_args.setdefault("convertAllBCs", not flags.Muon.useTGCPriorNextBC)
199 kwargs.setdefault("DecodingTool", CompFactory.Muon.TgcRdoToPrepDataToolMT(name="TgcPrepDataProviderTool", **tool_args))
200
201 # add RegSelTool
202 from RegionSelector.RegSelToolConfig import regSelTool_TGC_Cfg
203 kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_TGC_Cfg(flags)))
204 kwargs.setdefault("useROBs", False)
205
206
207
208 acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
209 return acc
210

Variable Documentation

◆ cfg

MuonRdoDecodeConfig.cfg = muonRdoDecodeTestData()

Definition at line 520 of file MuonRdoDecodeConfig.py.

Generated on for ATLAS Offline Software by doxygen 1.17.0