MuonRdoDecodeConfig.py

Go to the documentation of this file.

#  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 
from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
from AthenaConfiguration.ComponentFactory import CompFactory
from AthenaConfiguration.Enums import Format
from AthenaCommon.Constants import DEBUG, INFO
 

class MuonPrdCacheNames(object):
    MdtCache       = "MdtPrdCache"
    CscCache       = "CscPrdCache"
    CscStripCache  = "CscStripPrdCache"
    RpcCache       = "RpcPrdCache"
    TgcCache       = "TgcPrdCacheAllBCs"
    sTgcCache      = "sTgcPrdCache"
    MmCache        = "MmPrdCache"
    RpcCoinCache   = "RpcCoinCache"
    TgcCoinCache   = "TgcCoinCache"
 
 

def MuonPrdCacheCfg(flags):
    # Use MuonGeometryFlags to identify which configuration is being used
 
    acc = ComponentAccumulator()
    from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
    MuonIdHelperSvc = acc.getPrimaryAndMerge( MuonIdHelperSvcCfg(flags) )
    
    MuonPRDCacheCreator=CompFactory.MuonPRDCacheCreator
    cacheCreator = MuonPRDCacheCreator(CscStripCacheKey  = (MuonPrdCacheNames.CscStripCache if flags.Detector.GeometryCSC else ""),
                                       MdtCacheKey       = MuonPrdCacheNames.MdtCache,
                                       CscCacheKey       = (MuonPrdCacheNames.CscCache if flags.Detector.GeometryCSC else ""),
                                       RpcCacheKey       = MuonPrdCacheNames.RpcCache,
                                       TgcCacheKey      = MuonPrdCacheNames.TgcCache,
                                       sTgcCacheKey      = (MuonPrdCacheNames.sTgcCache if flags.Detector.GeometrysTGC else ""),
                                       MmCacheKey        = (MuonPrdCacheNames.MmCache if flags.Detector.GeometryMM else ""),
                                       TgcCoinCacheStr   = MuonPrdCacheNames.TgcCoinCache,
                                       RpcCoinCacheKey   = MuonPrdCacheNames.RpcCoinCache,
                                       MuonIdHelperSvc = MuonIdHelperSvc
                                       )
 
    acc.addEventAlgo( cacheCreator, primary=True )
    return acc
 
def MuonRdoToPrepDataAlgCfg(flags, name="MuonRdoToPrepDataAlg", **kwargs):
    result = ComponentAccumulator()
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    result.merge(MuonGeoModelCfg(flags))
    if flags.Muon.usePhaseIIGeoSetup:
        from ActsAlignmentAlgs.AlignmentAlgsConfig import ActsGeometryContextAlgCfg
        result.merge(ActsGeometryContextAlgCfg(flags))
 
    kwargs.setdefault("DoSeededDecoding", flags.Trigger.doHLT )
    the_alg = CompFactory.MuonRdoToPrepDataAlg(name, **kwargs)
    result.addEventAlgo(the_alg, primary = True)
    return result

