python.TileConfigFlags Namespace Reference

Classes
class	TileRunType

Functions
def	createTileConfigFlags ()
def	_doOpt2ByDefault (prevFlags)
def	_doExtraMethods (prevFlags)
def	_doOpt2 (prevFlags)
def	_doOptATLAS (prevFlags)
def	_zeroAmplitudeWithoutDigits (prevFlags)
def	_correctPedestalDifference (prevFlags)
def	_correctTimeJumps (prevFlags)
def	_getRunType (prevFlags)
def	_useDCS (prevFlags)
def	_getRawChannelContainer (prevFlags)
def	getRawChannelContainerOptATLAS (flags)

Variables
	flags
	Files

Function Documentation

_correctPedestalDifference()

def python.TileConfigFlags._correctPedestalDifference (   prevFlags )

private

Definition at line 160 of file TileConfigFlags.py.

def _correctPedestalDifference(prevFlags):
     if not prevFlags.Common.isOnline:
          return _zeroAmplitudeWithoutDigits(prevFlags)
     else:
          return False
 
 

_correctTimeJumps()

def python.TileConfigFlags._correctTimeJumps (   prevFlags )

private

Definition at line 167 of file TileConfigFlags.py.

def _correctTimeJumps(prevFlags):
     if not (prevFlags.Input.isMC or prevFlags.Overlay.DataOverlay) and prevFlags.Input.Format is Format.BS:
          return True
     else:
          return False
 
 

_doExtraMethods()

def python.TileConfigFlags._doExtraMethods (   prevFlags )

private

Definition at line 112 of file TileConfigFlags.py.

def _doExtraMethods(prevFlags):
     # Check if any Optimal Filter, but Opt2 and OptATLAS, is already scheduled
     if (prevFlags.Tile.doQIE or prevFlags.Tile.doManyAmps or prevFlags.Tile.doFlat
         or prevFlags.Tile.doFit or prevFlags.Tile.doFitCOOL or prevFlags.Tile.doMF
         or prevFlags.Tile.doOF1 or prevFlags.Tile.doWiener):
          return True
     else:
          return False
 

_doOpt2()

def python.TileConfigFlags._doOpt2 (   prevFlags )

private

Definition at line 121 of file TileConfigFlags.py.

def _doOpt2(prevFlags):
     # Do not run Opt2 method if any Optimal Filter is already scheduled
     if _doExtraMethods(prevFlags) :
          return False
     # If no extra Optimal Filters are scheduled yet check if Opt2 should be used by default
     else:
          if _doOpt2ByDefault(prevFlags):
               _flags = prevFlags.clone()
               _flags.Tile.doOpt2 = True
               # Opt2 should be run by default, but check if OptATLAS is already scheduled
               return not _flags.Tile.doOptATLAS
          else:
               return False
 
 

_doOpt2ByDefault()

def python.TileConfigFlags._doOpt2ByDefault (   prevFlags )

private

Definition at line 91 of file TileConfigFlags.py.

def _doOpt2ByDefault(prevFlags):
      #For online operation don't check run number
     if prevFlags.Common.isOnline:
          if prevFlags.Beam.Type is BeamType.Collisions:
               return False  # Use OF without iterations for collisions
          else:
               return True
 
     runNumber = prevFlags.Input.RunNumbers[0]
     # Run Optimal Filter with iterations (Opt2) by default,
     # both for cosmics and collisions data before 2011
     if not prevFlags.Input.isMC and runNumber > 0 and runNumber < 171194:
          return True
     # Run Optimal Filter without iterations (OptATLAS)
     # for collisions (data in 2011 and later and MC)
     elif prevFlags.Beam.Type is BeamType.Collisions:
          return False  # Use OF without iterations for collisions
     else:
          return True
 
 

_doOptATLAS()

def python.TileConfigFlags._doOptATLAS (   prevFlags )

private

Definition at line 136 of file TileConfigFlags.py.

