Functions
	TileRawChannelMakerCfg (flags, **kwargs)
	TileRawChannelMakerDigiHSTruthCfg (flags, **kwargs)
	TileRawChannelOutputCfg (flags, tileRawChannelMaker, streamName)
	TileRawChannelMakerOutputCfg (flags, streamName='ESD', **kwargs)
	TileRawChannelMakerDigiHSTruthOutputCfg (flags, streamName='ESD', **kwargs)

Variables
	flags = initConfigFlags()
	Files
	AtlasVersion
	GlobalTag
	RunType
	doFit
	doOF1
	doWiener
	doOpt2
	doOptATLAS
	doTileNN
	correctTimeJumps
	NoiseFilter
	ESDFileName
	MaxEvents
	acc = MainServicesCfg(flags)
	withDetails
	True
	summariseProps
	sc = acc.run()

Detailed Description

Define method to construct configured Tile raw channel maker algorithm

Function Documentation

◆ TileRawChannelMakerCfg()

TileRawChannelMakerCfg	(		flags,
		**	kwargs )

Return component accumulator with configured Tile raw channel maker algorithm

Arguments:
    flags  -- Athena configuration flags

Definition at line 10 of file TileRawChannelMakerConfig.py.

def TileRawChannelMakerCfg(flags, **kwargs):
    """Return component accumulator with configured Tile raw channel maker algorithm
 
    Arguments:
        flags  -- Athena configuration flags
    """
 
    acc = ComponentAccumulator()
 
    from TileConditions.TileInfoLoaderConfig import TileInfoLoaderCfg
    acc.merge( TileInfoLoaderCfg(flags) )
 
    kwargs.setdefault('name', 'TileRChMaker')
    name = kwargs['name']
 
    if flags.Common.ProductionStep in [ProductionStep.PileUpPresampling, ProductionStep.PileUpPretracking, ProductionStep.MinbiasPreprocessing]:
        kwargs.setdefault('TileDigitsContainer', flags.Overlay.BkgPrefix + 'TileDigitsCnt')
    else:
        kwargs.setdefault('TileDigitsContainer', 'TileDigitsCnt')
 
    from AthenaCommon.Logging import logging
    mlog = logging.getLogger( 'TileRawChannelMakerCfg' )
 
    if flags.Tile.doOverflowFit:
        kwargs.setdefault('FitOverflow', True)
        from TileRecUtils.TileRawChannelBuilderFitConfig import TileRawChannelBuilderFitOverflowCfg
        tileRawChannelBuilderFitOverflow = acc.popToolsAndMerge( TileRawChannelBuilderFitOverflowCfg(flags) )
        kwargs.setdefault('TileRawChannelBuilderFitOverflow', tileRawChannelBuilderFitOverflow)
    else:
        kwargs.setdefault('FitOverflow', False)
 
    tileRawChannelBuilder = []
 
    if flags.Tile.doFit:
        from TileRecUtils.TileRawChannelBuilderFitConfig import TileRawChannelBuilderFitFilterCfg
        tileRawChannelBuilderFitFilter = acc.popToolsAndMerge( TileRawChannelBuilderFitFilterCfg(flags) )
        tileRawChannelBuilder += [tileRawChannelBuilderFitFilter]
        mlog.info(" adding now TileRawChannelBuilderFitFilter with name %s to the algorithm: %s",
                  tileRawChannelBuilderFitFilter.name, name)
 
    if flags.Tile.doMF:
        from TileRecUtils.TileRawChannelBuilderMFConfig import TileRawChannelBuilderMFCfg
        tileRawChannelBuilderMF = acc.popToolsAndMerge( TileRawChannelBuilderMFCfg(flags) )
        tileRawChannelBuilder += [tileRawChannelBuilderMF]
        mlog.info(" adding now TileRawChannelBuilderMF with name %s to the algorithm: %s",
                  tileRawChannelBuilderMF.name, name)
 
    if flags.Tile.doOF1:
        from TileRecUtils.TileRawChannelBuilderOptConfig import TileRawChannelBuilderOF1Cfg
        tileRawChannelBuilderOF1 = acc.popToolsAndMerge( TileRawChannelBuilderOF1Cfg(flags) )
        tileRawChannelBuilder += [tileRawChannelBuilderOF1]
        mlog.info(" adding now TileRawChannelBuilderOpt2Filter with name %s to the algorithm: %s",
                  tileRawChannelBuilderOF1.name, name)
 
    if flags.Tile.doWiener:
        from TileRecUtils.TileRawChannelBuilderWienerConfig import TileRawChannelBuilderWienerCfg
        tileRawChannelBuilderWiener = acc.popToolsAndMerge( TileRawChannelBuilderWienerCfg(flags) )
        tileRawChannelBuilder += [tileRawChannelBuilderWiener]
        mlog.info(" adding now TileRawChannelBuilderWienerFilter with name %s to the algorithm: %s",
                  tileRawChannelBuilderWiener.name, name)
 
    if flags.Tile.doOpt2:
        from TileRecUtils.TileRawChannelBuilderOptConfig import TileRawChannelBuilderOpt2Cfg
        tileRawChannelBuilderOpt2 = acc.popToolsAndMerge( TileRawChannelBuilderOpt2Cfg(flags) )
        tileRawChannelBuilder += [tileRawChannelBuilderOpt2]
        mlog.info(" adding now TileRawChannelBuilderOpt2Filter with name %s to the algorithm: %s",
                  tileRawChannelBuilderOpt2.name, name)
 
    if flags.Tile.doOptATLAS:
        from TileRecUtils.TileRawChannelBuilderOptConfig import TileRawChannelBuilderOptATLASCfg
        tileRawChannelBuilderOptATLAS = acc.popToolsAndMerge( TileRawChannelBuilderOptATLASCfg(flags) )
        tileRawChannelBuilder += [tileRawChannelBuilderOptATLAS]
        mlog.info(" adding now TileRawChannelBuilderOpt2Filter with name %s to the algorithm: %s",
                  tileRawChannelBuilderOptATLAS.name, name)
 
    if flags.Tile.doTileNN:
        from TileRecUtils.TileRawChannelNNMakerConfig import TileRawChannelNNMakerCfg
        acc.merge( TileRawChannelNNMakerCfg(flags) )
        mlog.info(" adding now TileRawChannelNNMaker as a separate algorithm alongside: %s", name)
 
    kwargs.setdefault('TileRawChannelBuilder', tileRawChannelBuilder)
 
    if flags.Common.isOverlay and flags.Concurrency.NumThreads > 0:
        kwargs.setdefault('Cardinality', flags.Concurrency.NumThreads)
 
    TileRawChannelMaker=CompFactory.TileRawChannelMaker
    acc.addEventAlgo(TileRawChannelMaker(**kwargs), primary = True)
 
    return acc
 
 