def RpcRdoToPrepDataToolCfg(flags, suffix ="", RDOContainer = None, **kwargs):
    result = ComponentAccumulator()
    
    if flags.Muon.usePhaseIIGeoSetup and ( \
       not flags.Input.isMC or len([x for x in flags.Input.TypedCollections if x.find("RpcPadContainer#") != -1])):
       
        from MuonConfig.MuonByteStreamCnvTestConfig import RpcRdoToRpcDigitCfg, NrpcDigitToNrpcRDOCfg
       
        cnv_args = {}
        if RDOContainer: cnv_args.setdefault("RpcRdoContainer", RDOContainer)
        
        result.merge(RpcRdoToRpcDigitCfg(flags,
                                         name="RpcRdoDigitPatchAlg" + suffix,
                                         RpcDigitContainer="CnvRpcDigits",
                                         **cnv_args))
        
        result.merge(NrpcDigitToNrpcRDOCfg(flags,
                                           name="RpcBackConverterAlg" + suffix,
                                           RpcDigitContainer="CnvRpcDigits",
                                           NrpcRdoKey="CnvRpcRDOs"))
        kwargs.setdefault("RpcRdoContainer", "CnvRpcRDOs")
    
    if RDOContainer: 
        kwargs.setdefault("RpcRdoContainer", RDOContainer)
 
    if flags.Muon.usePhaseIIGeoSetup:
        from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
        result.merge(NRPCCablingConfigCfg(flags))
        from AthenaConfiguration.Enums import LHCPeriod
        kwargs.setdefault("decode2DStrips", flags.GeoModel.Run >= LHCPeriod.Run4)
        if not kwargs["decode2DStrips"]:
            kwargs.setdefault("OutputContainer", "xRpcMeasurements")
        the_tool = CompFactory.MuonR4.RpcRdoToRpcPrepDataTool(name="RpcPrepDataProviderTool", **kwargs)
        result.setPrivateTools(the_tool)
    else:
        # We need the RPC cabling to be setup
        from MuonConfig.MuonCablingConfig import RPCLegacyCablingConfigCfg
        result.merge(RPCLegacyCablingConfigCfg(flags))
 
        if not flags.Input.isMC:
            kwargs["reduceCablingOverlap"] = True
            kwargs["produceRpcCoinDatafromTriggerWords"] = True
            kwargs["overlap_timeTolerance"] = 1000
            kwargs["solvePhiAmbiguities"] = True
            kwargs["etaphi_coincidenceTime"] = 1000
        if not flags.Trigger.doHLT:
            kwargs["RpcPrdContainerCacheKey"] = ""
            kwargs["RpcCoinDataContainerCacheKey"] = ""
 
            from MuonConfig.MuonCondAlgConfig import RpcCondDbAlgCfg
            result.merge(RpcCondDbAlgCfg(flags))
        else:
            kwargs["RPCInfoFromDb"] = False
 
        if not flags.Muon.enableNRPC:
            kwargs["NrpcInputCollection"] = ""
 
 
        
        if not flags.Input.isMC and (flags.Muon.MuonTrigger or flags.Input.RunNumbers[0] >= 454434):
            kwargs["timeShift"] = 37.5
        #Setup RPC RDO decoder to be consistent with RPC readout settings
        if flags.Muon.MuonTrigger:
            kwargs["RdoDecoderTool"] = CompFactory.Muon.RpcRDO_Decoder("RpcRDO_Decoder", BCZERO=flags.Trigger.L1MuonSim.RPCNBCZ)
        
        kwargs.setdefault("isMC", flags.Input.isMC)
        the_tool =  CompFactory.Muon.RpcRdoToPrepDataToolMT(name="RpcPrepDataProviderTool",**kwargs)
        result.setPrivateTools(the_tool)
 
    return result
 
def RpcRDODecodeCfg(flags, name="MuonRpcRdoToPrdConv", RDOContainer = None, **kwargs):
    acc = ComponentAccumulator()
    
    suffix = name[name.find("_") :] if name.find("_") != -1 else ""
    # Conditions not needed for online
    # Get the RDO -> PRD tool
    kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(RpcRdoToPrepDataToolCfg(flags, suffix=suffix, RDOContainer=RDOContainer)))
    # add RegSelTool
    from RegionSelector.RegSelToolConfig import regSelTool_RPC_Cfg
    kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_RPC_Cfg(flags)))
    kwargs.setdefault("useROBs", False)
    
    # Add the RDO -> PRD alorithm
    acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
   
   
    if flags.Muon.usePhaseIIGeoSetup:
        from xAODMuonTrkPrepDataCnv.MuonPrepDataCnvCfg import xRpcToPrepDataCnvAlgCfg
        from AthenaConfiguration.Enums import LHCPeriod
        if flags.GeoModel.Run >= LHCPeriod.Run4:
            from xAODMuonViewAlgs.ViewAlgsConfig import RpcMeasViewAlgCfg
            acc.merge(RpcMeasViewAlgCfg(flags, name=f"RpcMeasViewAlg{suffix}"))
        acc.merge(xRpcToPrepDataCnvAlgCfg(flags, name=f"xAODRpcToPrepDataCnvAlg{suffix}"))
 
    return acc
 
 