def _doOptATLAS(prevFlags):
     # Do not run OptATLAS method if any Optimal Filter is alredy scheduled
     if _doExtraMethods(prevFlags) :
          return False
     # If no Optimal Filters are scheduled yet check if OptATLAS should be used by default
     else:
          if not _doOpt2ByDefault(prevFlags):
               # OptATLAS should be run by default, but check if Opt2 is already scheduled
               _flags = prevFlags.clone()
               _flags.Tile.doOptATLAS = True
               return not _flags.Tile.doOpt2
          else:
               return False
 
 

_getRawChannelContainer()

def python.TileConfigFlags._getRawChannelContainer (   prevFlags )

private

Definition at line 192 of file TileConfigFlags.py.

def _getRawChannelContainer(prevFlags):
 
     rawChannelContainer = 'UNDEFINED'
 
     if prevFlags.Tile.doQIE:
          rawChannelContainer = 'TileRawChannelQIE'
     if prevFlags.Tile.doManyAmps:
          rawChannelContainer = 'TileRawChannelManyAmp'
     if prevFlags.Tile.doFlat:
          rawChannelContainer = 'TileRawChannelFlat'
     if prevFlags.Tile.doFit:
          rawChannelContainer = 'TileRawChannelFit'
     if prevFlags.Tile.doFitCOOL:
          rawChannelContainer = 'TileRawChannelFitCool'
     if prevFlags.Tile.doMF:
          rawChannelContainer = 'TileRawChannelMF'
     if prevFlags.Tile.doOF1:
          rawChannelContainer = 'TileRawChannelOF1'
     if prevFlags.Tile.doWiener:
          rawChannelContainer = 'TileRawChannelWiener'
     if prevFlags.Tile.doOpt2:
          rawChannelContainer = 'TileRawChannelOpt2'
     if prevFlags.Tile.doOptATLAS:
          rawChannelContainer = getRawChannelContainerOptATLAS(prevFlags)
 
     return rawChannelContainer
 
 

_getRunType()

def python.TileConfigFlags._getRunType (   prevFlags )

private

Definition at line 174 of file TileConfigFlags.py.

def _getRunType(prevFlags):
     # Tile run types: UNDEFINED, PHY, PED, LAS, BILAS, CIS, MONOCIS
     from AthenaConfiguration.AutoConfigFlags import GetFileMD
     if not prevFlags.Input.isMC and 'calibration_Tile' in GetFileMD(prevFlags.Input.Files).get('triggerStreamOfFile', ''):
          return TileRunType.UNDEFINED
     else:
          return TileRunType.PHY
 
 

_useDCS()

def python.TileConfigFlags._useDCS (   prevFlags )

private

Definition at line 183 of file TileConfigFlags.py.

def _useDCS(prevFlags):
     if not (prevFlags.Common.isOnline or prevFlags.Input.isMC):
          runNumber = prevFlags.Input.RunNumbers[0]
          # Use Tile DCS only for 2011 data and later, excluding shutdown period
          return (runNumber > 171194 and runNumber < 222222) or runNumber > 232498
     else:
          return False
 
 

_zeroAmplitudeWithoutDigits()

def python.TileConfigFlags._zeroAmplitudeWithoutDigits (   prevFlags )

private

Definition at line 151 of file TileConfigFlags.py.

def _zeroAmplitudeWithoutDigits(prevFlags):
     if not prevFlags.Input.isMC:
          runNumber = prevFlags.Input.RunNumbers[0]
          # Use OF1 corrections only for years 2015 - 2016
          return runNumber > 269101 and runNumber < 324320
     else:
          return False
 
 

createTileConfigFlags()

def python.TileConfigFlags.createTileConfigFlags

(

)

Definition at line 47 of file TileConfigFlags.py.

