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="MuonRpcRdoProvider", **kwargs)
	This configuration function sets up everything for decoding RPC bytestream data into RDOs.
	NrpcBytestreamDecodeCfg (flags, name="MuonNRpcRdoProvider", **kwargs)
	TgcBytestreamDecodeCfg (flags, name="MuonTgcRdoProvider", **kwargs)
	MdtBytestreamDecodeCfg (flags, name="MuonMdtRdoProvider", **kwargs)
	CscBytestreamDecodeCfg (flags, name="CscRawDataProvider", **kwargs)
	sTgcRODDecoderCfg (flags, name="sTgcROD_Decoder", **kwargs)
	sTgcBytestreamDecodeCfg (flags, name="MuonStgcRdoProvider", **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="MuonMmRdoProvider", **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 181 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.Common.ProductionStep is ProductionStep.MinbiasPreprocessing else "CSCRDO"
    MuonCscRawDataProviderTool = CompFactory.Muon.CSC_RawDataProviderTool(name    = "CSC_RawDataProviderTool",
                                                                 Decoder = CSCRodDecoder,
                                                                 RdoLocation = keyName)
    if flags.Muon.MuonTrigger:
        MuonCscRawDataProviderTool.CscContainerCacheKey = MuonCacheNames.CscCache
    
    # Setup the RAW data provider algorithm
    CscRawDataProvider = CompFactory.Muon.MuonRawDataProvider(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 = "MuonMdtRdoProvider",
		**	kwargs )

Definition at line 139 of file MuonBytestreamDecodeConfig.py.

def MdtBytestreamDecodeCfg(flags, name="MuonMdtRdoProvider", **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.Common.ProductionStep is ProductionStep.MinbiasPreprocessing else "MDTCSM"
    MuonMdtRawDataProviderTool = CompFactory.Muon.MDT_RawDataProviderTool(name    = "MDT_RawDataProviderTool",
                                                                          Decoder = MDTRodDecoder,
                                                                          RdoLocation = keyName)
 
    if flags.Muon.MuonTrigger:
        MuonMdtRawDataProviderTool.CsmContainerCacheKey = MuonCacheNames.MdtCsmCache
 
    # Setup the RAW data provider algorithm
    MdtRawDataProvider = CompFactory.Muon.MuonRawDataProvider(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 = "MuonMmRdoProvider",
		**	kwargs )

Definition at line 342 of file MuonBytestreamDecodeConfig.py.

def MmBytestreamDecodeCfg(flags, name="MuonMmRdoProvider", **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.Common.ProductionStep is ProductionStep.MinbiasPreprocessing else "MMRDO"
    MuonMmRawDataProviderTool = CompFactory.Muon.MM_RawDataProviderTool(name  = "MM_RawDataProviderTool",
                                                              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
    MmRawDataProvider = CompFactory.Muon.MuonRawDataProvider(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 326 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 400 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 18 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 = "MuonNRpcRdoProvider",
		**	kwargs )

Definition at line 73 of file MuonBytestreamDecodeConfig.py.

def NrpcBytestreamDecodeCfg(flags, name="MuonNRpcRdoProvider", **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.MuonRawDataProvider(name         = name,
                                                               ProviderTool = MuonNrpcRawDataProviderTool, **kwargs )
 
    acc.addEventAlgo(NrpcRawDataProvider, primary=True)
    return acc
 

◆ NswMMTPByteStreamDecodeCfg()

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

Definition at line 388 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.MuonRawDataProvider(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 380 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 374 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 288 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.MuonRawDataProvider(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 281 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_RawDataProviderTool(name = name, **kwargs)
    result.setPrivateTools(the_tool)
    return result

◆ NswTrigProcessorRodDecoderCfg()

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

Definition at line 276 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 = "MuonRpcRdoProvider",
		**	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 35 of file MuonBytestreamDecodeConfig.py.

def RpcBytestreamDecodeCfg(flags, name="MuonRpcRdoProvider", **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.Common.ProductionStep is ProductionStep.MinbiasPreprocessing else "RPCPAD"
    MuonRpcRawDataProviderTool = CompFactory.Muon.RPC_RawDataProviderTool(name    = "RPC_RawDataProviderTool",
                                                                 Decoder = RPCRodDecoder,
                                                                 RdoLocation = keyName )
    if flags.Muon.MuonTrigger:
        MuonRpcRawDataProviderTool.RpcContainerCacheKey   = MuonCacheNames.RpcCache
        MuonRpcRawDataProviderTool.WriteOutRpcSectorLogic = False
 
    
    # Setup the RAW data provider algorithm
    RpcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(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 = "MuonStgcRdoProvider",
		**	kwargs )

Definition at line 242 of file MuonBytestreamDecodeConfig.py.

def sTgcBytestreamDecodeCfg(flags, name="MuonStgcRdoProvider", **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.Common.ProductionStep is ProductionStep.MinbiasPreprocessing else "sTGCRDO"
    MuonsTgcRawDataProviderTool = CompFactory.Muon.STGC_RawDataProviderTool(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
    sTgcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(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 298 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"
    MuonsTgcPadTriggerRawDataProviderTool = CompFactory.Muon.PadTrig_RawDataProviderTool(name = "sTgcPadTriggerRawDataProviderTool",
                                                                                         Decoder = STGCPadTriggerRodDecoder,
                                                                                         RdoLocation = keyName)
 
 
    # Setup the RAW data provider algorithm
    the_alg = CompFactory.Muon.MuonRawDataProvider(name = name,
                                                   ProviderTool = MuonsTgcPadTriggerRawDataProviderTool, **kwargs )
 
    acc.addEventAlgo(the_alg, primary = True)
 
    return acc
 

◆ sTgcRODDecoderCfg()

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

Definition at line 219 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 = "MuonTgcRdoProvider",
		**	kwargs )

Definition at line 97 of file MuonBytestreamDecodeConfig.py.

def TgcBytestreamDecodeCfg(flags, name="MuonTgcRdoProvider", **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.Common.ProductionStep is ProductionStep.MinbiasPreprocessing else "TGCRDO"
    MuonTgcRawDataProviderTool = CompFactory.Muon.TGC_RawDataProviderTool(name    = "TGC_RawDataProviderTool",
                                                                 Decoder = TGCRodDecoder,
                                                                 RdoLocation = keyName )
 
    if flags.Muon.MuonTrigger:
        MuonTgcRawDataProviderTool.TgcContainerCacheKey   = MuonCacheNames.TgcCache
 
    
    if flags.Muon.MuonTrigger:
        kwargs.setdefault("UseHashIds", True)
 
    # Setup the RAW data provider algorithm
    TgcRawDataProvider = CompFactory.Muon.MuonRawDataProvider(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
 