def TgcRDODecodeCfg(flags, name="MuonTgcRdoToPrdConv", RDOContainer = None,  **kwargs):
    acc = ComponentAccumulator()
    suffix = name[name.find("_") :] if name.find("_") != -1 else ""
 
    # We need the TGC cabling to be setup
    from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
    acc.merge(TGCCablingConfigCfg(flags))
 
    # Get the RDO -> PRD tool
    tool_args = {}
    
    if flags.Muon.usePhaseIIGeoSetup:
        from MuonConfig.MuonByteStreamCnvTestConfig import TgcRdoToTgcDigitCfg
        acc.merge(TgcRdoToTgcDigitCfg(flags, name=f"MuonTgcRdoToDigitR4{suffix}",
                                      TgcRdoContainer = "TGCRDO" if not  RDOContainer else RDOContainer,
                                      TgcDigitContainer="TgcDigitsRdoConv"))
        kwargs.setdefault("DecodingTool", 
            CompFactory.MuonR4.TgcDigitToPrepDataCnvTool(name="TgcPrepDataProviderTool",
                                                         ReadKey="TgcDigitsRdoConv",
                                                         convertAllBCs = not flags.Muon.useTGCPriorNextBC))
        from xAODMuonTrkPrepDataCnv.MuonPrepDataCnvCfg import xTgcToPrepDataCnvAlgCfg
        acc.merge(xTgcToPrepDataCnvAlgCfg(flags, name=f"xAODTgcToPrepDataCnvAlg{suffix}"))
 
    else:
        if not flags.Trigger.doHLT:
           tool_args.setdefault("UpdateKeyPrd", "")
           tool_args.setdefault("CoinCacheString", "")
 
        if RDOContainer: 
            tool_args.setdefault("RDOContainer", RDOContainer)
            tool_args.setdefault("convertAllBCs", not flags.Muon.useTGCPriorNextBC)
        kwargs.setdefault("DecodingTool", CompFactory.Muon.TgcRdoToPrepDataToolMT(name="TgcPrepDataProviderTool", **tool_args))
 
    # add RegSelTool
    from RegionSelector.RegSelToolConfig import regSelTool_TGC_Cfg
    kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_TGC_Cfg(flags)))
    kwargs.setdefault("useROBs", False)
   
 
    
    acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
    return acc
 
def StgcRdoToPrepDataToolCfg(flags, name="STGC_PrepDataProviderTool", **kwargs):
    result = ComponentAccumulator()
    kwargs.setdefault("UseR4DetMgr", flags.Muon.usePhaseIIGeoSetup)
    if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup:
        kwargs.setdefault("xAODStripKey", "xAODsTgcStrips")
        kwargs.setdefault("xAODWireKey", "xAODsTgcWires")
        kwargs.setdefault("xAODPadKey", "xAODsTgcPads")
 
    from MuonConfig.MuonRecToolsConfig import SimpleSTgcClusterBuilderToolCfg
    kwargs.setdefault("ClusterBuilderTool",result.popToolsAndMerge(SimpleSTgcClusterBuilderToolCfg(flags)))
    from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
    kwargs.setdefault("NSWCalibTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))    
    the_tool = CompFactory.Muon.sTgcRdoToPrepDataToolMT(name, **kwargs)
    result.setPrivateTools(the_tool)
    return result
 
 
def StgcRDODecodeCfg(flags, name="MuonStgcRdoToPrdConv", **kwargs):
    acc = ComponentAccumulator()
    # Get the RDO -> PRD tool
    kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(StgcRdoToPrepDataToolCfg(flags)))
    # add RegSelTool
    from RegionSelector.RegSelToolConfig import regSelTool_STGC_Cfg
    kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_STGC_Cfg(flags)))
    kwargs.setdefault("useROBs", False)
 
 
    
    acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
    if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup:
        suffix = name[name.find("_") :] if name.find("_") != -1 else ""
        from xAODMuonViewAlgs.ViewAlgsConfig import sTgcMeasViewAlgCfg
        acc.merge(sTgcMeasViewAlgCfg(flags, name=f"sTgcMeasViewAlg{suffix}"))
 
    return acc
 
 
