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

Functions
	MuonCacheCfg (flags)
	This configuration function creates the IdentifiableCaches for RDO.
	RpcBytestreamDecodeCfg (flags, name="RpcRawDataProvider", **kwargs)
	This configuration function sets up everything for decoding RPC bytestream data into RDOs.
	NrpcBytestreamDecodeCfg (flags, name="NrpcRawDataProvider", **kwargs)
	TgcBytestreamDecodeCfg (flags, name="TgcRawDataProvider", **kwargs)
	MdtBytestreamDecodeCfg (flags, name="MdtRawDataProvider", **kwargs)
	CscBytestreamDecodeCfg (flags, name="CscRawDataProvider", **kwargs)
	sTgcRODDecoderCfg (flags, name="sTgcROD_Decoder", **kwargs)
	sTgcBytestreamDecodeCfg (flags, name="sTgcRawDataProvider", **kwargs)
	NswTrigProcessorRodDecoderCfg (flags, name="NswTrigProcessorDecoder", **kwargs)
	NswTrigProcessorRawDataProviderToolCfg (flags, name="NswTrigProcessorRawDataTool", **kwargs)
	NswTrigProcByteStreamDecodeCfg (flags, name="NswProcByteStream")
	sTgcPadTriggerBytestreamDecodeCfg (flags, name="sTgcPadTriggerRawDataProvider", **kwargs)
	MmRDODDecoderCfg (flags, name="MmROD_Decoder", **kwargs)
	MmBytestreamDecodeCfg (flags, name="MmRawDataProvider", **kwargs)
	NswMMTPRodDecoderCfg (flags, name="NswMMTPRodDecoder", **kwargs)
	NswMMTPRawDataProviderToolCfg (flags, name="NswMMTPRawDataProviderTool", **kwargs)
	NswMMTPByteStreamDecodeCfg (flags, name="NswMMTPByteStreamDecode", **kwargs)
	MuonByteStreamDecodersCfg (flags)

Variables
	flags = initConfigFlags()
	Files
	GlobalTag
	AtlasVersion
	NumThreads
	MaxEvents
	args = flags.fillFromArgs()
	cfg = MainServicesCfg(flags)
	withDetails

Function Documentation

◆ CscBytestreamDecodeCfg()

MuonBytestreamDecodeConfig.CscBytestreamDecodeCfg	(		flags,
			name = "CscRawDataProvider",
		**	kwargs )

Definition at line 182 of file MuonBytestreamDecodeConfig.py.

def CscBytestreamDecodeCfg(flags, name="CscRawDataProvider", **kwargs):
    acc = ComponentAccumulator()
 
    # We need the CSC cabling to be setup
    from MuonConfig.MuonCablingConfig import CSCCablingConfigCfg # Not yet been prepared
    acc.merge( CSCCablingConfigCfg(flags) )
 
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags)) 
 
    # Setup the CSC ROD decoder
    Muon__CscROD_Decoder=CompFactory.Muon.CscROD_Decoder
    CSCRodDecoder = Muon__CscROD_Decoder(name        = "CscROD_Decoder" )
 
 
    # Setup the RAW data provider tool
    keyName = f"{flags.Overlay.BkgPrefix}CSCRDO" if flags.Overlay.ByteStream else "CSCRDO"
    Muon__CSC_RawDataProviderToolMT=CompFactory.Muon.CSC_RawDataProviderToolMT
    MuonCscRawDataProviderTool = Muon__CSC_RawDataProviderToolMT(name    = "CSC_RawDataProviderToolMT",
                                                                 Decoder = CSCRodDecoder,
                                                                 RdoLocation = keyName)
    if flags.Muon.MuonTrigger:
        MuonCscRawDataProviderTool.CscContainerCacheKey = MuonCacheNames.CscCache
    
    # Setup the RAW data provider algorithm
    Muon__CscRawDataProvider=CompFactory.Muon.CscRawDataProvider
    CscRawDataProvider = Muon__CscRawDataProvider(name         = name,
                                                  ProviderTool = MuonCscRawDataProviderTool, **kwargs )
    if flags.Muon.MuonTrigger:
        # add RegSelTool
        from RegionSelector.RegSelToolConfig import regSelTool_CSC_Cfg
        CscRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_CSC_Cfg( flags ) )
 
 
    acc.addEventAlgo(CscRawDataProvider,primary=True)
 
    return acc
 
 

