def __init__(self,doOldStyleConfig=False):
"Setup conditions DB - IOVDbSvc and connections according to GlobalFlags"
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaCommon.Logging import logging
self.msg = logging.getLogger( 'IOVDbSvc.CondDB' )
self.msg.debug("Loading basic services for CondDBSetup...")
# AthenaPool and IOVDbSvc configuration
from AthenaPoolCnvSvc import AthenaPool # noqa: F401
from IOVDbSvc import IOVDb # noqa: F401
# local access to IOVDbSvc parameters
self.iovdbsvc=svcMgr.IOVDbSvc
# initialise list of allowed DBs
self.dblist={}
# and list of blocked folders
self.blocklist=[]
# decide which instance to setup
# default database
self.dbname=''
# names for MC and data database in case forceMC/forceData are used
self.dbmc=''
self.dbdata=''
self.poolcats=[]
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
self.isOnline=athenaCommonFlags.isOnline()
self.isMC=not globalflags.DataSource()=='data'
if (globalflags.DetGeo() in ['atlas','commis']):
# ATLAS full or commissioning geometry
self.dbmc='OFLP200'
self.dbdata=globalflags.DatabaseInstance() #could be 'auto'
if self.isMC:
# Monte Carlo
self.dbname=self.dbmc
self.poolcats=['oflcond']
else:
# real data
if (self.dbdata=='auto'):
from RecExConfig.RecFlags import rec
self.dbdata=self._InstanceFromProjectName(rec.projectName())
self.msg.info("Configuring database instance %s based on project tag %s", self.dbdata, rec.projectName())
self.dbname=self.dbdata
self.poolcats=['comcond','oflcond']
elif (globalflags.DetGeo() in ['ctbh8','ctbh6']):
self.dbmc='TMCP200'
self.dbdata='TBDP200'
if self.isMC:
# 2004 combined testbeam, Monte Carlo
self.dbname=self.dbmc
self.poolcats=['tbcond','oflcond']
else:
# 2004 combined testbeam, real data
self.dbname=self.dbdata
self.poolcats=['tbcond','oflcond']
else:
raise RuntimeError("Unknown globalflags.DetGeo: %s" % globalflags.DetGeo())
if (self.dbname!=''):
self.msg.info('Setting up conditions DB access to instance %s', self.dbname)
# set up all access options - online schemas
self._SetAcc('INDET','COOLONL_INDET')
self._SetAcc('INDET_ONL','COOLONL_INDET')
self._SetAcc('PIXEL','COOLONL_PIXEL')
self._SetAcc('PIXEL_ONL','COOLONL_PIXEL')
self._SetAcc('SCT','COOLONL_SCT')
self._SetAcc('SCT_ONL','COOLONL_SCT')
self._SetAcc('TRT','COOLONL_TRT')
self._SetAcc('TRT_ONL','COOLONL_TRT')
self._SetAcc('LAR','COOLONL_LAR')
self._SetAcc('LAR_ONL','COOLONL_LAR')
self._SetAcc('TILE','COOLONL_TILE')
self._SetAcc('TILE_ONL','COOLONL_TILE')
self._SetAcc('MUON','COOLONL_MUON')
self._SetAcc('MUON_ONL','COOLONL_MUON')
self._SetAcc('MUONALIGN','COOLONL_MUONALIGN')
self._SetAcc('MUONALIGN_ONL','COOLONL_MUONALIGN')
self._SetAcc('MDT','COOLONL_MDT')
self._SetAcc('MDT_ONL','COOLONL_MDT')
self._SetAcc('RPC','COOLONL_RPC')
self._SetAcc('RPC_ONL','COOLONL_RPC')
self._SetAcc('TGC','COOLONL_TGC')
self._SetAcc('TGC_ONL','COOLONL_TGC')
self._SetAcc('CSC','COOLONL_CSC')
self._SetAcc('CSC_ONL','COOLONL_CSC')
self._SetAcc('TDAQ','COOLONL_TDAQ')
self._SetAcc('TDAQ_ONL','COOLONL_TDAQ')
self._SetAcc('GLOBAL','COOLONL_GLOBAL')
self._SetAcc('GLOBAL_ONL','COOLONL_GLOBAL')
self._SetAcc('TRIGGER','COOLONL_TRIGGER')
self._SetAcc('TRIGGER_ONL','COOLONL_TRIGGER')
self._SetAcc('CALO','COOLONL_CALO')
self._SetAcc('CALO_ONL','COOLONL_CALO')
self._SetAcc('FWD','COOLONL_FWD')
self._SetAcc('FWD_ONL','COOLONL_FWD')
# set up all access options - offline schemas
# only do this if isOnline flag is NOT set
# or MC flag is set, to allow HLT testing using MC database
if (self.isMC or not self.isOnline):
self._SetAcc('INDET_OFL','COOLOFL_INDET')
self._SetAcc('PIXEL_OFL','COOLOFL_PIXEL')
self._SetAcc('SCT_OFL','COOLOFL_SCT')
self._SetAcc('TRT_OFL','COOLOFL_TRT')
self._SetAcc('LAR_OFL','COOLOFL_LAR')
self._SetAcc('TILE_OFL','COOLOFL_TILE')
self._SetAcc('MUON_OFL','COOLOFL_MUON')
self._SetAcc('MUONALIGN_OFL','COOLOFL_MUONALIGN')
self._SetAcc('MDT_OFL','COOLOFL_MDT')
self._SetAcc('RPC_OFL','COOLOFL_RPC')
self._SetAcc('TGC_OFL','COOLOFL_TGC')
self._SetAcc('CSC_OFL','COOLOFL_CSC')
self._SetAcc('TDAQ_OFL','COOLOFL_TDAQ')
self._SetAcc('DCS_OFL','COOLOFL_DCS')
self._SetAcc('GLOBAL_OFL','COOLOFL_GLOBAL')
self._SetAcc('TRIGGER_OFL','COOLOFL_TRIGGER')
self._SetAcc('CALO_OFL','COOLOFL_CALO')
self._SetAcc('FWD_OFL','COOLOFL_FWD')
else:
self.msg.info('Running in online mode - no access to COOLOFL schemas')
self.iovdbsvc.OnlineMode=True
# setup default connection to localfile, and put in LOCAL symbol
localfile="sqlite://;schema=mycool.db;dbname="
self.dblist['LOCAL']=localfile
self.iovdbsvc.dbConnection=localfile+self.dbname
# setup knowledge of dbinstance in IOVDbSvc, for global tag x-check
self.iovdbsvc.DBInstance=self.dbname
# setup DBReplicaSvc to veto DBRelease SQLite files if real data
if not self.isMC:
from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
svcMgr+=DBReplicaSvc(COOLSQLiteVetoPattern="/DBRelease/")
# enable Frontier cache alignment if it looks like Frontier will
# be used (via FRONTIER_SERVER variable)
if 'FRONTIER_SERVER' in os.environ.keys() and os.environ['FRONTIER_SERVER']!="":
self.iovdbsvc.CacheAlign=3
# setup PoolSvc catalogues
from PoolSvc.PoolSvcConf import PoolSvc
if not hasattr (svcMgr, 'PoolSvc'):
svcMgr+=PoolSvc()
# add the standard catalogues
for i in self.poolcats:
svcMgr.PoolSvc.ReadCatalog+=["prfile:poolcond/PoolCat_%s.xml" % i]
# also add entries which will be resolved using ATLAS_POOLCOND_PATH
# (if set) - the actual resolution is done inside PoolSvc C++
for i in self.poolcats:
svcMgr.PoolSvc.ReadCatalog+=["apcfile:poolcond/PoolCat_%s.xml" % i]
svcMgr.PoolSvc.ReadCatalog+=["apcfile:poolcond/PoolFileCatalog.xml"]
else:
raise RuntimeError('Not enough configuration information to setup ConditionsDB access (are GlobalFlags being used?)')
self.msg.debug("Loading basic services for CondDBSetup... [DONE]")
def configure(self):
mlog = logging.getLogger( 'Py:LArRawChannelGetter::configure %s:' % self.__class__ )
from AthenaCommon.AlgSequence import AlgSequence
topSequence = AlgSequence()
from AthenaCommon.AppMgr import ToolSvc
# get LArDigitGetter in MC case
from AthenaCommon.DetFlags import DetFlags
if DetFlags.digitize.LAr_on() :
try:
from LArDigitization.LArDigitGetter import LArDigitGetter
theLArDigitGetter = LArDigitGetter()
except Exception as configException:
mlog.error("could not get handle to LArDigitGetter Quit")
import traceback
mlog.error(traceback.format_exc())
return False
if not theLArDigitGetter.usable():
mlog.error("LArDigitGetter unusable. Quite")
return False
from LArROD.LArRODFlags import larRODFlags
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource()=='data' or larRODFlags.forceIter() :
# ADC2MeV tool
from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault
theADC2MeVTool = LArADC2MeVToolDefault()
ToolSvc += theADC2MeVTool
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
# Data case
if larRODFlags.readDigits():
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat() == 'bytestream':
if not larRODFlags.keepDSPRaw():
topSequence.LArRawDataReaderAlg.LArRawChannelKey=""
if globalflags.DetGeo() == 'ctbh6' or globalflags.DetGeo() == 'ctbh8':
from LArROD.LArRODConf import LArRawChannelBuilder
theLArRawChannelBuilder=LArRawChannelBuilder()
topSequence += theLArRawChannelBuilder
return True
from LArROD.LArRODConf import LArRawChannelBuilderDriver
theLArRawChannelBuilder=LArRawChannelBuilderDriver("LArRawChannelBuilder")
topSequence += theLArRawChannelBuilder
if larRODFlags.keepDSPRaw():
theLArRawChannelBuilder.LArRawChannelContainerName=larRODFlags.RawChannelFromDigitsContainerName()
# bad channel masking if required
if not larRODFlags.doBuildBadChannel():
# The first tool filters out bad channels
from LArROD.LArRODConf import LArRawChannelBuilderToolBadChannelTool
theLArRawChannelBuilderToolBadChannel=LArRawChannelBuilderToolBadChannelTool()
from LArBadChannelTool.LArBadChannelToolConf import LArBadChannelMasker
theLArRCBMasker=LArBadChannelMasker("LArRCBMasker")
theLArRCBMasker.DoMasking=True
theLArRCBMasker.ProblemsToMask=[
"deadReadout","deadPhys","almostDead","short",
"lowNoiseHG","highNoiseHG","unstableNoiseHG",
"lowNoiseMG","highNoiseMG","unstableNoiseMG",
"lowNoiseLG","highNoiseLG","unstableNoiseLG"
]
theLArRawChannelBuilderToolBadChannel.BadChannelMask=theLArRCBMasker
theLArRawChannelBuilder.BuilderTools += [theLArRawChannelBuilderToolBadChannel]
ToolSvc+=theLArRawChannelBuilderToolBadChannel
# Pulse reconstruction
# main method: OFC iteration
from LArROD.LArRODConf import LArRawChannelBuilderToolOFCIter
theLArRawChannelBuilderToolOFCIter=LArRawChannelBuilderToolOFCIter()
theLArRawChannelBuilderToolOFCIter.minSample = 2
theLArRawChannelBuilderToolOFCIter.maxSample = 12
theLArRawChannelBuilderToolOFCIter.minADCforIterInSigma=4 # ADCmax at least 4 sigma above noise for iteration
theLArRawChannelBuilderToolOFCIter.minADCforIter=15 # min adc for iteration (only if no pedestalRMS found)
theLArRawChannelBuilderToolOFCIter.defaultPhase=0 # starting delay, also the fixed delay for ADC below min.
theLArRawChannelBuilderToolOFCIter.ECut=250. # Energy to save quality
theLArRawChannelBuilder.BuilderTools += [theLArRawChannelBuilderToolOFCIter]
theLArRawChannelBuilder+=theLArRawChannelBuilderToolOFCIter
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback(1): cubic method
from LArROD.LArRODConf import LArRawChannelBuilderToolCubic
theLArRawChannelBuilderToolCubic=LArRawChannelBuilderToolCubic()
theLArRawChannelBuilderToolCubic.minADCforCubic=30
theLArRawChannelBuilder.BuilderTools += [theLArRawChannelBuilderToolCubic]
theLArRawChannelBuilder += theLArRawChannelBuilderToolCubic
# fallback(2) averageing
from LArROD.LArRODConf import LArRawChannelBuilderToolAverage
theLArRawChannelBuilderToolAverage=LArRawChannelBuilderToolAverage()
theLArRawChannelBuilderToolAverage.NScan=0
theLArRawChannelBuilder.BuilderTools += [theLArRawChannelBuilderToolAverage]
theLArRawChannelBuilder += theLArRawChannelBuilderToolAverage
# Pedestal
# main method from database
from LArROD.LArRODConf import LArRawChannelBuilderPedestalDataBase
theLArRawChannelBuilderPedestalDataBase=LArRawChannelBuilderPedestalDataBase()
theLArRawChannelBuilderPedestalDataBase.LArPedestalKey = "LArPedestal"
theLArRawChannelBuilder.PedestalTools = [theLArRawChannelBuilderPedestalDataBase]
theLArRawChannelBuilder += theLArRawChannelBuilderPedestalDataBase
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback. sample 0
from LArROD.LArRODConf import LArRawChannelBuilderPedestalSampleZero
theLArRawChannelBuilderPedestalSampleZero=LArRawChannelBuilderPedestalSampleZero()
theLArRawChannelBuilder.PedestalTools += [theLArRawChannelBuilderPedestalSampleZero]
theLArRawChannelBuilder += theLArRawChannelBuilderPedestalSampleZero
# ADC to energy
# main method from database
from LArROD.LArRODConf import LArRawChannelBuilderADC2EDataBase
theLArRawChannelBuilderADC2EDataBase=LArRawChannelBuilderADC2EDataBase()
theLArRawChannelBuilder.ADCtoEnergyTools = [theLArRawChannelBuilderADC2EDataBase]
theLArRawChannelBuilderADC2EDataBase.ADC2MeVTool = theADC2MeVTool
theLArRawChannelBuilder += theLArRawChannelBuilderADC2EDataBase
# no fallback when emulating exactly DSP computation
if not larRODFlags.doDSP():
# fallback, constant conversion factors
from LArROD.LArRODConf import LArRawChannelBuilderADC2EConstants
theLArRawChannelBuilderADC2EConstants=LArRawChannelBuilderADC2EConstants()
theLArRawChannelBuilder.ADCtoEnergyTools += [theLArRawChannelBuilderADC2EConstants]
theLArRawChannelBuilder += theLArRawChannelBuilderADC2EConstants
#more tools to be configured
from LArRecUtils.LArRecUtilsConf import LArOFPeakRecoTool
theLArOFPeakRecoTool=LArOFPeakRecoTool()
from LArConditionsCommon.LArCondFlags import larCondFlags
theLArOFPeakRecoTool.UseShape=larCondFlags.useShape()
if larCondFlags.LArCoolChannelSelection.statusOn:
if len(larCondFlags.LArCoolChannelSelection())>0:
theLArOFPeakRecoTool.forceHighGain=larCondFlags.useOFCOnlyCoolChannelSelection()
ToolSvc += theLArOFPeakRecoTool
#
# adjust default timing to match first sample information written in cool from Lar online configuration
#
nominalPeakSample=2
if globalflags.DataSource()=='data':
from LArConditionsCommon.LArCool import larcool
if (larcool is not None):
nominalPeakSample = larcool.firstSample()
# don't use ramp intercept in calibration if gain type is not auto
if larcool.gainType() > 0 :
mlog.info(" Gain Type: %d don't use intercept in ADC to Energy ramp calibration",larcool.gainType())
theLArRawChannelBuilderADC2EDataBase.UseHighGainRampIntercept = False
theLArRawChannelBuilderADC2EDataBase.UseMedGainRampIntercept = False
theLArRawChannelBuilderADC2EDataBase.UseLowGainRampIntercept = False
else :
mlog.info(" Gain Type: %d use intercept in ADC to energy ramp calibraion ",larcool.gainType())
if (nominalPeakSample > 1) :
theLArRawChannelBuilder.DefaultShiftTimeSample=nominalPeakSample-2
else :
theLArRawChannelBuilder.DefaultShiftTimeSample=0
theLArRawChannelBuilder.DataLocation = "FREE"
else:
from AthenaCommon.GlobalFlags import globalflags
if globalflags.InputFormat() == 'bytestream':
if not "LArRawChannelContainer/LArRawChannels" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames+=["LArRawChannelContainer/LArRawChannels"]
# In the case of DSP monitoring and reading rawchannels, need to give a different name to the LArRawChannels container
# read from the bytestream ...
# This name has to be coherent with the name in LArMonTools/LArRODMonTool_jobOptions.py
if larRODFlags.doDSP() and larRODFlags.readRawChannels(): #Reading LArRawChannel
print ("Reading RawChannels in DSP physics mode")
# !!! The name of the LArRawChannels container read from the Bytestream is LArRawChannels_fB !!!
if not "LArRawChannelContainer/LArRawChannels_fB" in svcMgr.ByteStreamAddressProviderSvc.TypeNames:
svcMgr.ByteStreamAddressProviderSvc.TypeNames+=["LArRawChannelContainer/LArRawChannels_fB"]
print (svcMgr.ByteStreamAddressProviderSvc.TypeNames)
else:
# MC Case
try:
from AthenaCommon import CfgGetter
topSequence += CfgGetter.getAlgorithm("LArRawChannelBuilder", tryDefaultConfigurable=True)
except Exception as cfgException:
mlog.error("Failed to retrieve LArRawChannelBuilder. Quit")
import traceback
mlog.error(traceback.format_exc())
return False
return True
# IOVRecExTB.py - setup IOVDbSvc for RecExTB
# combined testbeam analysis with data or Monte Carlo
log.warning("IOVDbSvc/IOVRecExTB.py - This file is obselete; conditions DB access should automatically be configured from detector geometry")
from AthenaCommon.GlobalFlags import globalflags
if (globalflags.DetGeo() in ['ctbh8','ctbh6']):
from IOVDbSvc.CondDB import conddb
else:
raise RuntimeError,'IOVRecExTB.py included but geometry is not CTB'
# IOVRecExCommon.py - setup IOVDbSvc for RecExCommon
# Full ATLAS Monte Carlo setup
log.warning(
"IOVDbSvc/IOVRecExCommon.py - This file is obselete; conditions DB access should automatically be configured from detector geometry"
)
from AthenaCommon.GlobalFlags import globalflags
if (globalflags.DetGeo() == 'atlas'):
from IOVDbSvc.CondDB import conddb
else:
raise RuntimeError, 'IOVRecExCommon.py included but geometry is not atlas'
)
CaloCellMakerFlags.doCompactCellInstead = doCompactCellInstead
CaloCellMakerFlags.doCompactCellInAddition = doCompactCellInAddition
# set sensible defaults according to global tags
CaloCellMakerFlags.makeCellFromRawChannel = False
CaloCellMakerFlags.makeCellFromDigit = False
CaloCellMakerFlags.doLArHitToCellDirect = False
CaloCellMakerFlags.doTileHitToRawChannelDirect = False
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource() == 'data':
if globalflags.DetGeo() == 'ctb':
CaloCellMakerFlags.makeCellFromDigit = True
if globalflags.DataSource() == 'geant3' and globalflags.InputFormat(
) == 'zebra':
# for geant3 digitisation of all calo is needed
DetFlags.digitize.Calo_setOn()
# usually use fast digitisation for lar
CaloCellMakerFlags.doLArHitToCellDirect = True
# usually use slow digitisation for tile
CaloCellMakerFlags.doTileHitToRawChannelDirect = False
CaloCellMakerFlags.makeCellFromDigit = True
elif globalflags.DataSource() == 'geant3' or globalflags.DataSource(
) == 'geant4':
# on geant4 usually run on raw channel file
CaloCellMakerFlags.makeCellFromRawChannel = True
# IOVRecExCommission.py - setup IOVDbSvc for RecExCommissionMC
# commissioning with Monte Carlo
log.warning(
"IOVDbSvc/IOVRecExCommissionMC.py - This file is obselete; conditions DB access should automatically be configured from detector geometry"
)
from AthenaCommon.GlobalFlags import globalflags
if (globalflags.DetGeo() == 'commis' and globalflags.DataSource() != 'data'):
from IOVDbSvc.CondDB import conddb
else:
raise RuntimeError, 'IOVRecExCommissionMC.py included but geometry is not commis / Monte Carlo'
def CaloNoiseToolDefault(flag='',name='CaloNoiseToolDefault'):
# check if tool already exists
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
if hasattr(svcMgr.ToolSvc, name):
# re-use previously configured (public) tool
return getattr(svcMgr.ToolSvc, name)
mlog = logging.getLogger( 'CaloNoiseToolDefault' )
if flag=='db' :
_useDB = True
elif flag=='tool' :
_useDB = False
else :
# will put here logic to select according to global flag
from AthenaCommon.GlobalFlags import globalflags
from AthenaCommon.BeamFlags import jobproperties
if globalflags.DataSource()=='data' and globalflags.DetGeo()!='ctbh6' and globalflags.DetGeo()!='ctbh8':
_useDB = True
elif globalflags.DataSource()=='geant4' and jobproperties.Beam.zeroLuminosity():
_useDB = True
else:
# now uses also calonoisetoolDB for MC with pileup.. requires a new global tag for pileup reco to have the noise properly read
_useDB = True
if _useDB :
mlog.info(" Using CaloNoiseToolDB" )
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource()=='data':
from CaloTools.CaloNoiseToolDBData import CaloNoiseToolDBData
theTool = CaloNoiseToolDBData(name)
else:
from CaloTools.CaloNoiseToolDBMC import CaloNoiseToolDBMC
theTool = CaloNoiseToolDBMC(name)
return theTool
else :
mlog.info("Using CaloNoiseTool")
from CaloTools.CaloToolsConf import CaloNoiseTool
# Tile configuration
from AthenaCommon.DetFlags import DetFlags
if DetFlags.Tile_on():
from TileConditions.TileInfoConfigurator import TileInfoConfigurator
tileInfoConfigurator = TileInfoConfigurator()
tileInfoConfigurator.setupCOOL()
UseTile = True
else:
UseTile = False
# CaloNoiseTool configuration
WorkMode=1
WithOF=True
TileInfoName="TileInfo"
# get public tool LArADC2MeVTool
from LArRecUtils.LArADC2MeVToolDefault import LArADC2MeVToolDefault
theADC2MeVTool = LArADC2MeVToolDefault()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += theADC2MeVTool
# get public tool LArOFCTool
from LArRecUtils.LArOFCToolDefault import LArOFCToolDefault
theOFCTool = LArOFCToolDefault()
from AthenaCommon.AppMgr import ToolSvc
ToolSvc += theOFCTool
from AthenaCommon.BeamFlags import jobproperties
if jobproperties.Beam.zeroLuminosity():
ReturnNoise="electronicNoise"
NMinBias=0
deltaBunch=1
else:
ReturnNoise="totalNoise"
NMinBias=jobproperties.Beam.numberOfCollisions()
deltaBunch=int(jobproperties.Beam.bunchSpacing()/( 25.*ns)+0.5)
from AthenaCommon.GlobalFlags import globalflags
if globalflags.DataSource()=='data':
IsMC = False
UseSymmetry= False
else:
IsMC = True
UseSymmetry= True
from LArROD.LArRODFlags import larRODFlags
theTool = CaloNoiseTool(name,
WorkMode = WorkMode,
WithOF = WithOF,
UseTile = UseTile,
TileInfoName = TileInfoName,
LArADC2MeVTool = theADC2MeVTool,
LArOFCTool = theOFCTool,
ReturnNoise = ReturnNoise,
NMinBias = NMinBias,
deltaBunch = deltaBunch,
IsMC = IsMC,
UseSymmetry = UseSymmetry,
firstSample=larRODFlags.firstSample())
return theTool
def configure(self):
log = logging.getLogger("TriggerConfigGetter.py")
# first check the input
if "HIT2RDO" in self._environment:
TriggerFlags.doLVL2 = False
TriggerFlags.doEF = False
log.info("For simulation jobs the following flags are set:")
log.info("globalflags.InputFormat : %s" %
globalflags.InputFormat())
log.info("globalflags.DataSource : %s" %
globalflags.DataSource())
log.info("TriggerFlags.configForStartup : %s" %
TriggerFlags.configForStartup())
log.info("TriggerFlags.dataTakingConditions : %s" %
TriggerFlags.dataTakingConditions())
log.info("TriggerFlags.doLVL2 : %s" %
TriggerFlags.doLVL2())
log.info("TriggerFlags.doEF : %s" %
TriggerFlags.doEF())
else:
if not self.checkInput():
log.error(
"Could not determine job input. Can't setup trigger configuration and will return!"
)
return
self.readPool = globalflags.InputFormat() == 'pool'
self.readRDO = rec.readRDO()
self.writeESDAOD = rec.doWriteESD() or rec.doWriteAOD(
) or rec.doWriteDPD()
self.ConfigSrcList = TriggerFlags.configurationSourceList()
self.readMC = globalflags.DataSource(
) == 'geant3' or globalflags.DataSource() == 'geant4'
self.readTriggerDB = TriggerFlags.readMenuFromTriggerDb(
) and self.readRDO
self.isCommisioning = globalflags.DataSource(
) == 'data' and globalflags.DetGeo() == 'commis'
self.l1Folders = TriggerFlags.dataTakingConditions(
) == 'FullTrigger' or TriggerFlags.dataTakingConditions() == 'Lvl1Only'
self.hltFolders = TriggerFlags.dataTakingConditions(
) == 'FullTrigger' or TriggerFlags.dataTakingConditions() == 'HltOnly'
self.isRun1Data = False
if globalflags.DataSource() == 'data':
from RecExConfig.AutoConfiguration import GetRunNumber
runNumber = GetRunNumber()
if runNumber > 0 and runNumber < 230000:
self.isRun1Data = True
self.isTriggerReprocessing = False
# the TriggerFlags.readMenuFromTriggerDb() tells us that we read the trigger menu from the database
# the connection itself is defined in TriggerFlags.triggerDbConnection()
# reading from the TriggerDB can mean different things:
# a) TriggerFlags doLVL2() and doEF() are both False:
# - create a tmp sqlite file with the conditions (menu)
# - use DSConfigSvc
# b) TriggerFlags doLVL2() or doEF() is True:
# - use HLTConfigSvc
if self.readTriggerDB and (TriggerFlags.doLVL2()
or TriggerFlags.doEF()
or TriggerFlags.doHLT()):
self.ConfigSrcList = [
'xml'
] # to use L1/HLTConfigSvc and not DSConfigSvc, but only if we are running the HLT
if self._environment: # I don't think anyone calls TriggerConfigGetter with an argument
self.readPool = False
self.writeESDAOD = False
self.readHits = False
if "ReadPoolRDO" in self._environment:
self.readPool = True
self.readRDO = True
elif "ReadPool" in self._environment:
self.readPool = True
self.readRDO = False
if "WritePool" in self._environment:
self.writeESDAOD = True
if "HIT2RDO" in self._environment:
self.readRDO = False
self.readHits = True
# define ConfigSvc
if not self.ConfigSrcList:
if (self.readPool and not self.readRDO) or (
self.readRDO
and not self.readPool): # (ESD, AOD, DPD) or (RDO-BS)
self.ConfigSrcList = ['ds']
elif (self.readRDO and self.readPool
) or rec.readTAG() or self.readHits: # (RDO-MC) or TAG
self.ConfigSrcList = ['xml']
else: # should not get here: should be found by checkInput
log.fatal('no reading of BS, RDO, AOD, ESD, or TAG specified')
# we need the temporary COOL database, if we read the configuration from XML and write ESD/AOD (or have 'ds' set for some reason)
self.makeTempCool = self.readRDO and \
( self.writeESDAOD or 'ds' in self.ConfigSrcList ) and \
( self.readMC \
or (self.isCommisioning and (TriggerFlags.readLVL1configFromXML() and TriggerFlags.readHLTconfigFromXML())) \
or TriggerFlags.readMenuFromTriggerDb() )
log.info("Need to create temporary cool file? : %r" %
self.makeTempCool)
log.info('Creating the Trigger Configuration Services')
self.svc = SetupTrigConfigSvc()
#set the merged system
#self.svc.doMergedHLT = TriggerFlags.doHLT()
if 'xml' in self.ConfigSrcList or self.makeTempCool:
# sets them if plain XML reading is to be used
self.svc.l1topoXmlFile = TriggerFlags.outputL1TopoConfigFile(
) # generated in python
self.svc.l1XmlFile = TriggerFlags.outputLVL1configFile(
) # generated in python
self.svc.hltXmlFile = TriggerFlags.outputHLTconfigFile(
) # generated in python
if TriggerFlags.readL1TopoConfigFromXML():
self.svc.l1topoXmlFile = TriggerFlags.inputL1TopoConfigFile(
) # given XML
if TriggerFlags.readLVL1configFromXML():
self.svc.l1XmlFile = TriggerFlags.inputLVL1configFile(
) # given XML
if TriggerFlags.readHLTconfigFromXML():
self.svc.hltXmlFile = TriggerFlags.inputHLTconfigFile(
) # given XML
### preparations are done!
try:
self.svc.SetStates(self.ConfigSrcList)
except:
log.error('Failed to set state of TrigConfigSvc to %r' %
self.ConfigSrcList)
else:
log.info('The following configuration services will be tried: %r' %
self.ConfigSrcList)
try:
self.svc.InitialiseSvc()
except Exception, ex:
log.error('Failed to activate TrigConfigSvc: %r' % ex)
def configure(self):
log = logging.getLogger( "TriggerConfigGetter.py" )
from PyUtils.MetaReaderPeekerFull import metadata
# first check the input
if "HIT2RDO" in self._environment:
TriggerFlags.doLVL2 = False
TriggerFlags.doEF = False
log.info("For simulation jobs the following flags are set:")
log.info("globalflags.InputFormat : %s", globalflags.InputFormat())
log.info("globalflags.DataSource : %s", globalflags.DataSource())
log.info("TriggerFlags.configForStartup : %s", TriggerFlags.configForStartup())
log.info("TriggerFlags.dataTakingConditions : %s", TriggerFlags.dataTakingConditions())
log.info("TriggerFlags.doLVL2 : %s", TriggerFlags.doLVL2())
log.info("TriggerFlags.doEF : %s", TriggerFlags.doEF())
else:
if not self.checkInput():
log.error("Could not determine job input. Can't setup trigger configuration and will return!")
return
# self.checkInput() may call TriggerConfigCheckMetadata, this can in turn set "rec.doTrigger.set_Value_and_Lock(False)"
# but TriggerConfigGetter might have only been called in the first place due to this flag having been true,
# so re-check that we're still OK to be executing here
if not (recAlgs.doTrigger() or rec.doTrigger() or TriggerFlags.doTriggerConfigOnly()):
log.info("Aborting TriggerConfigGetter as the trigger flags were switched to false in checkInput()")
return True
self.readPool = globalflags.InputFormat() == 'pool'
self.readRDO = rec.readRDO()
self.writeESDAOD = rec.doWriteESD() or rec.doWriteAOD() or rec.doWriteDPD()
self.writeAOD = rec.doWriteAOD() or rec.doWriteDPD()
self.ConfigSrcList = TriggerFlags.configurationSourceList()
self.readMC = globalflags.DataSource()=='geant3' or globalflags.DataSource()=='geant4'
self.readTriggerDB = TriggerFlags.readMenuFromTriggerDb() and self.readRDO
self.isCommisioning = globalflags.DataSource()=='data' and globalflags.DetGeo()=='commis'
self.l1Folders = TriggerFlags.dataTakingConditions()=='FullTrigger' or TriggerFlags.dataTakingConditions()=='Lvl1Only'
self.hltFolders = TriggerFlags.dataTakingConditions()=='FullTrigger' or TriggerFlags.dataTakingConditions()=='HltOnly'
self.isRun1Data = False
self.hasxAODMeta = ("metadata_items" in metadata and any(('TriggerMenu' in key) for key in metadata["metadata_items"].keys()))
if globalflags.DataSource()=='data':
from RecExConfig.AutoConfiguration import GetRunNumber
runNumber = GetRunNumber()
if runNumber is not None and runNumber > 0 and runNumber < 230000 :
self.isRun1Data = True
self.isTriggerReprocessing = False
# the TriggerFlags.readMenuFromTriggerDb() tells us that we read the trigger menu from the database
# the connection itself is defined in TriggerFlags.triggerDbConnection()
# reading from the TriggerDB can mean different things:
# a) TriggerFlags doLVL2() and doEF() are both False:
# - create a tmp sqlite file with the conditions (menu)
# - use DSConfigSvc
# b) TriggerFlags doLVL2() or doEF() is True:
# - use HLTConfigSvc
if self.readTriggerDB and (TriggerFlags.doLVL2() or TriggerFlags.doEF() or TriggerFlags.doHLT()):
self.ConfigSrcList = ['xml'] # to use L1/HLTConfigSvc and not DSConfigSvc, but only if we are running the HLT
if self._environment: # I don't think anyone calls TriggerConfigGetter with an argument
self.readPool = False
self.writeESDAOD = False
self.readHits = False
if "ReadPoolRDO" in self._environment:
self.readPool = True
self.readRDO = True
elif "ReadPool" in self._environment:
self.readPool = True
self.readRDO = False
if "WritePool" in self._environment:
self.writeESDAOD = True
if "HIT2RDO" in self._environment:
self.readRDO = False
self.readHits = True
# define ConfigSvc
if not self.ConfigSrcList:
if (self.readPool and not self.readRDO) or (self.readRDO and not self.readPool): # (ESD, AOD, DPD) or (RDO-BS)
self.ConfigSrcList = ['ds']
elif (self.readRDO and self.readPool) or rec.readTAG() or self.readHits: # (RDO-MC) or TAG
self.ConfigSrcList = ['xml']
else: # should not get here: should be found by checkInput
log.fatal('no reading of BS, RDO, AOD, ESD, or TAG specified')
# we need the temporary COOL database, if we read the configuration from XML and write ESD/AOD (or have 'ds' set for some reason)
self.makeTempCool = self.readRDO and \
( self.writeESDAOD or 'ds' in self.ConfigSrcList ) and \
( self.readMC \
or (self.isCommisioning and (TriggerFlags.readLVL1configFromXML() and TriggerFlags.readHLTconfigFromXML())) \
or TriggerFlags.readMenuFromTriggerDb() )
log.info("Need to create temporary cool file? : %r", self.makeTempCool)
log.info('Creating the Trigger Configuration Services')
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
########################################################################
# START OF TEMPORARY SOLUTION FOR RUN-3 TRIGGER DEVELOPMENT
########################################################################
from TriggerJobOpts.HLTTriggerResultGetter import EDMDecodingVersion
EDMDecodingVersion() # In most use cases this needs to be called much earlier than in HLTTriggerResultGetter
if TriggerFlags.EDMDecodingVersion() >= 3:
if self.hasxAODMeta:
if not hasattr(svcMgr, 'xAODConfigSvc'):
from TrigConfxAOD.TrigConfxAODConf import TrigConf__xAODConfigSvc
svcMgr += TrigConf__xAODConfigSvc('xAODConfigSvc')
else: # Does not have xAODMeta
# Run-3 Trigger Configuration Services
from TrigConfigSvc.TrigConfigSvcCfg import getL1ConfigSvc, getHLTConfigSvc
from AthenaConfiguration.AllConfigFlags import ConfigFlags
svcMgr += getL1ConfigSvc(ConfigFlags)
svcMgr += getHLTConfigSvc(ConfigFlags)
# Needed for TrigConf::xAODMenuWriterMT
from TrigConfigSvc.TrigConfigSvcConfig import TrigConfigSvc
svcMgr += TrigConfigSvc("TrigConfigSvc")
svcMgr.TrigConfigSvc.PriorityList = ["none", "ds", "xml"]
else:
# non-MT (Run-2) Trigger Configuration
self.svc = SetupTrigConfigSvc()
if 'xml' in self.ConfigSrcList or self.makeTempCool:
# sets them if plain XML reading is to be used
self.svc.l1topoXmlFile = TriggerFlags.outputL1TopoConfigFile() # generated in python
self.svc.l1XmlFile = TriggerFlags.outputLVL1configFile() # generated in python
self.svc.hltXmlFile = TriggerFlags.outputHLTconfigFile() # generated in python
if TriggerFlags.readL1TopoConfigFromXML():
self.svc.l1topoXmlFile = TriggerFlags.inputL1TopoConfigFile() # given XML
if TriggerFlags.readLVL1configFromXML():
self.svc.l1XmlFile = TriggerFlags.inputLVL1configFile() # given XML
if TriggerFlags.readHLTconfigFromXML():
self.svc.hltXmlFile = TriggerFlags.inputHLTconfigFile() # given XML
try:
self.svc.SetStates( self.ConfigSrcList )
except Exception:
log.error( 'Failed to set state of TrigConfigSvc to %r', self.ConfigSrcList )
else:
log.info('The following configuration services will be tried: %r', self.ConfigSrcList )
try:
self.svc.InitialiseSvc()
except Exception as ex:
log.error( 'Failed to activate TrigConfigSvc: %r', ex )
########################################################################
# END OF TEMPORARY SOLUTION FOR RUN-3 TRIGGER DEVELOPMENT
########################################################################
if self.readTriggerDB:
log.info( "Using TriggerDB connection '%s'", TriggerFlags.triggerDbConnection() )
self.trigDbConnectionParameters = interpretConnection(TriggerFlags.triggerDbConnection(), resolveAlias=False)
self.setConfigSvcConnParams(self.trigDbConnectionParameters)
log.info("TriggerFlags.triggerCoolDbConnection is '%s' [default: '']", TriggerFlags.triggerCoolDbConnection())
TrigCoolDbConnection = TriggerFlags.triggerCoolDbConnection()
if self.makeTempCool:
TrigCoolDbConnection = self.setupTempCOOLWriting(TrigCoolDbConnection)
if ('ds' in self.ConfigSrcList) and not self.hasxAODMeta:
self.setupCOOLReading(TrigCoolDbConnection)
if hasattr(svcMgr, 'DSConfigSvc'):
db = 'TRIGGERDB'
if self.isRun1Data:
db = 'TRIGGERDB_RUN1'
elif self.readMC:
db = 'TRIGGERDBMC'
elif self.isTriggerReprocessing:
db = 'TRIGGERDBREPR'
svcMgr.DSConfigSvc.ConfigSource = 'dblookup'
svcMgr.DSConfigSvc.DBServer = db
log.info("DSConfigSvc trigger database is '%s'", db)
if not self.hasxAODMeta:
self.setupxAODWriting()
# all went fine we are configured
return True