def MMRdoToPrepDataToolCfg(flags, name="MmRdoToPrepDataTool", **kwargs):
    result = ComponentAccumulator()
 
    from MuonConfig.MuonRecToolsConfig import SimpleMMClusterBuilderToolCfg
    kwargs.setdefault("ClusterBuilderTool",result.popToolsAndMerge(SimpleMMClusterBuilderToolCfg(flags)))
    from MuonConfig.MuonCalibrationConfig import NSWCalibToolCfg
    kwargs.setdefault("NSWCalibTool", result.popToolsAndMerge(NSWCalibToolCfg(flags)))   
    kwargs["xAODKey"] =  "xAODMMClusters" if flags.Muon.writexAODPRD or flags.Muon.usePhaseIIGeoSetup else ""
    kwargs["UseR4DetMgr"] = flags.Muon.usePhaseIIGeoSetup
    the_tool = CompFactory.Muon.MmRdoToPrepDataToolMT(name, **kwargs)
    result.setPrivateTools(the_tool)
    return result
 
 
def MMRDODecodeCfg(flags, name="MuonMmRdoToPrdConv", **kwargs):
    acc = ComponentAccumulator()
    
    kwargs.setdefault("DecodingTool", acc.popToolsAndMerge(MMRdoToPrepDataToolCfg(flags)))
    # add RegSelTool
    from RegionSelector.RegSelToolConfig import regSelTool_MM_Cfg
    kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_MM_Cfg(flags)))
    kwargs.setdefault("useROBs", False)
    # Add the RDO -> PRD alorithm
    acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
    return acc
 
 
def MdtRDODecodeCfg(flags, name="MuonMdtRdoToPrdConv", RDOContainer = None, **kwargs):
    acc = ComponentAccumulator()
    from MuonConfig.MuonCalibrationConfig import MdtCalibrationToolCfg
 
    tool_kwargs = {}
 
    # Twin tube conditions not available in COMP200.
    tool_kwargs.setdefault('UseTwin', True)
    if flags.IOVDb.DatabaseInstance == 'COMP200':
        tool_kwargs['UseTwin'] = False
 
    # We need the MDT cabling to be setup
    from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg, MdtTwinTubeMapCondAlgCfg
    acc.merge(MDTCablingConfigCfg(flags))
    if tool_kwargs['UseTwin']:
        acc.merge(MdtTwinTubeMapCondAlgCfg(flags))
 
    tool_kwargs["CalibrationTool"] = acc.popToolsAndMerge(MdtCalibrationToolCfg(flags, TimeWindowSetting = 2, 
                                                                                DoPropagationCorrection = False))
    if RDOContainer: tool_kwargs["RDOContainer"] = RDOContainer
 
    # add RegSelTool
    from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
    kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_MDT_Cfg(flags)))
    
    # Add RDO -> PRD algorithm for Phase II
    if flags.Muon.usePhaseIIGeoSetup:
        kwargs["DecodingTool"] = CompFactory.MuonR4.MdtRdoToMdtPrepDataTool(name="MdtRdoToMdtPrepDataTool", **tool_kwargs)
        acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
        suffix = name[name.find("_") :] if name.find("_") != -1 else ""
        from xAODMuonViewAlgs.ViewAlgsConfig import MdtMeasViewAlgCfg
        acc.merge(MdtMeasViewAlgCfg(flags, name=f"MdtMeasViewAlg{suffix}"))
        from xAODMuonTrkPrepDataCnv.MuonPrepDataCnvCfg import xMdtToPrepDataCnvAlgCfg
        acc.merge(xMdtToPrepDataCnvAlgCfg(flags, name=f"xAODMdtToPrepDataCnvAlg{suffix}"))
    # else, use legacy
    else: 
        kwargs.setdefault("DecodingTool", CompFactory.Muon.MdtRdoToPrepDataToolMT(name="MdtPrepDataProviderTool", **tool_kwargs))
        acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
 
    return acc
 
 
def CscRDODecodeCfg(flags, name="CscRdoToCscPrepData", RDOContainer = None, **kwargs):
    acc = ComponentAccumulator()
 
    # We need the CSC cabling to be setup
    from MuonConfig.MuonCablingConfig import CSCCablingConfigCfg # Not yet been prepared
    acc.merge(CSCCablingConfigCfg(flags))
 
    from MuonConfig.MuonCondAlgConfig import CscCondDbAlgCfg
    acc.merge(CscCondDbAlgCfg(flags))
 
    # Get the RDO -> PRD tool
    
    kwargs.setdefault("useROBs", False)
    kwargs.setdefault("DecodingTool", CompFactory.Muon.CscRdoToCscPrepDataToolMT(name="CscPrepDataProviderTool"))
    if RDOContainer:
        kwargs["DecodingTool"].RDOContainer = RDOContainer
    # add RegSelTool
    from RegionSelector.RegSelToolConfig import regSelTool_CSC_Cfg
    kwargs.setdefault("RegSelector", acc.popToolsAndMerge(regSelTool_CSC_Cfg(flags)))
 
    # Add the RDO -> PRD alorithm
    acc.merge(MuonRdoToPrepDataAlgCfg(flags, name, **kwargs))
    return acc
 
 