◆ MdtBytestreamDecodeCfg()

MuonBytestreamDecodeConfig.MdtBytestreamDecodeCfg	(		flags,
			name = "MdtRawDataProvider",
		**	kwargs )

Definition at line 138 of file MuonBytestreamDecodeConfig.py.

def MdtBytestreamDecodeCfg(flags, name="MdtRawDataProvider", **kwargs):
    acc = ComponentAccumulator()
 
    # We need the MDT cabling to be setup
    from MuonConfig.MuonCablingConfig import MDTCablingConfigCfg
    acc.merge( MDTCablingConfigCfg(flags) )
 
    # need the MagFieldSvc since MdtRdoToMdtPrepData.MdtRdoToMdtPrepDataTool.MdtCalibrationTool wants to retrieve it
    from MagFieldServices.MagFieldServicesConfig import AtlasFieldCacheCondAlgCfg
    acc.merge( AtlasFieldCacheCondAlgCfg(flags) )
 
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags)) 
 
    # Setup the MDT ROD decoder
    MdtROD_Decoder=CompFactory.MdtROD_Decoder
    MDTRodDecoder = MdtROD_Decoder(name="MdtROD_Decoder")
 
 
    # Setup the RAW data provider tool
    keyName = f"{flags.Overlay.BkgPrefix}MDTCSM" if flags.Overlay.ByteStream else "MDTCSM"
    Muon__MDT_RawDataProviderToolMT=CompFactory.Muon.MDT_RawDataProviderToolMT
    MuonMdtRawDataProviderTool = Muon__MDT_RawDataProviderToolMT(name    = "MDT_RawDataProviderToolMT",
                                                                 Decoder = MDTRodDecoder,
                                                                 RdoLocation = keyName)
 
    if flags.Muon.MuonTrigger:
        MuonMdtRawDataProviderTool.CsmContainerCacheKey = MuonCacheNames.MdtCsmCache
 
    # Setup the RAW data provider algorithm
    Muon__MdtRawDataProvider=CompFactory.Muon.MdtRawDataProvider
    MdtRawDataProvider = Muon__MdtRawDataProvider(name         = name,
                                                  ProviderTool = MuonMdtRawDataProviderTool, **kwargs )
    if flags.Muon.MuonTrigger:
        # add RegSelTool
        from RegionSelector.RegSelToolConfig import regSelTool_MDT_Cfg
        MdtRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_MDT_Cfg( flags ) )
 
 
    acc.addEventAlgo(MdtRawDataProvider,primary=True)
 
    return acc
 

◆ MmBytestreamDecodeCfg()

MuonBytestreamDecodeConfig.MmBytestreamDecodeCfg	(		flags,
			name = "MmRawDataProvider",
		**	kwargs )

Definition at line 348 of file MuonBytestreamDecodeConfig.py.

def MmBytestreamDecodeCfg(flags, name="MmRawDataProvider", **kwargs):
    acc = ComponentAccumulator()
 
    # We need the MM cabling to be setup
    #from MuonConfig.MuonCablingConfig import MM_CablingConfigCfg
    #acc.merge( MM_CablingConfigCfg(flags) )
 
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags)) 
   
    # Setup the RAW data provider tool
    keyName = f"{flags.Overlay.BkgPrefix}MMRDO" if flags.Overlay.ByteStream else "MMRDO"
    MuonMmRawDataProviderTool = CompFactory.Muon.MM_RawDataProviderToolMT(name  = "MM_RawDataProviderToolMT",
                                                              Decoder = acc.popToolsAndMerge(MmRDODDecoderCfg(flags)),
                                                              RdoLocation = keyName,
                                                              SkipDecoding=flags.Muon.MuonTrigger and flags.Muon.runCommissioningChain)
 
    #if flags.Muon.MuonTrigger:
    #    MuonMmRawDataProviderTool.RawDataContainerCacheKey = MuonCacheNames.MicromegasCache
 
    # Setup the RAW data provider algorithm
    Muon__MmRawDataProvider = CompFactory.Muon.MM_RawDataProvider
    MmRawDataProvider = Muon__MmRawDataProvider(name = name, ProviderTool = MuonMmRawDataProviderTool, **kwargs )
    if flags.Muon.MuonTrigger:
        # add RegSelTool
        from RegionSelector.RegSelToolConfig import regSelTool_MM_Cfg
        MmRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_MM_Cfg( flags ) )
 
    acc.addEventAlgo(MmRawDataProvider,primary=True)
 
    return acc
 

