TileDigitsFlxMonitorAlgorithm Namespace Reference

Functions
def	TileDigitsFlxMonitoringConfig (flags, fragIDs=[0x201, 0x402], topPath='TestBeam', **kwargs)

Function Documentation

TileDigitsFlxMonitoringConfig()

def TileDigitsFlxMonitorAlgorithm.TileDigitsFlxMonitoringConfig	(		flags,
			fragIDs = [0x201, 0x402],
			topPath = 'TestBeam',
		**	kwargs
	)

Function to configures TileDigitsFlxMonAlg algorithms in the monitoring system.

Definition at line 10 of file TileDigitsFlxMonitorAlgorithm.py.

def TileDigitsFlxMonitoringConfig(flags, fragIDs=[0x201, 0x402], topPath='TestBeam', **kwargs):
    '''Function to configures TileDigitsFlxMonAlg algorithms in the monitoring system.'''
 
    kwargs.setdefault('TileDigitsContainerLegacy', 'TileDigitsCnt')
    kwargs.setdefault('TileDigitsContainerFlx', 'TileDigitsFlxCnt')
    kwargs.setdefault('FirstSample', 0)
    kwargs.setdefault('LastSample', 15)
    kwargs.setdefault('FelixOffset', 0)
    kwargs.setdefault('FelixScale', 4)
 
    felixScale = kwargs['FelixScale']
 
    from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
    result = ComponentAccumulator()
 
    from TileConditions.TileCablingSvcConfig import TileCablingSvcCfg
    result.merge( TileCablingSvcCfg(flags) )
 
    from AthenaMonitoring import AthMonitorCfgHelper
    helper = AthMonitorCfgHelper(flags, 'TileDigitsFlxMonitoring')
 
    from AthenaConfiguration.ComponentFactory import CompFactory
    TileDigitsFlxMonitorAlgorithm = CompFactory.TileDigitsFlxMonitorAlgorithm
    tileDigitsFlxMonAlg = helper.addAlgorithm(TileDigitsFlxMonitorAlgorithm, 'TileDigitsFlxMonAlg')
    tileDigitsFlxMonAlg.TriggerChain = ''
 
    for k, v in kwargs.items():
        setattr(tileDigitsFlxMonAlg, k, v)
 
    # Configure histogram with TileDigitsFlxMonAlg algorithm execution time
    executeTimeGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileDigitsFlxMonExecuteTime', f'{topPath}/Felix')
    executeTimeGroup.defineHistogram('TIME_execute', path = 'Digits', type='TH1F',
                                     title = 'Time for execute TileDigitsFlxMonAlg algorithm;time [#mus]',
                                     xbins = 300, xmin = 0, xmax = 300000)
 
    runNumber = flags.Input.RunNumbers[0]
    from TileCalibBlobObjs.Classes import TileCalibUtils as Tile
 
    modules = []
    if fragIDs:
        for fragID in fragIDs:
            ros = fragID >> 8
            drawer = fragID & 0x3F
            modules += [Tile.getDrawerString(ros, drawer)]
    else:
        for ros in range(1, Tile.MAX_ROS):
            for drawer in range(0, Tile.MAX_DRAWER):
                modules += [Tile.getDrawerString(ros, drawer)]
 
    channelHFNGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileFlxMonHFN', f'{topPath}/Felix/Digits')
    for moduleName in modules:
        for gainName in ['HG', 'LG']:
            title = f'Run {runNumber} {moduleName} {gainName}: Mean RMS in event (HFN)-FELIX;Channel;HFN'
            name = f'{moduleName}_{gainName}_channel,{moduleName}_{gainName}_HFN;{moduleName}_HFN_{gainName}'
            path = moduleName
            channelHFNGroup.defineHistogram(name, title = title, path = path, type = 'TProfile',
                                            xbins = 48, xmin = -0.5, xmax = 47.5)
 
    channelPedGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileFlxMonPed', f'{topPath}/Felix/Digits')
    for moduleName in modules:
        for gainName in ['HG', 'LG']:
            title = f'Run {runNumber} {moduleName} {gainName}: Pedestal, sample[0]-FELIX;Channel;ADC'
            name = f'{moduleName}_{gainName}_channel,{moduleName}_{gainName}_Pedestal;{moduleName}_Pedestal_{gainName}'
            path = moduleName
            channelPedGroup.defineHistogram(name, title = title, path = path, type = 'TProfile',
                                            xbins = 48, xmin = -0.5, xmax = 47.5)
 
    channelHFNGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileLegacyMonHFN', f'{topPath}/Legacy/Digits')
    for moduleName in modules:
        for gainName in ['HG', 'LG']:
            title = f'Run {runNumber} {moduleName} {gainName}: Mean RMS in event (HFN);Channel;HFN'
            name = f'{moduleName}_{gainName}_channel,{moduleName}_{gainName}_HFN;{moduleName}_HFN_{gainName}'
            path = moduleName
            channelHFNGroup.defineHistogram(name, title = title, path = path, type = 'TProfile',
                                            xbins = 48, xmin = -0.5, xmax = 47.5)
 
    channelPedGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileLegacyMonPed', f'{topPath}/Legacy/Digits')
    for moduleName in modules:
        for gainName in ['HG', 'LG']:
            title = f'Run {runNumber} {moduleName} {gainName}: Pedestal, sample[0];Channel;ADC'
            name = f'{moduleName}_{gainName}_channel,{moduleName}_{gainName}_Pedestal;{moduleName}_Pedestal_{gainName}'
            path = moduleName
            channelPedGroup.defineHistogram(name, title = title, path = path, type = 'TProfile',
                                            xbins = 48, xmin = -0.5, xmax = 47.5)
 
    channelSamplesFlxGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileFlxMonSamples', f'{topPath}/Felix/Digits')
    for moduleName in modules:
        for channel in range(0, Tile.MAX_CHAN):
            for gainName in ['HG', 'LG']:
                title = (f'Run {runNumber} {moduleName} channel {channel} {gainName}: Samples-FELIX;Sample [ADC];N')
                name = f'{moduleName}_ch_{str(channel)}_{gainName}_samples'
                path = moduleName
                channelSamplesFlxGroup.defineHistogram(name, title = title, path = path, type = 'TH1F',
                                                       xbins = 4096, xmin = -0.5, xmax = 4095.5)
 
 
    channelSamplesLegacyGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileLegacyMonSamples', f'{topPath}/Legacy/Digits')
    for moduleName in modules:
        for channel in range(0, Tile.MAX_CHAN):
            for gainName in ['HG', 'LG']:
                title = (f'Run {runNumber} {moduleName} channel {channel} {gainName}: Samples;Sample [ADC];N')
                name = f'{moduleName}_ch_{str(channel)}_{gainName}_samples'
                path = moduleName
                channelSamplesLegacyGroup.defineHistogram(name, title = title, path = path, type = 'TH1F',
                                                          xbins = 1024, xmin = -0.5, xmax = 1023.5)
 
    channelAllSamplesDiffGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileChannelAllSamplesDiff', f'{topPath}/Compare/Digits')
    for moduleName in modules:
        for channel in range(0, Tile.MAX_CHAN):
            for gainName in ['HG', 'LG']:
                title = (f'Run {runNumber} {moduleName} channel {channel} {gainName}: Samples difference (FELIX-Legacy*{felixScale});Sample [ADC];N')
                name = f'{moduleName}_ch_{str(channel)}_{gainName}_samples_diff'
                path = moduleName
                channelAllSamplesDiffGroup.defineHistogram(name, title = title, path = path, type = 'TH1F',
                                                           xbins = 200, xmin = -100, xmax = 100)
 
    moduleAllSamplesGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileModuleAllSamplesDiff', f'{topPath}/Compare/Digits')
    for moduleName in modules:
        for gainName in ['HG', 'LG']:
            title = (f'Run {runNumber} {moduleName} {gainName}: All channels samples difference (FELIX-Legacy*{felixScale});Sample [ADC];N')
            name = f'{moduleName}_{gainName}_samples_diff;{moduleName}_{gainName}_all_channels_samples_diff'
            path = moduleName
            moduleAllSamplesGroup.defineHistogram(name, title = title, path = path, type = 'TH1F',
                                                  xbins = 200, xmin = -100, xmax = 100)
 
    moduleSamplesDiffGroup = helper.addGroup(tileDigitsFlxMonAlg, 'TileModuleSamplesDiff', f'{topPath}/Compare/Digits')
    for moduleName in modules:
        for gainName in ['HG', 'LG']:
            title = f'Run {runNumber} {moduleName} {gainName}: Samples difference (FELIX-Legacy*{felixScale});Channel;ADC'
            name = f'{moduleName}_{gainName}_channel,{moduleName}_{gainName}_samples_diff;{moduleName}_{gainName}_samples_diff'
            path = moduleName
            moduleSamplesDiffGroup.defineHistogram(name, title = title, path = path, type = 'TProfile',
                                                   xbins = 48, xmin = -0.5, xmax = 47.5)
 
 
    accumalator = helper.result()
    result.merge(accumalator)
    return result