def CscClusterBuildCfg(flags, name="CscThresholdClusterBuilder"):
    acc = ComponentAccumulator()
    from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
    from MuonConfig.MuonSegmentFindingConfig import CalibCscStripFitterCfg, QratCscClusterFitterCfg, CscAlignmentTool
    from MuonConfig.MuonCalibrationConfig import CscCalibToolCfg
 
    # Get cluster creator tool
 
    MuonIdHelperSvc = acc.getPrimaryAndMerge( MuonIdHelperSvcCfg(flags) )
    CalibCscStripFitter = acc.getPrimaryAndMerge( CalibCscStripFitterCfg(flags) )
    QratCscClusterFitter = acc.getPrimaryAndMerge( QratCscClusterFitterCfg(flags) )
    SimpleCscClusterFitter = CompFactory.SimpleCscClusterFitter(CscAlignmentTool = CscAlignmentTool(flags) )
    CscSplitClusterFitter = CompFactory.CscSplitClusterFitter(  precision_fitter = QratCscClusterFitter, 
                                                                default_fitter = SimpleCscClusterFitter )
    CscCalibTool        = acc.getPrimaryAndMerge( CscCalibToolCfg(flags) )
    CscThresholdClusterBuilderTool=CompFactory.CscThresholdClusterBuilderTool
    CscClusterBuilderTool = CscThresholdClusterBuilderTool(name = "CscThresholdClusterBuilderTool" , 
                                                           MuonIdHelperSvc = MuonIdHelperSvc,
                                                           strip_fitter = CalibCscStripFitter,
                                                           precision_fitter = QratCscClusterFitter,
                                                           default_fitter = SimpleCscClusterFitter,
                                                           split_fitter = CscSplitClusterFitter,
                                                           cscCalibTool = CscCalibTool)
 
    #CSC cluster building
    CscThresholdClusterBuilder=CompFactory.CscThresholdClusterBuilder
    CscClusterBuilder = CscThresholdClusterBuilder(name            = name,
                                                   cluster_builder = CscClusterBuilderTool,
                                                   MuonIdHelperSvc = MuonIdHelperSvc
                                                    )
    acc.addEventAlgo(CscClusterBuilder)
 
    return acc
 
 
def MuonPRD_MultiTruthMakerCfg(flags, name="MuonPRD_MultiTruthMaker", **kwargs):
    from MuonConfig.MuonGeometryConfig import MuonIdHelperSvcCfg
    result = ComponentAccumulator()
    result.merge(MuonIdHelperSvcCfg(flags))
    
    if not flags.Detector.GeometryMDT: kwargs.setdefault("MdtPrdKey", "")
    if not flags.Detector.GeometryRPC: kwargs.setdefault("RpcPrdKey", "")
    if not flags.Detector.GeometryTGC: kwargs.setdefault("TgcPrdKey", "")
    if not flags.Detector.GeometryCSC: kwargs.setdefault("CscPrdKey", "")
 
    if not flags.Detector.GeometrysTGC: kwargs.setdefault("sTgcPrdKey", "")
    if not flags.Detector.GeometryMM: kwargs.setdefault("MmPrdKey", "")
 
    kwargs.setdefault("TgcPrdKey", 'TGC_MeasurementsAllBCs')
    result.addEventAlgo(CompFactory.MuonPRD_MultiTruthMaker(name, **kwargs), primary = True)
    return result
 
 