◆ MmRDODDecoderCfg()

MuonBytestreamDecodeConfig.MmRDODDecoderCfg	(		flags,
			name = "MmROD_Decoder",
		**	kwargs )

Definition at line 332 of file MuonBytestreamDecodeConfig.py.

def MmRDODDecoderCfg(flags, name="MmROD_Decoder", **kwargs):
    result = ComponentAccumulator()
    
    if not flags.Muon.MuonTrigger and not flags.Input.isMC:        
        from MuonConfig.MuonCondAlgConfig import NswDcsDbAlgCfg
        if False: result.merge(NswDcsDbAlgCfg(flags))
        from MuonConfig.MuonCablingConfig import MmCablingCfg
        result.merge(MmCablingCfg(flags))
    else:
        kwargs.setdefault("CablingMap", "")
    
    kwargs.setdefault("DcsKey", "")
    
    the_tool = CompFactory.Muon.MM_ROD_Decoder(name = name, **kwargs)
    result.setPrivateTools(the_tool)
    return result

◆ MuonByteStreamDecodersCfg()

MuonBytestreamDecodeConfig.MuonByteStreamDecodersCfg ( flags )

Definition at line 407 of file MuonBytestreamDecodeConfig.py.

def MuonByteStreamDecodersCfg(flags):
    cfg=ComponentAccumulator()
    
    # Adds all services needed to read BS
    from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
    cfg.merge(ByteStreamReadCfg(flags ))
 
    # Schedule Rpc data decoding
    if flags.Detector.EnableRPC:
        cfg.merge(RpcBytestreamDecodeCfg(flags))
 
    if flags.Muon.enableNRPC:
        # Schedule Nrpc data decoding
        cfg.merge(NrpcBytestreamDecodeCfg(flags))
 
    # Schedule Tgc data decoding
    if flags.Detector.EnableTGC:
        cfg.merge(TgcBytestreamDecodeCfg(flags))
 
    # Schedule Mdt data decoding
    if flags.Detector.EnableMDT:
        cfg.merge(MdtBytestreamDecodeCfg(flags))
 
    # Schedule Csc data decoding
    if flags.Detector.GeometryCSC:
        cfg.merge(CscBytestreamDecodeCfg(flags))
 
    if flags.Detector.GeometryMM:
        # Schedule MM and MMTP data decoding
        cfg.merge( MmBytestreamDecodeCfg( flags ) )
        cfg.merge( NswMMTPByteStreamDecodeCfg(flags) )
 
    # Schedule sTGC data decoding
    if flags.Detector.GeometrysTGC:
        cfg.merge(sTgcBytestreamDecodeCfg(flags))
        # Schedule sTGC Pad Trigger data decoding
        cfg.merge( sTgcPadTriggerBytestreamDecodeCfg(flags))
    
    if flags.Detector.GeometrysTGC and flags.Detector.GeometryMM:  
        cfg.merge(NswTrigProcByteStreamDecodeCfg(flags))
 
    return cfg
 
 

◆ MuonCacheCfg()

MuonBytestreamDecodeConfig.MuonCacheCfg ( flags )

This configuration function creates the IdentifiableCaches for RDO.

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 17 of file MuonBytestreamDecodeConfig.py.