◆ TileRawChannelMakerDigiHSTruthCfg()

TileRawChannelMakerDigiHSTruthCfg	(		flags,
		**	kwargs )

Return component accumulator with configured Tile raw channel maker algorithm for HS

Arguments:
    flags  -- Athena configuration flags

Definition at line 101 of file TileRawChannelMakerConfig.py.

def TileRawChannelMakerDigiHSTruthCfg(flags, **kwargs):
    """Return component accumulator with configured Tile raw channel maker algorithm for HS
 
    Arguments:
        flags  -- Athena configuration flags
    """
 
    kwargs.setdefault('name', 'TileRChMaker_DigiHSTruth')
    kwargs.setdefault('TileDigitsContainer', 'TileDigitsCnt_DigiHSTruth')
 
    acc = TileRawChannelMakerCfg(flags, **kwargs)
    rawChannelMaker = acc.getPrimary()
 
    rawChannelbuilders = rawChannelMaker.TileRawChannelBuilder
 
    for rawChannelBuilder in rawChannelbuilders:
        rawChannelBuilder.TileRawChannelContainer = f'{rawChannelBuilder.TileRawChannelContainer}_DigiHSTruth'
 
    return acc
 
 

◆ TileRawChannelMakerDigiHSTruthOutputCfg()

TileRawChannelMakerDigiHSTruthOutputCfg	(		flags,
			streamName = 'ESD',
		**	kwargs )

Return component accumulator with configured Tile raw channel maker algorithm and Output stream

Arguments:
    flags  -- Athena configuration flags
    streamName -- name of output stream. Defaults to ESD.

Definition at line 157 of file TileRawChannelMakerConfig.py.

def TileRawChannelMakerDigiHSTruthOutputCfg(flags, streamName = 'ESD', **kwargs):
    """Return component accumulator with configured Tile raw channel maker algorithm and Output stream
 
    Arguments:
        flags  -- Athena configuration flags
        streamName -- name of output stream. Defaults to ESD.
    """
 
    acc = TileRawChannelMakerDigiHSTruthCfg(flags, **kwargs)
    acc.merge( TileRawChannelOutputCfg(flags, acc.getPrimary(), streamName) )
 
    return acc
 
 

◆ TileRawChannelMakerOutputCfg()

TileRawChannelMakerOutputCfg	(		flags,
			streamName = 'ESD',
		**	kwargs )

Return component accumulator with configured Tile raw channel maker algorithm and Output stream

Arguments:
    flags  -- Athena configuration flags
    streamName -- name of output stream. Defaults to ESD.

Definition at line 143 of file TileRawChannelMakerConfig.py.

def TileRawChannelMakerOutputCfg(flags, streamName = 'ESD', **kwargs):
    """Return component accumulator with configured Tile raw channel maker algorithm and Output stream
 
    Arguments:
        flags  -- Athena configuration flags
        streamName -- name of output stream. Defaults to ESD.
    """
 
    acc = TileRawChannelMakerCfg(flags, **kwargs)
    acc.merge( TileRawChannelOutputCfg(flags, acc.getPrimary(), streamName) )
 
    return acc
 
 

◆ TileRawChannelOutputCfg()

TileRawChannelOutputCfg	(	flags,
		tileRawChannelMaker,
		streamName )

Return component accumulator with configured Output stream for Tile raw channel maker algorithm

Arguments:
    flags  -- Athena configuration flags
    tileRawChannelMaker -- Tile raw channel maker algorithm
    streamName -- name of output stream.

Definition at line 122 of file TileRawChannelMakerConfig.py.

def TileRawChannelOutputCfg(flags, tileRawChannelMaker, streamName):
    """Return component accumulator with configured Output stream for Tile raw channel maker algorithm
 
    Arguments:
        flags  -- Athena configuration flags
        tileRawChannelMaker -- Tile raw channel maker algorithm
        streamName -- name of output stream.
    """
 
    outputItemList = []
    rawChannelbuilders = tileRawChannelMaker.TileRawChannelBuilder
 
    for rawChannelBuilder in rawChannelbuilders:
        outputItemList += [f'TileRawChannelContainer#{rawChannelBuilder.TileRawChannelContainer}']
 
    from OutputStreamAthenaPool.OutputStreamConfig import OutputStreamCfg
    acc = OutputStreamCfg(flags, streamName, ItemList = outputItemList)
 
    return acc
 
 