def MuonRDOtoPRDConvertorsCfg(flags):
    # Schedule RDO conversion
    acc = ComponentAccumulator()
 
    if flags.Detector.GeometryMDT:
        acc.merge(MdtRDODecodeCfg(flags))
 
    if flags.Detector.GeometryRPC:
        acc.merge(RpcRDODecodeCfg(flags))
 
    if flags.Detector.GeometryTGC:
        acc.merge(TgcRDODecodeCfg(flags))
 
    if flags.Detector.GeometrysTGC:
        acc.merge(StgcRDODecodeCfg(flags))
 
    if flags.Detector.GeometryMM:
        acc.merge(MMRDODecodeCfg(flags))
 
 
    if flags.Detector.GeometryCSC:
        acc.merge(CscRDODecodeCfg(flags))
        acc.merge(CscClusterBuildCfg(flags))
 
    if flags.Muon.scheduleActsReco:
        from MuonSpacePointFormation.SpacePointFormationConfig import MuonSpacePointFormationCfg 
        acc.merge(MuonSpacePointFormationCfg(flags))
 
    from AthenaConfiguration.Enums import Format
    if flags.Input.isMC and flags.Input.Format!=Format.BS:
        if not flags.Muon.usePhaseIIGeoSetup:
            acc.merge(MuonPRD_MultiTruthMakerCfg(flags))
        elif flags.Muon.setupTruthAlgorithms:
            from MuonTruthAlgsR4.MuonTruthAlgsConfig import MuonTruthAlgsCfg
            acc.merge(MuonTruthAlgsCfg(flags))
    return acc
 
 
# This function runs the decoding on a data file
def muonRdoDecodeTestData( forTrigger = False ):
    from AthenaConfiguration.AllConfigFlags import initConfigFlags
    from AthenaConfiguration.TestDefaults import defaultConditionsTags, defaultGeometryTags, defaultTestFiles
    flags = initConfigFlags()
    flags.Input.Files = defaultTestFiles.RAW_RUN2
    flags.GeoModel.AtlasVersion = defaultGeometryTags.RUN2
    flags.IOVDb.GlobalTag = defaultConditionsTags.RUN2_DATA
 
    flags.lock()
    flags.dump()
 
    from AthenaCommon.Logging import log
 
    log.setLevel(INFO)
    log.info('About to setup Raw data decoding')
 
    from AthenaConfiguration.MainServicesConfig import MainServicesCfg
    cfg = MainServicesCfg(flags)
 
    # Add the MuonCache to ComponentAccumulator for trigger/RoI testing mode
    if forTrigger:
        # cache creators loaded independently
        from MuonConfig.MuonBytestreamDecodeConfig import MuonCacheCfg
        cfg.merge( MuonCacheCfg(flags) )
 
    if flags.Input.Format is Format.BS:
        from MuonConfig.MuonBytestreamDecodeConfig import MuonByteStreamDecodersCfg
        cfg.merge( MuonByteStreamDecodersCfg( flags) )
 
    cfg.merge( MuonRDOtoPRDConvertorsCfg( flags) )
 
    log.info('Print Config')
    cfg.printConfig(withDetails=True)
 
    if forTrigger:
        pklName = 'MuonRdoDecode_Cache.pkl'
    else:
        pklName = 'MuonRdoDecode.pkl'
 
    # Store config as pickle
    log.info('Save Config')
    with open(pklName,'wb') as f:
        cfg.store(f)
        f.close()
    return cfg
 
# This function runs the decoding on a MC file
def muonRdoDecodeTestMC():
 
    from AthenaConfiguration.AllConfigFlags import initConfigFlags
    from AthenaConfiguration.TestDefaults import defaultTestFiles
    flags = initConfigFlags()
    flags.Input.Files = defaultTestFiles.RDO_RUN3
 
    flags.lock()
    flags.dump()
 
    from AthenaCommon.Logging import log
 
    log.setLevel(DEBUG)
    log.info('About to setup Rpc RDO data decoding')
 
    cfg=ComponentAccumulator()
 
    # We are reading a pool file for this test
    from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
    cfg.merge(PoolReadCfg(flags))
 
    # Schedule RDO conversion
    cfg.merge( MuonRDOtoPRDConvertorsCfg( flags) )
 
    log.info('Print Config')
    cfg.printConfig(withDetails=True)
 
    # Store config as pickle
    log.info('Save Config')
    with open('MuonRdoDecode.pkl','wb') as f:
        cfg.store(f)
        f.close()
    return cfg
 
if __name__=="__main__":
    # To run this, do e.g.
    # python ../athena/MuonSpectrometer/MuonConfig/python/MuonRdoDecodeConfig.py
    cfg = muonRdoDecodeTestData()
    #muonRdoDecodeTestMC()