python.MuonBytestreamDecodeConfig Namespace Reference

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

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

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

Function Documentation

CscBytestreamDecodeCfg()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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()

def python.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
 

Variable Documentation

args

python.MuonBytestreamDecodeConfig.args = flags.fillFromArgs()

Definition at line 465 of file MuonBytestreamDecodeConfig.py.

AtlasVersion

python.MuonBytestreamDecodeConfig.AtlasVersion

Definition at line 461 of file MuonBytestreamDecodeConfig.py.

cfg

python.MuonBytestreamDecodeConfig.cfg = MainServicesCfg(flags)

Definition at line 470 of file MuonBytestreamDecodeConfig.py.

Files

python.MuonBytestreamDecodeConfig.Files

Definition at line 459 of file MuonBytestreamDecodeConfig.py.

flags

python.MuonBytestreamDecodeConfig.flags = initConfigFlags()

Definition at line 457 of file MuonBytestreamDecodeConfig.py.

GlobalTag

python.MuonBytestreamDecodeConfig.GlobalTag

Definition at line 460 of file MuonBytestreamDecodeConfig.py.

MaxEvents

python.MuonBytestreamDecodeConfig.MaxEvents

Definition at line 463 of file MuonBytestreamDecodeConfig.py.

NumThreads

python.MuonBytestreamDecodeConfig.NumThreads

Definition at line 462 of file MuonBytestreamDecodeConfig.py.

withDetails

python.MuonBytestreamDecodeConfig.withDetails

Definition at line 475 of file MuonBytestreamDecodeConfig.py.