Functions
def	TileRawChannelMakerCfg (flags, **kwargs)

def	TileRawChannelMakerDigiHSTruthCfg (flags, **kwargs)

def	TileRawChannelOutputCfg (flags, tileRawChannelMaker, streamName)

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

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

Variables
	flags

	Files

	AtlasVersion

	GlobalTag

	RunType

	doFit

	doOF1

	doWiener

	doOpt2

	doOptATLAS

	correctTimeJumps

	NoiseFilter

	ESDFileName

	MaxEvents

	acc

	readMuRcv

	withDetails

	True

	summariseProps

	sc

Function Documentation

◆ TileRawChannelMakerCfg()

def TileRawChannelMakerConfig.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]:
         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.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)
  
     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()

def TileRawChannelMakerConfig.TileRawChannelMakerDigiHSTruthCfg	(		flags,
		**	kwargs
	)

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

Arguments:
    flags  -- Athena configuration flags

Definition at line 89 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()

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

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

def TileRawChannelMakerConfig.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 110 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
  
  