def MuonCacheCfg(flags):
 
 
    acc = ComponentAccumulator()
 
    MuonCacheCreator=CompFactory.MuonCacheCreator
    cacheCreator = MuonCacheCreator(MdtCsmCacheKey = MuonCacheNames.MdtCsmCache,
                                    CscCacheKey    = (MuonCacheNames.CscCache if flags.Detector.GeometryCSC else ""),
                                    RpcCacheKey    = MuonCacheNames.RpcCache,
                                    TgcCacheKey    = MuonCacheNames.TgcCache)
 
    acc.addEventAlgo( cacheCreator, primary=True )
    return acc
 

◆ NrpcBytestreamDecodeCfg()

MuonBytestreamDecodeConfig.NrpcBytestreamDecodeCfg	(		flags,
			name = "NrpcRawDataProvider",
		**	kwargs )

Definition at line 73 of file MuonBytestreamDecodeConfig.py.

def NrpcBytestreamDecodeCfg(flags, name="NrpcRawDataProvider", **kwargs):
    acc = ComponentAccumulator()
    
    # We need the NRPC cabling to be setup
    from MuonConfig.MuonCablingConfig import NRPCCablingConfigCfg
    acc.merge( NRPCCablingConfigCfg(flags) )
 
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags))
 
 
    # Setup the RAW data provider tool
    keyName = flags.Overlay.BkgPrefix + "NRPCRDO" if flags.Common.isOverlay else "NRPCRDO"
    MuonNrpcRawDataProviderTool = CompFactory.Muon.NRPC_RawDataProviderTool(name    = "NRPC_RawDataProviderTool",
                                                                   NrpcRdoKey = keyName )
    
    # Setup the RAW data provider algorithm
    NrpcRawDataProvider = CompFactory.Muon.NrpcRawDataProvider(name         = name,
                                                    ProviderTool = MuonNrpcRawDataProviderTool, **kwargs )
 
    acc.addEventAlgo(NrpcRawDataProvider, primary=True)
    return acc
 

◆ NswMMTPByteStreamDecodeCfg()

MuonBytestreamDecodeConfig.NswMMTPByteStreamDecodeCfg	(		flags,
			name = "NswMMTPByteStreamDecode",
		**	kwargs )

Definition at line 395 of file MuonBytestreamDecodeConfig.py.

def NswMMTPByteStreamDecodeCfg(flags, name = "NswMMTPByteStreamDecode",  **kwargs ):
    result = ComponentAccumulator()
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    result.merge(MuonGeoModelCfg(flags))
 
    #recycling Pad data provider since not it's not doing anything
    the_alg = CompFactory.Muon.sTgcPadTriggerRawDataProvider(name = name, ProviderTool = result.popToolsAndMerge(NswMMTPRawDataProviderToolCfg(flags)), **kwargs )
    result.addEventAlgo(the_alg, primary = True)
    return result
 
 

◆ NswMMTPRawDataProviderToolCfg()

MuonBytestreamDecodeConfig.NswMMTPRawDataProviderToolCfg	(		flags,
			name = "NswMMTPRawDataProviderTool",
		**	kwargs )

Definition at line 387 of file MuonBytestreamDecodeConfig.py.

def NswMMTPRawDataProviderToolCfg(flags, name = "NswMMTPRawDataProviderTool", **kwargs ):
    result = ComponentAccumulator()
    kwargs.setdefault( "Decoder", result.popToolsAndMerge(NswMMTPRodDecoderCfg(flags)))
    kwargs.setdefault( "RdoLocation", ( flags.Overlay.BkgPrefix  if flags.Common.isOverlay else "") + "NSW_MMTrigProcessor_RDO" )
    the_tool = CompFactory.Muon.NSWMMTP_RawDataProviderToolMT(name = name, **kwargs)
    result.setPrivateTools(the_tool)
    return result
 

◆ NswMMTPRodDecoderCfg()

MuonBytestreamDecodeConfig.NswMMTPRodDecoderCfg	(		flags,
			name = "NswMMTPRodDecoder",
		**	kwargs )

Definition at line 381 of file MuonBytestreamDecodeConfig.py.

def NswMMTPRodDecoderCfg(flags, name ="NswMMTPRodDecoder", **kwargs):
    result = ComponentAccumulator()
    the_tool = CompFactory.Muon.NSWMMTP_ROD_Decoder(name = name, **kwargs)
    result.setPrivateTools(the_tool)
    return result
 