def createTileConfigFlags():
 
     tcf = AthConfigFlags()
 
     tcf.addFlag('Tile.doQIE', False)
     tcf.addFlag('Tile.doManyAmps', False)
     tcf.addFlag('Tile.doFlat', False)
     tcf.addFlag('Tile.doFit', False)
     tcf.addFlag('Tile.doFitCOOL', False)
     tcf.addFlag('Tile.doMF', False)
     tcf.addFlag('Tile.doOF1', False)
     tcf.addFlag('Tile.doWiener', False)
     tcf.addFlag('Tile.doOpt2', _doOpt2)
     tcf.addFlag('Tile.doOptATLAS', _doOptATLAS)
     tcf.addFlag('Tile.NoiseFilter', lambda prevFlags : -1 if prevFlags.Input.isMC else 1)
     tcf.addFlag('Tile.RunType', _getRunType, type=TileRunType)
     tcf.addFlag('Tile.correctTime', lambda prevFlags : not prevFlags.Input.isMC and not prevFlags.Overlay.DataOverlay and prevFlags.Beam.Type is BeamType.Collisions)
     tcf.addFlag('Tile.correctTimeNI', True)
     tcf.addFlag('Tile.correctAmplitude', True)
     tcf.addFlag('Tile.AmpMinForAmpCorrection', 15.0)
     tcf.addFlag('Tile.TimeMinForAmpCorrection', lambda prevFlags : (prevFlags.Beam.BunchSpacing / -2.))
     tcf.addFlag('Tile.TimeMaxForAmpCorrection', lambda prevFlags : (prevFlags.Beam.BunchSpacing / 2.))
     tcf.addFlag('Tile.OfcFromCOOL', True)
     tcf.addFlag('Tile.BestPhaseFromCOOL', lambda prevFlags : not prevFlags.Input.isMC and not prevFlags.Overlay.DataOverlay and prevFlags.Beam.Type is BeamType.Collisions)
     tcf.addFlag('Tile.readDigits', lambda prevFlags : not prevFlags.Input.isMC)
     tcf.addFlag('Tile.doOverflowFit', True)
     tcf.addFlag('Tile.zeroAmplitudeWithoutDigits', _zeroAmplitudeWithoutDigits)
     tcf.addFlag('Tile.correctPedestalDifference', _correctPedestalDifference)
     tcf.addFlag('Tile.correctTimeJumps', _correctTimeJumps)
     tcf.addFlag('Tile.RawChannelContainer', _getRawChannelContainer)
     tcf.addFlag('Tile.useDCS', _useDCS)
     tcf.addFlag('Tile.doTimingHistogramsForGain', -1) # Production of Tile timing histograms per channel (< 0: switched off)
     tcf.addFlag('Tile.doTimingHistogramsForCell', {'LBA14':['A4','B6','D1'],'LBA22':['A4','B6','D1'],'EBA22':['A13','B12','D5']}) # Production of Tile timing histograms per selected cells ({}: switched off)
     tcf.addFlag('Tile.useOnlineChannelStatus', True) # Use online DB with channel/adc status
 
     def __tilesim():
          from TileConfiguration.TileSimConfigFlags import createTileSimConfigFlags
          return createTileSimConfigFlags()
     tcf.addFlagsCategory('Tile.Sim', __tilesim, prefix=True)
 
     return tcf
 
 
 

getRawChannelContainerOptATLAS()

def python.TileConfigFlags.getRawChannelContainerOptATLAS

(

flags

)

Definition at line 220 of file TileConfigFlags.py.

def getRawChannelContainerOptATLAS(flags):
     if not (flags.Input.isMC or flags.Overlay.DataOverlay) and flags.Input.Format is Format.BS:
          return 'TileRawChannelFixed'
     else:
          return 'TileRawChannelCnt'
 
 

Variable Documentation

Files

python.TileConfigFlags.Files

Definition at line 232 of file TileConfigFlags.py.

flags

python.TileConfigFlags.flags

Definition at line 231 of file TileConfigFlags.py.