def __init__(self,
streamName="Stream2",
fileName="HLT.root",
catalog="xmlcatalog_file:Catalog1.xml",
store=None):
import AthenaPoolCnvSvc.WriteAthenaPool
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from PoolSvc.PoolSvcConf import PoolSvc
svcMgr += PoolSvc()
svcMgr.PoolSvc.WriteCatalog = catalog
from AthenaPoolCnvSvc.AthenaPoolCnvSvcConf import AthenaPoolCnvSvc
svcMgr += AthenaPoolCnvSvc()
svcMgr.AthenaPoolCnvSvc.CommitInterval = 10
from OutputStreamAthenaPool.OutputStreamAthenaPool import AthenaPoolOutputConditionStream
self.stream = AthenaPoolOutputConditionStream(streamName)
from AthenaPoolCnvSvc.WriteAthenaPool import AthenaPoolOutputStream
self.stream = AthenaPoolOutputStream(streamName)
self.stream.OutputFile = fileName
if store != None:
self.stream.Store = store
else:
from StoreGate.StoreGateConf import StoreGateSvc
self.stream.Store = StoreGateSvc("DetectorStore")
TrigConditionStream.setItemList(self.stream)
#--------------------------------------------------------------
# Number of events to write
#--------------------------------------------------------------
try:
theApp.EvtMax = EvtMax
except:
theApp.Evtmax = 10
#--------------------------------------------------------------
# POOL support
#--------------------------------------------------------------
include("AthenaPoolCnvSvc/AthenaPool_jobOptions.py")
from PoolSvc.PoolSvcConf import PoolSvc
svcMgr += PoolSvc()
try:
svcMgr.PoolSvc.WriteCatalog = OutCatalog
except:
svcMgr.PoolSvc.WriteCatalog = "xmlcatalog_file:PoolFileCatalog.xml"
#--------------------------------------------------------------
# Input collection type
#--------------------------------------------------------------
try:
inCollType = InCollType
except:
inCollType = "MonteCarlo"
if inCollType == "MonteCarlo":
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]")
rec.doAODCaloCells.set_Value_and_Lock(False)
rec.doCBNT.set_Value_and_Lock(False)
rec.doESD.set_Value_and_Lock(False)
rec.doHist.set_Value_and_Lock(False)
rec.doWriteAOD.set_Value_and_Lock(False)
rec.doWriteESD.set_Value_and_Lock(False)
rec.doWriteTAG.set_Value_and_Lock(False)
rec.doFileMetaData.set_Value_and_Lock(False)
rec.doJiveXML.set_Value_and_Lock(False)
rec.doPerfMon.set_Value_and_Lock(False)
#### jOs from Thijs for spacepoints from ESDs:
#from AthenaCommon.BeamFlags import jobproperties
#from InDetRecExample.InDetJobProperties import InDetFlags
#jobproperties.InDetJobProperties.Enabled.set_Value_and_Lock(True)
#InDetFlags.preProcessing.set_Value_and_Lock(True)
#InDetFlags.doSpacePointFormation.set_Value_and_Lock(True)
# use closest DB replica
from AthenaCommon.AppMgr import ServiceMgr
from PoolSvc.PoolSvcConf import PoolSvc
ServiceMgr += PoolSvc(SortReplicas=True)
from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
ServiceMgr += DBReplicaSvc(UseCOOLSQLite=False)
# main jobOption - must always be included
include("RecExCommon/RecExCommon_topOptions.py")
from SCT_ConditionsTools.SCT_ByteStreamErrorsToolSetup import SCT_ByteStreamErrorsToolSetup
sct_ByteStreamErrorsToolSetup = SCT_ByteStreamErrorsToolSetup()
sct_ByteStreamErrorsToolSetup.setConfigTool(SCT_ConfigurationConditionsTool)
sct_ByteStreamErrorsToolSetup.setup()
SCT_ByteStreamErrorsTool = sct_ByteStreamErrorsToolSetup.getTool()
SCT_ByteStreamErrorsTool.OutputLevel = DEBUG
from SCT_ConditionsAlgorithms.SCT_ConditionsAlgorithmsConf import SCT_ByteStreamErrorsTestAlg
job += SCT_ByteStreamErrorsTestAlg(
ByteStreamErrorsTool=SCT_ByteStreamErrorsTool)
from AthenaCommon.AthenaCommonFlags import athenaCommonFlags
if numThreads >= 2:
from SCT_ConditionsAlgorithms.SCTCondAlgCardinality import sctCondAlgCardinality
sctCondAlgCardinality.set(numThreads)
job.SCT_ByteStreamErrorsTestAlg.Cardinality = numThreads
import AthenaPoolCnvSvc.ReadAthenaPool
from PoolSvc.PoolSvcConf import PoolSvc
ServiceMgr += PoolSvc()
athenaCommonFlags.FilesInput = ["./ESD.pool.root"]
ServiceMgr.EventSelector.InputCollections = athenaCommonFlags.FilesInput.get_Value(
)
theApp.EvtMax = -1
ServiceMgr.MessageSvc.Format = "% F%50W%S%7W%R%T %0W%M"
import AtlasGeoModel.GeoModelInit
from AthenaCommon.AlgSequence import AlgSequence
job = AlgSequence()
from AthenaCommon.AppMgr import ToolSvc
#include("AthenaPoolCnvSvc/AthenaPool_jobOptions.py")
import AthenaPoolCnvSvc.AthenaPool
from AthenaSealSvc.AthenaSealSvcConf import AthenaSealSvc
ServiceMgr += AthenaSealSvc(CheckDictionary=TRUE)
from PoolSvc.PoolSvcConf import PoolSvc
ServiceMgr += PoolSvc(DbOpen="update")
#from OutputStreamAthenaPool.OutputStreamAthenaPoolConf import AthenaPoolOutputStreamTool
#CondStreamPixelDCSTest = AthenaPoolOutputStreamTool("CondStreamPixelDCSTest",OutputFile = "SimplePoolFile.root",OutputLevel = DEBUG)
from AthenaServices.AthenaServicesConf import AthenaOutputStreamTool
CondStreamPixelDCSTest = AthenaOutputStreamTool(
"CondStreamPixelDCSTest",
OutputFile="SimplePoolFile.root",
OutputLevel=MyOutPut)
ToolSvc += CondStreamPixelDCSTest
from PixelConditionsTools.PixelConditionsToolsConf import PixelDCSTool
ToolSvc += PixelDCSTool(
eventTypeList = inputFileSummary.get("evt_type")
if eventTypeList.__contains__("IS_SIMULATION") :
print "Detected that the input file is a simulated dataset"
inputIsSimulation = True
pass
pass
#====================================================================
# Do the good run list (GRL) selection --- only for data
#====================================================================
cmdString_GRL = ""
if not inputIsSimulation :
# use closest DB replica
from PoolSvc.PoolSvcConf import PoolSvc
svcMgr += PoolSvc(SortReplicas=True)
from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
svcMgr += DBReplicaSvc(UseCOOLSQLite=False)
## # Try to copy the GRL locally
## import socket
## socket.setdefaulttimeout(180)
## remoteGRL = D2PDFlags.GRLFile()
## localGRL = "data10_7TeV.pro05.merged_LBSUMM_WZjets_allchannels.xml"
## import urllib
## urllib.urlretrieve( remoteGRL, localGRL )
# Create an instance of the GoodRunsListSelectorTool
from GoodRunsLists.GoodRunsListsConf import *
ToolSvc += GoodRunsListSelectorTool( "GoodRunsListSelectorTool",
OutputLevel = INFO,