◆ NswTrigProcByteStreamDecodeCfg()

MuonBytestreamDecodeConfig.NswTrigProcByteStreamDecodeCfg	(		flags,
			name = "NswProcByteStream" )

Definition at line 293 of file MuonBytestreamDecodeConfig.py.

def NswTrigProcByteStreamDecodeCfg(flags, name = "NswProcByteStream"):
    result = ComponentAccumulator()
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    result.merge(MuonGeoModelCfg(flags))
    the_alg = CompFactory.Muon.sTgcPadTriggerRawDataProvider(name = name,
                                                             ProviderTool = result.popToolsAndMerge(NswTrigProcessorRawDataProviderToolCfg(flags)) )
    result.addEventAlgo(the_alg, primary = True)
    return result
 

◆ NswTrigProcessorRawDataProviderToolCfg()

MuonBytestreamDecodeConfig.NswTrigProcessorRawDataProviderToolCfg	(		flags,
			name = "NswTrigProcessorRawDataTool",
		**	kwargs )

Definition at line 286 of file MuonBytestreamDecodeConfig.py.

def NswTrigProcessorRawDataProviderToolCfg(flags, name = "NswTrigProcessorRawDataTool", **kwargs ):
    result = ComponentAccumulator()
    kwargs.setdefault("Decoder", result.popToolsAndMerge(NswTrigProcessorRodDecoderCfg(flags)))
    kwargs.setdefault( "RdoLocation", ( flags.Overlay.BkgPrefix  if flags.Common.isOverlay else "") + "NSW_TrigProcessor_RDO" )
    the_tool = CompFactory.Muon.NSWTP_RawDataProviderToolMT(name = name, **kwargs)
    result.setPrivateTools(the_tool)
    return result

◆ NswTrigProcessorRodDecoderCfg()

MuonBytestreamDecodeConfig.NswTrigProcessorRodDecoderCfg	(		flags,
			name = "NswTrigProcessorDecoder",
		**	kwargs )

Definition at line 281 of file MuonBytestreamDecodeConfig.py.

def NswTrigProcessorRodDecoderCfg(flags, name ="NswTrigProcessorDecoder", **kwargs):
    result = ComponentAccumulator()
    the_tool = CompFactory.Muon.NSWTP_ROD_Decoder(name = name, **kwargs)
    result.setPrivateTools(the_tool)
    return result

◆ RpcBytestreamDecodeCfg()

MuonBytestreamDecodeConfig.RpcBytestreamDecodeCfg	(		flags,
			name = "RpcRawDataProvider",
		**	kwargs )

This configuration function sets up everything for decoding RPC bytestream data into RDOs.

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

Definition at line 34 of file MuonBytestreamDecodeConfig.py.

def RpcBytestreamDecodeCfg(flags, name="RpcRawDataProvider", **kwargs):
    acc = ComponentAccumulator()
    
    # We need the RPC cabling to be setup
    from MuonConfig.MuonCablingConfig import RPCCablingConfigCfg
    acc.merge( RPCCablingConfigCfg(flags) )
 
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags)) 
    
    # Setup the RPC ROD decoder
    RPCRodDecoder = CompFactory.Muon.RpcROD_Decoder(name         = "RpcROD_Decoder",NOBXS=flags.Trigger.L1MuonSim.RPCNBX)
 
 
    # Setup the RAW data provider tool
    keyName = f"{flags.Overlay.BkgPrefix}RPCPAD" if flags.Overlay.ByteStream else "RPCPAD"
    MuonRpcRawDataProviderTool = CompFactory.Muon.RPC_RawDataProviderToolMT(name    = "RPC_RawDataProviderToolMT",
                                                                 Decoder = RPCRodDecoder,
                                                                 RdoLocation = keyName )
    if flags.Muon.MuonTrigger:
        MuonRpcRawDataProviderTool.RpcContainerCacheKey   = MuonCacheNames.RpcCache
        MuonRpcRawDataProviderTool.WriteOutRpcSectorLogic = False
 
    
    # Setup the RAW data provider algorithm
    Muon__RpcRawDataProvider=CompFactory.Muon.RpcRawDataProvider
    RpcRawDataProvider = Muon__RpcRawDataProvider(name         = name,
                                                  ProviderTool = MuonRpcRawDataProviderTool, **kwargs )
 
    if flags.Muon.MuonTrigger:
        # add RegSelTool
        from RegionSelector.RegSelToolConfig import regSelTool_RPC_Cfg
        RpcRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_RPC_Cfg( flags ) )
 
 
    acc.addEventAlgo(RpcRawDataProvider, primary=True)
    return acc
 

◆ sTgcBytestreamDecodeCfg()

MuonBytestreamDecodeConfig.sTgcBytestreamDecodeCfg	(		flags,
			name = "sTgcRawDataProvider",
		**	kwargs )

Definition at line 245 of file MuonBytestreamDecodeConfig.py.

def sTgcBytestreamDecodeCfg(flags, name="sTgcRawDataProvider", **kwargs):
 
    acc = ComponentAccumulator()
 
 
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags))
 
 
 
    # Setup the RAW data provider tool
    keyName = f"{flags.Overlay.BkgPrefix}sTGCRDO" if flags.Overlay.ByteStream else "sTGCRDO"
    Muon__STGC_RawDataProviderToolMT=CompFactory.Muon.STGC_RawDataProviderToolMT
    MuonsTgcRawDataProviderTool = Muon__STGC_RawDataProviderToolMT(name    = "sTgcRawDataProviderTool",
                                                                   Decoder = acc.popToolsAndMerge(sTgcRODDecoderCfg(flags)),
                                                                   RdoLocation = keyName,
                                                                   SkipDecoding=flags.Muon.MuonTrigger and flags.Muon.runCommissioningChain )
 
    #if flags.Muon.MuonTrigger:
    #    MuonsTgcRawDataProviderTool.sTgcContainerCacheKey = MuonCacheNames.sTgcCache
    
    # Setup the RAW data provider algorithm
    Muon__sTgcRawDataProvider=CompFactory.Muon.sTgcRawDataProvider
    sTgcRawDataProvider = Muon__sTgcRawDataProvider(name       = name,
                                                  ProviderTool = MuonsTgcRawDataProviderTool, **kwargs )
    if flags.Muon.MuonTrigger:
        # add RegSelTool
        from RegionSelector.RegSelToolConfig import regSelTool_STGC_Cfg
        sTgcRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_STGC_Cfg( flags ) )
 
 
    acc.addEventAlgo(sTgcRawDataProvider,primary=True)
 
    return acc
 

◆ sTgcPadTriggerBytestreamDecodeCfg()

MuonBytestreamDecodeConfig.sTgcPadTriggerBytestreamDecodeCfg	(		flags,
			name = "sTgcPadTriggerRawDataProvider",
		**	kwargs )

Definition at line 303 of file MuonBytestreamDecodeConfig.py.

def sTgcPadTriggerBytestreamDecodeCfg(flags, name="sTgcPadTriggerRawDataProvider", **kwargs):
 
    acc = ComponentAccumulator()
 
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags))
 
    # Setup the sTGC ROD decoder
    Muon__PadTrig_ROD_Decoder = CompFactory.Muon.PadTrig_ROD_Decoder
    STGCPadTriggerRodDecoder = Muon__PadTrig_ROD_Decoder(name = "sTgcPadTriggerROD_Decoder")
 
 
    # Setup the RAW data provider tool
    keyName = flags.Overlay.BkgPrefix + "NSW_PadTrigger_RDO" if flags.Common.isOverlay else "NSW_PadTrigger_RDO"
    Muon__PadTrig_RawDataProviderToolMT = CompFactory.Muon.PadTrig_RawDataProviderToolMT
    MuonsTgcPadTriggerRawDataProviderTool = Muon__PadTrig_RawDataProviderToolMT(name = "sTgcPadTriggerRawDataProviderTool",
                                                                                Decoder = STGCPadTriggerRodDecoder,
                                                                                RdoLocation = keyName)
 
 
    # Setup the RAW data provider algorithm
    the_alg = CompFactory.Muon.sTgcPadTriggerRawDataProvider(name = name,
                                                             ProviderTool = MuonsTgcPadTriggerRawDataProviderTool, **kwargs )
 
    acc.addEventAlgo(the_alg, primary = True)
 
    return acc
 

◆ sTgcRODDecoderCfg()

MuonBytestreamDecodeConfig.sTgcRODDecoderCfg	(		flags,
			name = "sTgcROD_Decoder",
		**	kwargs )

Definition at line 222 of file MuonBytestreamDecodeConfig.py.

def sTgcRODDecoderCfg(flags, name = "sTgcROD_Decoder", **kwargs):
    result = ComponentAccumulator()
    
    if False and not flags.Muon.MuonTrigger and not flags.Input.isMC:
        from MuonConfig.MuonCondAlgConfig import NswDcsDbAlgCfg
        result.merge(NswDcsDbAlgCfg(flags))
    else:
        kwargs.setdefault("DcsKey", "")
 
    if flags.Input.isMC:
        kwargs.setdefault("CablingMap","")
    else:
        # We need the sTGC cabling to be setup
        from MuonConfig.MuonCablingConfig import sTgcCablingCfg
        result.merge( sTgcCablingCfg(flags) )
        kwargs.setdefault("CablingMap","stgcCablingMap")
 
 
    # Setup the sTGC ROD decoder
    STGCRodDecoder = CompFactory.Muon.STGC_ROD_Decoder(name = name, **kwargs)
    result.setPrivateTools(STGCRodDecoder)
    return result
 

◆ TgcBytestreamDecodeCfg()

MuonBytestreamDecodeConfig.TgcBytestreamDecodeCfg	(		flags,
			name = "TgcRawDataProvider",
		**	kwargs )

Definition at line 97 of file MuonBytestreamDecodeConfig.py.

def TgcBytestreamDecodeCfg(flags, name="TgcRawDataProvider", **kwargs):
    acc = ComponentAccumulator()
 
    # We need the TGC cabling to be setup
    from MuonConfig.MuonCablingConfig import TGCCablingConfigCfg
    acc.merge( TGCCablingConfigCfg(flags) )
 
    # Make sure muon geometry is configured
    from MuonConfig.MuonGeometryConfig import MuonGeoModelCfg
    acc.merge(MuonGeoModelCfg(flags)) 
 
    # Setup the TGC ROD decoder
    Muon__TGC_RodDecoderReadout=CompFactory.Muon.TGC_RodDecoderReadout
    TGCRodDecoder = Muon__TGC_RodDecoderReadout(name = "TgcROD_Decoder")
 
 
    # Setup the RAW data provider tool
    keyName = f"{flags.Overlay.BkgPrefix}TGCRDO" if flags.Overlay.ByteStream else "TGCRDO"
    Muon__TGC_RawDataProviderToolMT=CompFactory.Muon.TGC_RawDataProviderToolMT
    MuonTgcRawDataProviderTool = Muon__TGC_RawDataProviderToolMT(name    = "TGC_RawDataProviderToolMT",
                                                                 Decoder = TGCRodDecoder,
                                                                 RdoLocation = keyName )
 
    if flags.Muon.MuonTrigger:
        MuonTgcRawDataProviderTool.TgcContainerCacheKey   = MuonCacheNames.TgcCache
 
    
    # Setup the RAW data provider algorithm
    Muon__TgcRawDataProvider=CompFactory.Muon.TgcRawDataProvider
    TgcRawDataProvider = Muon__TgcRawDataProvider(name         = name,
                                                  ProviderTool = MuonTgcRawDataProviderTool, **kwargs )
    if flags.Muon.MuonTrigger:
        # add RegSelTool
        from RegionSelector.RegSelToolConfig import regSelTool_TGC_Cfg
        TgcRawDataProvider.RegionSelectionTool = acc.popToolsAndMerge( regSelTool_TGC_Cfg( flags ) )
 
 
    acc.addEventAlgo(TgcRawDataProvider,primary=True)
 
    return acc
 