AtlasTest/DatabaseTest/AthenaDBTestRec/scripts/ReadReal.py

-#!/bin/env python
-
-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-#
-import sys,os,traceback,time,commands,getopt
-from PyCool import cool
-from CoolConvUtilities.AtlCoolLib import indirectOpen
-
-def testRun(globaltag,run,tofs,nevt,deltat,configfile,debug=0):
-    "Execute the test run with given parameters"
-    print "Simulate tag %s run %i with %i events time increment %i" % (globaltag,run,nevt,deltat)
-
-    starttime=time.time()
-    # find run start time from SORParams folder
-    tdaqDB=indirectOpen('COOLONL_TDAQ/COMP200',oracle=True)
-    if (tdaqDB is None):
-        print "ERROR: Cannot connect to COOLONL_TDAQ/COMP200"
-        return 1
-    sortime=0
-    try:
-        tdaqfolder=tdaqDB.getFolder('/TDAQ/RunCtrl/SOR_Params')
-        runiov=run << 32
-        obj=tdaqfolder.findObject(runiov,0)
-        payload=obj.payload()
-        sortime=payload['SORTime']/1.E9+tofs
-    except Exception,e:
-        print "ERROR accessing /TDAQ/RunCtrl/SOR_Params"
-        print e
-    tdaqDB.closeDatabase()
-    print "Starttime is %i (%s)" % (sortime,time.asctime(time.gmtime(sortime)))
-
-    # now run Athena job
-    iovsvcdbg=3
-    if (debug>=2): iovsvcdbg=2
-    
-    jofile=open('condtestjobopts.py','w')
-    jofile.write("""import AthenaCommon.AtlasUnixGeneratorJob
-from AthenaCommon.AlgSequence import AlgSequence
-topSequence=AlgSequence()
-from AthenaCommon.AppMgr import ServiceMgr as svcMgr
-#--------------------------------------------------------------
-# Load POOL support
-#--------------------------------------------------------------
-import AthenaPoolCnvSvc.AthenaPool
-
-#--------------------------------------------------------------
-# Access to IOVSvc, IOVDbSvc
-#--------------------------------------------------------------
-from AthenaCommon.GlobalFlags import globalflags 
-globalflags.DetGeo.set_Value_and_Lock('atlas') 
-globalflags.DataSource.set_Value_and_Lock('data')
-from IOVDbSvc.CondDB import conddb
-conddb.iovdbsvc.OutputLevel=%i
-conddb.iovdbsvc.GlobalTag='%s'
-        
-# setup DBReplicaSvc
-from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
-svcMgr+=DBReplicaSvc(UseCOOLSQLite=False)
-
-#--------------------------------------------------------------
-# Private Application Configuration options
-#--------------------------------------------------------------
-from AthenaDBTestRec.AthenaDBTestRecConf import TestCoolRecRead
-theTestCoolRecRead=TestCoolRecRead(OutputLevel=INFO)
-topSequence+=theTestCoolRecRead
-#--------------------------------------------------------------
-# Set the following when reading back to adjust the run/event numbers
-# and timestampsjob
-svcMgr.EventSelector.RunNumber         = %i
-svcMgr.EventSelector.EventsPerRun      = 999999
-svcMgr.EventSelector.FirstEvent        = 1
-# initial time stamp - this is number of seconds since 1st Jan 1970 GMT
-svcMgr.EventSelector.InitialTimeStamp  = %i
-# increment of 3 minutes
-svcMgr.EventSelector.TimeStampInterval = %i
-theApp.EvtMax                   = %i
-
-svcMgr.MessageSvc.infoLimit        = 100000
-svcMgr.MessageSvc.debugLimit        = 100000
-
-# include file to set FolderList
-include('%s')
-# remove some folders known to cause trouble (as DetDescr not loaded)
-badfolders=['/LAR/Identifier/OnOffIdAtlas','/LAR/Identifier/FebRodAtlas','/LAR/Identifier/LArTTCellMapAtlas','/CALO/Identifier/CaloTTOnOffIdMapAtlas','/CALO/Identifier/CaloTTOnAttrIdMapAtlas']
-
-for i in range(0,len(FolderList)):
-  folder=FolderList[i]
-  ignore=False
-  for j in badfolders:
-    if folder.find(j)>=0: ignore=True
-  if (ignore):
-    print "Suppressing folder",folder
-  else:
-    svcMgr.IOVDbSvc.Folders+=[folder]
-print "Processing",len(svcMgr.IOVDbSvc.Folders),"of",len(FolderList),"folders"
-
-""" % (iovsvcdbg,globaltag,run,sortime,deltat,nevt,configfile) )
-
-    jofile.close()
-
-    comm='athena.py condtestjobopts.py '
-    if (debug==0):
-        comm+=' >& log'
-    else:
-        comm+=' |tee log'
-    print 'About to execute',comm
-    # execute Athena job 
-    athenarc=os.system(comm)
-    # athenarc=0
-    print 'Return code from athena=',athenarc
-
-    # analysis of job based on status codes from Tier-0 test
-    retcode=0
-    # tail logfile if we did not print whole thing
-    if (debug==0):
-        print 'End of logfile follows ...'
-        (s,o)=commands.getstatusoutput('tail -n 200 log')
-        print o
-    if (athenarc!=0):
-        retcode=62600
-    else:
-        # extract summary line from logfile
-        (s,msg)=commands.getstatusoutput('grep TestCoolRecReadSummary log')
-        opmsg=msg[msg.find('TestCoolRecReadSummary:')+24:]
-        print 'Extracted output message:',opmsg
-        if (opmsg!='All folders OK'):
-            retcode=65000
-
-    print '>== All done, return code',retcode,'time taken is',time.time()-starttime
-    return retcode
-
-if __name__=='__main__':
-    def usage():
-        print "Script for running COOL test workloads based on real conditions data and reconstruction jobs"
-        print "Usage",sys.argv[0],'{<options>} <configfile.py> <globaltag> <run> {<timeoffset> <nevt> <deltat>}'
-        print "<configfile.py> gets included and should define FolderList"
-        print "<globaltag> specifies the global conditions tag"
-        print "<run> specifies the run number to be used when retrieving"
-        print "<timeoffset> specifies an offset (in seconds) into the run for DCS data"
-        print "<nevt> can be used to process >1 event (defaut 1)"
-        print "<deltat> specifies the time advance between events (in seconds)"
-        print "Options are:"
-        print "--help : Print this help"
-        print "--debug=<level> : Enable full log file (1) + IOVDbSvc debug (2)"
-        print
-        print "Example:",sys.argv[0],'--debug 1 ../config/Tier0Cosmic2.py COMCOND-ES1C-000-00 91389'
-        sys.exit(-1)
-    try:
-        longopts=['debug=','help']
-        opts,args=getopt.getopt(sys.argv[1:],'',longopts)
-    except getopt.GetoptError,e:
-        print e
-        usage()
-        sys.exit(-1)
-    debug=0
-    # process optional arguments
-    for o,a in opts:
-        if (o=='--help'):
-            usage()
-            sys.exit(0)
-        if (o=='--debug'):
-            debug=int(a)
-    # check there are enough arguments
-    if len(args)<3:
-        usage()
-        sys.exit(-1)
-    configfile=str(args[0])
-    globaltag=str(args[1])
-    run=int(args[2])
-    tofs=0
-    nevt=1
-    deltat=1
-    if len(args)>3:
-        tofs=int(args[3])
-    if len(args)>4:
-        nevt=int(args[4])
-    if len(args)>4:
-        deltat=int(args[5])
-    retcode=testRun(globaltag,run,tofs,nevt,deltat,configfile,debug)
-    sys.exit(retcode)

AtlasTest/DatabaseTest/AthenaDBTestRec/scripts/ReadRun.py

-#!/bin/env python
-
-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-#
-import sys,os,traceback,time,commands,getopt
-
-def testRun(dbid,run,nevt,deltat,configfiles,debug=0):
-    "Execute the test run with given parameters"
-    if dbid=="":
-        dbid='logical:X:ATLAS_COOLONL_GLOBAL:STRM200'
-    starttime=time.time()
-    time0=run*3600
-        
-    print ">== Data will be read from database connection",dbid
-    # generate configuration for folders
-    cfiles=[]
-    i=0
-    for configfile in configfiles:
-        print '>==  Generate config for file',configfile
-        comm='TestCoolRecWriter.exe \"'+dbid+'\" 2 '+configfile
-        print 'Execute command:',comm
-        rc=os.system(comm)
-        if (rc!=0):print 'Non-zero return code',rc,'from TestCoolRecWriter'
-        # add suffix CoolReadConfig.py file
-        filen='CoolReadConfig_'+str(i)+'.py'
-        os.system('mv CoolReadConfig.py %s' % filen)
-        cfiles+=[ filen ]
-        i+=1
-    
-    # now run Athena job
-    print cfiles
-    iovsvcdbg=3
-    if (debug>=2): iovsvcdbg=2
-    
-    jofile=open('condtestjobopts.py','w')
-    jofile.write("""import AthenaCommon.AtlasUnixGeneratorJob
-from AthenaCommon.AlgSequence import AlgSequence
-topSequence=AlgSequence()
-from AthenaCommon.AppMgr import ServiceMgr as svcMgr
-#--------------------------------------------------------------
-# Load POOL support
-#--------------------------------------------------------------
-import AthenaPoolCnvSvc.AthenaPool
-
-#--------------------------------------------------------------
-# Access to IOVSvc, IOVDbSvc
-#--------------------------------------------------------------
-import IOVDbSvc.IOVDb
-svcMgr.IOVDbSvc.OutputLevel        = %i
-svcMgr.IOVDbSvc.ManageConnections=False
-
-# setup DBReplicaSvc
-PoolSvc=Service("PoolSvc")
-PoolSvc.SortReplicas=True
-from DBReplicaSvc.DBReplicaSvcConf import DBReplicaSvc
-svcMgr+=DBReplicaSvc(UseCOOLSQLite=False)
-
-#--------------------------------------------------------------
-# Private Application Configuration options
-#--------------------------------------------------------------
-from AthenaDBTestRec.AthenaDBTestRecConf import TestCoolRecRead
-theTestCoolRecRead=TestCoolRecRead(OutputLevel=INFO)
-topSequence+=theTestCoolRecRead
-#--------------------------------------------------------------
-# Set the following when reading back to adjust the run/event numbers
-# and timestampsjob
-svcMgr.EventSelector.RunNumber         = %i
-svcMgr.EventSelector.EventsPerRun      = 999999
-svcMgr.EventSelector.FirstEvent        = 1
-# initial time stamp - this is number of seconds since 1st Jan 1970 GMT
-svcMgr.EventSelector.InitialTimeStamp  = %i
-# increment of 3 minutes
-svcMgr.EventSelector.TimeStampInterval = %i
-theApp.EvtMax                   = %i
-
-svcMgr.MessageSvc.infoLimit        = 100000
-svcMgr.MessageSvc.debugLimit        = 100000
-
-#
-""" % (iovsvcdbg,run,time0,deltat,nevt) )
-
-    jofile.close()
-
-    comm='athena.py condtestjobopts.py '
-    for i in cfiles: comm+=i+' '
-    if (debug==0):
-        comm+=' >& log'
-    else:
-        comm+=' |tee log'
-    print 'About to execute',comm
-    # execute Athena job 
-    athenarc=os.system(comm)
-    print 'Return code from athena=',athenarc
-
-    # analysis of job based on status codes from Tier-0 test
-    retcode=0
-    # tail logfile if we did not print whole thing
-    if (debug==0):
-        print 'End of logfile follows ...'
-        (s,o)=commands.getstatusoutput('tail -n 100 log')
-        print o
-    if (athenarc!=0):
-        retcode=62600
-    else:
-        # extract summary line from logfile
-        (s,msg)=commands.getstatusoutput('grep TestCoolRecReadSummary log')
-        opmsg=msg[msg.find('TestCoolRecReadSummary:')+24:]
-        print 'Extracted output message:',opmsg
-        if (opmsg!='All folders OK'):
-            retcode=65000
-
-    print '>== All done, return code',retcode,'time taken is',time.time()-starttime
-    return retcode
-
-if __name__=='__main__':
-    def usage():
-        print "Script for running COOL test workloads"
-        print "Usage",sys.argv[0],'{<options>} \"DbIbString\" <run> <nevt> <deltat> <config1> { <config2> ...}'
-        print "Options are:"
-        print "--help : Print this help"
-        print "--debug=<level> : Enable full log file (1) + IOVDbSvc debug (2)"
-        sys.exit(-1)
-    try:
-        longopts=['debug=','help']
-        opts,args=getopt.getopt(sys.argv[1:],'',longopts)
-    except getopt.GetoptError,e:
-        print e
-        usage()
-        sys.exit(-1)
-    debug=0
-    # process optional arguments
-    for o,a in opts:
-        if (o=='--help'):
-            usage()
-            sys.exit(0)
-        if (o=='--debug'):
-            debug=int(a)
-    # check there are enough arguments
-    if len(args)<5:
-        usage()
-        sys.exit(-1)
-    dbid=args[0]
-    if (dbid==""):
-        dbid='logical:X:ATLAS_COOLONL_GLOBAL:STRM200'
-    run=int(args[1])
-    nevt=int(args[2])
-    deltat=int(args[3])
-    retcode=testRun(dbid,run,nevt,deltat,args[4:],debug)
-    sys.exit(retcode)

AtlasTest/DatabaseTest/AthenaDBTestRec/scripts/WriteRun.py

-#!/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-#
-import sys,os,traceback,time
-
-if len(sys.argv)<4:
-    print "Usage",sys.argv[0],'\"DbIbString\" <run> <config1> <config2>'
-    sys.exit(-1)
-
-dbid=sys.argv[1]
-run=int(sys.argv[2])
-time0=run*3600
-starttime=time.time()
-print ">== Data will be written to database connection",dbid
-
-for i in range(0,len(sys.argv)-3):
-    configfile=sys.argv[3+i]
-    print '>== Write data for run',run,'start time',time0,'config file',configfile
-    comm='TestCoolRecWriter.exe \"'+dbid+'\" 1 '+configfile+' 1 '+str(run)+' 720000 '+str(time0)+ ' 3600'
-    print 'Execute command:',comm
-    rc=os.system(comm)
-    if (rc!=0):print 'Non-zero return code',rc,'from TestCoolRecWriter'
-print '>== All done, time taken is',time.time()-starttime
-

AtlasTest/DatabaseTest/AthenaDBTestRec/scripts/gen_refdb.sh

-#/bin/ksh
-# gen_refdb.sh <config> <connectionstring>
-#
-# e.g. for a local SQLite
-#  gen_refdb.sh refc1301 "sqlite:X:refc1301.db:REFC1301"
-# for Oracle
-#  gen_refdb.sh refc1301 "oracle:server:schema:dbname:user:passwd"
-#
-CFILE=../config/${1}.txt
-echo Generate reference conditions DB with all IOVs valid from file $CFILE
-TestCoolRecWriter.exe $2 1 $CFILE 0
-echo All done

AtlasTest/DatabaseTest/AthenaDBTestRec/scripts/gen_tier0test.py

-#!/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-#
-# wrapper to run TestCoolRecWriter with a given confiyration file (assumed
-# to be in ../config/ directory) to produce a joboption file for Athena
-# and a set of single run databases for Tier0 test
-# Typically to be used in a run subdirectory of the package
-# ../scripts/gen_tier0test.py ti0c1301 10
-#
-import sys
-import os
-import traceback
-
-if len(sys.argv) < 3:
-    print "usage", sys.argv[0],'<configfile> <nrun>'
-    sys.exit(-1)
-
-config=sys.argv[1]
-nrun=sys.argv[2]
-dbname="TI0C1301"
-
-for irun in range(0,int(nrun)):
-  isrun=str(irun)
-  jofile=config+"_jobOptions.py"
-  dbfile="sqlite/"+config+"_r"+isrun+".db"
-
-  if (irun==0):
-    print "Generate Athena joboptions in",jofile
-    os.system("export POOL_OUTMSG_LEVEL=E;TestCoolRecWriter.exe \"sqlite:X:"+dbfile+":"+dbname+"\" 2 ../config/"+config+".txt 1 "+isrun+" 10000 0 3600")
-    os.system("mv CoolReadConfig.py "+jofile)
-
-  print "Generate database file",dbfile
-  os.system("export POOL_OUTMSG_LEVEL=E;TestCoolRecWriter.exe \"sqlite:X:"+dbfile+":"+dbname+"\" 1 ../config/"+config+".txt 1 "+isrun+" 10000 0 3600")
-
-print "All done"

AtlasTest/DatabaseTest/AthenaDBTestRec/scripts/gendb.py

-#!/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-#
-# wrapper to run TestCoolRecWriter with a given confiyration file (assumed
-# to be in ../config/ directory) to produce a joboption file for Athena
-# and a database in sqlite subdirectory
-# Typically to be used in a run subdirectory of the package
-#
-import sys
-import os
-import traceback
-
-if len(sys.argv) < 2:
-    print "usage", sys.argv[0],'<configfile> <nrun>'
-    sys.exit(-1)
-
-config=sys.argv[1]
-nrun=sys.argv[2]
-
-jofile=config+"_r"+nrun+"_jobOptions.py"
-dbfile="sqlite/"+config+"_r"+nrun+".db"
-
-print "Generate Athena joboptions in",jofile
-os.system("export POOL_OUTMSG_LEVEL=E;TestCoolRecWriter.exe \"sqlite:X:"+dbfile+":TESTDB\" 2 ../config/"+config+".txt "+nrun+" 10000 730000 0 3600")
-os.system("mv CoolReadConfig.py "+jofile)
-
-print "Generate database file",dbfile
-os.system("export POOL_OUTMSG_LEVEL=E;TestCoolRecWriter.exe \"sqlite:X:"+dbfile+":TESTDB\" 1 ../config/"+config+".txt "+nrun+" 10000 730000 0 3600")
-
-print "Done - filesize:"
-os.system("ls -lL "+dbfile)
-

AtlasTest/DatabaseTest/AthenaDBTestRec/scripts/gendb_intr.py

-#!/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-#
-# wrapper to run TestCoolRecWriter with a given confiyration file (assumed
-# to be in ../config/ directory) to produce a joboption file for Athena
-# and a database in sqlite subdirectory
-# Typically to be used in a run subdirectory of the package
-#
-import sys
-import os
-import traceback
-
-if len(sys.argv) < 4:
-    print "usage", sys.argv[0],'<configfile> <nrun> <schema> <passwd>'
-    sys.exit(-1)
-
-config=sys.argv[1]
-nrun=sys.argv[2]
-schema=sys.argv[3]
-passwd=sys.argv[4]
-
-jofile=config+"_r"+nrun+"_intr_jobOptions.py"
-dbstr="\"oracle:INTR:"+schema+":TESTDB:"+schema+":"+passwd+"\""
-
-print "Generate Athena joboptions in",jofile
-os.system("export POOL_OUTMSG_LEVEL=E;TestCoolRecWriter.exe "+dbstr+" 2 ../config/"+config+".txt "+nrun+" 10000 730000 0 36")
-os.system("mv CoolReadConfig.py "+jofile)
-
-print "Fill Oracle database"
-os.system("export POOL_OUTMSG_LEVEL=E;TestCoolRecWriter.exe "+dbstr+" 1 ../config/"+config+".txt "+nrun+" 10000 730000 0 36")
-
-print "Done"
-
-

AtlasTest/DatabaseTest/AthenaDBTestRec/share/DetStoreDump_jobOptions.py

-# enable DetStoreDump algorithm to do SG dump of detector store
-# include this at end of joboptions so it is last in list
-from AthenaCommon.AlgSequence import AlgSequence
-topSequence=AlgSequence()
-from AthenaDBTestRec.AthenaDBTestRecConf import DetStoreDump
-# set mode to zero to only dump after initialize, not after first event
-theDetStoreDump=DetStoreDump(Mode=1)
-topSequence+=theDetStoreDump

AtlasTest/DatabaseTest/AthenaDBTestRec/share/ReadRefDBExample.py

-###############################################################
-#
-# Job options file for ReadRefDBExample.py
-# Reads a reference COOL data sample from INTR database
-#
-#==============================================================
-import AthenaCommon.AtlasUnixGeneratorJob
-from AthenaCommon.AlgSequence import AlgSequence
-topSequence=AlgSequence()
-from AthenaCommon.AppMgr import ServiceMgr as svcMgr
-#--------------------------------------------------------------
-# Load POOL support
-#--------------------------------------------------------------
-import AthenaPoolCnvSvc.AthenaPool
-
-#--------------------------------------------------------------
-# Access to IOVSvc, IOVDbSvc
-#--------------------------------------------------------------
-import IOVDbSvc.IOVDb
-svcMgr.IOVDbSvc.OutputLevel        = 3
-svcMgr.IOVDbSvc.ManageConnections=False
-
-#--------------------------------------------------------------
-# Private Application Configuration options
-#--------------------------------------------------------------
-from AthenaDBTestRec.AthenaDBTestRecConf import TestCoolRecRead
-theTestCoolRecRead=TestCoolRecRead(OutputLevel=INFO)
-topSequence+=theTestCoolRecRead
-
-# Set the following when reading back to adjust the run/event numbers
-# and timestampsjob
-svcMgr.EventSelector.RunNumber         = 0
-svcMgr.EventSelector.EventsPerRun      = 20
-svcMgr.EventSelector.FirstEvent        = 1
-# initial time stamp - this is number of seconds since 1st Jan 1970 GMT
-svcMgr.EventSelector.InitialTimeStamp  = 0
-# increment of 3 minutes
-svcMgr.EventSelector.TimeStampInterval = 5
-theApp.EvtMax                   = 15
-
-# setup the COOL conditions database and folders to be read in
-include("AthenaDBTestRec/Read_refcond1.py")

AtlasTest/DatabaseTest/AthenaDBTestRec/share/Read_refcond1.py

-# AthenaDBTestRec config generated from input ../config/refc1301.txt
-# local SQLite file
-# CondDBCool_Schema0="<db>sqlite://;schema=refc2001.db;dbname=REFC2001</db>"
-# Oracle INTR server - authentication via XML file
-CondDBCool_Schema0="<db>oracle://INTR;schema=ATLAS_COOL_GLOBAL;dbname=REFC2001</db>"
-# Frontier 
-#CondDBCool_Schema0="<dbConnection>impl=cool;techno=logical;schema=ATLAS_FRONTIER_TEST;X:REFC2001</dbConnection>"
-#
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_0 <tag>REFCOND1LARFOLDER_0-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_0"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_1 <tag>REFCOND1LARFOLDER_1-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_1"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_2 <tag>REFCOND1LARFOLDER_2-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_2"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_3 <tag>REFCOND1LARFOLDER_3-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_3"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_4 <tag>REFCOND1LARFOLDER_4-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_4"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_5 <tag>REFCOND1LARFOLDER_5-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_5"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_6 <tag>REFCOND1LARFOLDER_6-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_6"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_7 <tag>REFCOND1LARFOLDER_7-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_7"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_8 <tag>REFCOND1LARFOLDER_8-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_8"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_9 <tag>REFCOND1LARFOLDER_9-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_9"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_10 <tag>REFCOND1LARFOLDER_10-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_10"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_11 <tag>REFCOND1LARFOLDER_11-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_11"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_12 <tag>REFCOND1LARFOLDER_12-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_12"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_13 <tag>REFCOND1LARFOLDER_13-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_13"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_14 <tag>REFCOND1LARFOLDER_14-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_14"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_15 <tag>REFCOND1LARFOLDER_15-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_15"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_16 <tag>REFCOND1LARFOLDER_16-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_16"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_17 <tag>REFCOND1LARFOLDER_17-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_17"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_18 <tag>REFCOND1LARFOLDER_18-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_18"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_19 <tag>REFCOND1LARFOLDER_19-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_19"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_20 <tag>REFCOND1LARFOLDER_20-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_20"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_21 <tag>REFCOND1LARFOLDER_21-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_21"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_22 <tag>REFCOND1LARFOLDER_22-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_22"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_23 <tag>REFCOND1LARFOLDER_23-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_23"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_24 <tag>REFCOND1LARFOLDER_24-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_24"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_25 <tag>REFCOND1LARFOLDER_25-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_25"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_26 <tag>REFCOND1LARFOLDER_26-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_26"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_27 <tag>REFCOND1LARFOLDER_27-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_27"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_28 <tag>REFCOND1LARFOLDER_28-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_28"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_29 <tag>REFCOND1LARFOLDER_29-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_29"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_30 <tag>REFCOND1LARFOLDER_30-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_30"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_31 <tag>REFCOND1LARFOLDER_31-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_31"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_32 <tag>REFCOND1LARFOLDER_32-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_32"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_33 <tag>REFCOND1LARFOLDER_33-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_33"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_34 <tag>REFCOND1LARFOLDER_34-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_34"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_35 <tag>REFCOND1LARFOLDER_35-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_35"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_36 <tag>REFCOND1LARFOLDER_36-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_36"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_37 <tag>REFCOND1LARFOLDER_37-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_37"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_38 <tag>REFCOND1LARFOLDER_38-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_38"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_39 <tag>REFCOND1LARFOLDER_39-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_39"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_40 <tag>REFCOND1LARFOLDER_40-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_40"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_41 <tag>REFCOND1LARFOLDER_41-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_41"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_42 <tag>REFCOND1LARFOLDER_42-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_42"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_43 <tag>REFCOND1LARFOLDER_43-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_43"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_44 <tag>REFCOND1LARFOLDER_44-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_44"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_45 <tag>REFCOND1LARFOLDER_45-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_45"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_46 <tag>REFCOND1LARFOLDER_46-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_46"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_47 <tag>REFCOND1LARFOLDER_47-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_47"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_48 <tag>REFCOND1LARFOLDER_48-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_48"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/LAR/FOLDER_49 <tag>REFCOND1LARFOLDER_49-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/LAR/FOLDER_49"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/MDT/RT <tag>REFCOND1MDTRT-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/MDT/RT"]
-theTestCoolRecRead.FTypes+=[0]
-svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema0 + "/REFCOND1/MDT/T0 <tag>REFCOND1MDTT0-ref1</tag>"]
-theTestCoolRecRead.Folders+=["/REFCOND1/MDT/T0"]
-theTestCoolRecRead.FTypes+=[0]

AtlasTest/DatabaseTest/AthenaDBTestRec/src/DBConnection.h

-/*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef ATHENADBTESTREC_DBCONNECTION_H
-#define ATHENADBTESTREC_DBCONNECTION_H
-// DBConnection.h
-// Class to hold details of a COOL DB connection
-// Richard Hawkings, started 19/1/06
-
-#include <string>
-
-#include "CxxUtils/checker_macros.h"
-#include "CoolKernel/IDatabaseSvc.h"
-#include "CoraCool/CoraCoolDatabase.h"
-
-class ATLAS_NOT_THREAD_SAFE DBConnection {
- public:
-  DBConnection(const std::string tech, const std::string server,
-	       const std::string schema, const std::string dbname,
-	       const std::string user, const std::string passwd);
-  DBConnection(const std::string options, const std::string newschema="");
-
-  ~DBConnection();
-
-  cool::IDatabasePtr open();
-  void close();
-  bool isActive() const;
-  std::string coolStr() const;
-  std::string iovdbStr() const;
-  CoraCoolDatabasePtr coradbptr();
-
- private:
-  std::string m_tech;
-  std::string m_server;
-  std::string m_schema;
-  std::string m_dbname;
-  std::string m_user;
-  std::string m_passwd;
-  bool m_active;
-  bool m_coracool;
-  cool::IDatabasePtr m_coolptr;
-  CoraCoolDatabasePtr m_coradb;
-};
-
-inline bool DBConnection::isActive() const {return m_active;}
-
-#endif // ATHENADBTESTREC_DBCONNECTION_H

AtlasTest/DatabaseTest/AthenaDBTestRec/src/FolderInfo.h

-/*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef ATHENADBTESTREC_FOLDERINFO_H
-#define ATHENADBTESTREC_FOLDERINFO_H
-
-#include <vector>
-#include <string>
-
-#include "DBConnection.h"
-#include "CoolKernel/IFolder.h"
-#include "CoolKernel/RecordSpecification.h"
-#include "CxxUtils/checker_macros.h"
-#include "PersistentDataModel/Placement.h"
-
-class ATLAS_NOT_THREAD_SAFE FolderInfo {
- public:
-  enum PayloadTime {
-		    PTimeUndefined=0,
-		    DCSC=1,
-		    DCSP=2,
-		    RUNC=3,
-		    RUNP=4
-		    };
-  enum PayloadType {
-		      PTypeUndefined=0,
-		      Int=1,
-		      Float=2,
-		      String=3,
-                      PoolRef=4,
-		      Blob=5,
-		      CoraCool=6,
-		      CoolVector=7
-		      };
-
-  FolderInfo(const std::string name,DBConnection* dbconn,const int ndbconn,
-	     const int nchan, PayloadTime ptime,PayloadType ptype, 
-	     const int ncol, const int size, const int period,
-	     const std::string tag="",const bool payloadTable=false);
-
-  ~FolderInfo();
-
-  bool createFolder();
-
-  // accessor functions
-  const std::string name() const;
-  DBConnection* dbConnection();
-  int ndbconn() const;
-  int nchan() const;
-  PayloadTime ptime() const;
-  PayloadType ptype() const;
-  int size() const;
-  int period() const;
-  const std::string tag() const;
-  const Placement* poolplace() const;
-
-  void setpoolplace(Placement* const poolplace);
-  
-  void printSpec(const cool::IRecordSpecification& catrspec) const;
-
- private:
-  std::string m_name;
-  DBConnection* m_dbconn;
-  int m_ndbconn;
-  int m_nchan;
-  PayloadTime m_ptime;
-  PayloadType m_ptype;
-  int m_ncol;
-  int m_size;
-  int m_period;
-  std::vector<int> m_noisychan;
-  std::string m_tag;
-  bool m_paytable;
-
-  Placement* m_poolplace;
-
-};
-
-inline const std::string FolderInfo::name() const {return m_name;}
-inline DBConnection* FolderInfo::dbConnection() {return m_dbconn;}
-inline int FolderInfo::ndbconn() const { return m_ndbconn; }
-
-inline int FolderInfo::nchan() const {return m_nchan;}
-inline FolderInfo::PayloadTime FolderInfo::ptime() const {return m_ptime;}
-inline FolderInfo::PayloadType FolderInfo::ptype() const {return m_ptype;}
-inline int FolderInfo::size() const {return m_size;}
-inline int FolderInfo::period() const {return m_period;}
-inline const std::string FolderInfo::tag() const {return m_tag;}
-
-inline const Placement* FolderInfo::poolplace() const {return m_poolplace;}
-inline void FolderInfo::setpoolplace(Placement* const poolplace) {
-  m_poolplace=poolplace; }
-
-// helper functions
-FolderInfo::PayloadTime string2ptime(const std::string & str);
-FolderInfo::PayloadType string2ptype(const std::string & str);
-
-#endif // ATHENADBTESTREC_FOLDERINFO_H

AtlasTest/DatabaseTest/AthenaDBTestRec/src/TestCoolRecWriter.h

-/*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-*/
-
-#ifndef ATHENADBTESTREC_TESTCOOLRECWRITER_H
-#define ATHENADBTESTREC_TESTCOOLRECWRITER_H
-
-#include "FolderInfo.h"
-#include "DBConnection.h"
-#include "CoralBase/Attribute.h"
-#include "CoolKernel/Record.h"
-#include "CxxUtils/checker_macros.h"
-
-namespace pool {
-class IFileCatalog;
-class IPersistencySvc;
-}
-
-class ATLAS_NOT_THREAD_SAFE TestCoolRecWriter {
- public:
-  TestCoolRecWriter(const std::string& cooldb, const int mode,
-		    const std::string& configfile,
-                    const int nrun, const int run0, const int nevent, 
-                    const int time0, const int timerun);
-  int execute();
-  int fillDB();
-  int checkFolders();
-  bool readConfig();
-  void setPayload(const FolderInfo* folderi,cool::Record& payload,
-		  const int irun, const int ichan, const int iarray=0);
-  void setCoraPayload(const FolderInfo* folderi, 
-		      const cool::IRecordSpecification& rspec,
-		      std::vector<coral::AttributeList>& payloads,
-		      const int irun,const int ichan);
-  void setCoolVecPayload(const FolderInfo* folderi, 
-			 const cool::IRecordSpecification& rspec,
-			 std::vector<cool::IRecordPtr>& payloads,
-			 const int irun,const int ichan);
-  int genJobOpts(const std::string& file);
-  bool setupPool();
-  bool finalizePool();
-  void setPoolPayload(const FolderInfo* folderi, cool::Record& payload,
-		      const int irun, const int ichan);
-
- private:
-  // parameters
-  std::string m_coolstr;
-  int m_mode;
-  std::string m_configfile;
-  int m_nrun;
-  int m_run0;
-  int m_nevent;
-  int m_time0;
-  int m_timerun;
-  int m_poolmode;
-  std::string m_poolstem;
-  std::string m_tagsuffix;
-
-  bool m_usepool;
-  bool m_usecoracool;
-
-  std::vector<FolderInfo*> m_folders;
-  std::vector<DBConnection*> m_dbconn;
-
-  pool::IFileCatalog* m_poolcat;
-  pool::IPersistencySvc* m_persistencySvc;
-
-};
-
-#endif // ATHENADBTESTREC_TESTCOOLRECWRITER_H

AtlasTest/DatabaseTest/AthenaDBTestRec/src/app/DBConnection.cxx

-/*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// DBConnection.cxx
-// Class to hold details of a COOL DB connection
-// Richard Hawkings, started 20/1/06
-
-#include <iostream>
-#include "CoolKernel/IDatabaseSvc.h"
-#include "CoraCool/CoraCoolDatabaseSvcFactory.h"
-#include "RelationalAccess/ConnectionService.h"
-#include "DBConnection.h"
-
-DBConnection::DBConnection(const std::string tech, const std::string server,
-	       const std::string schema, const std::string dbname,
-			   const std::string user, const std::string passwd) :
-  m_tech(tech), m_server(server), m_schema(schema), m_dbname(dbname),
-  m_user(user), m_passwd(passwd), m_active(false), m_coracool(false)
-{}
-
-DBConnection::DBConnection(const std::string options, 
-			   const std::string newschema) 
-{
-  // split the input string into fields separated by :
-  std::vector<std::string> split;
-  unsigned int iofs1=0;
-  while (iofs1<options.size()) {
-    std::string::size_type iofs2=options.find(":",iofs1);
-    if (iofs2==std::string::npos) iofs2=options.size();
-    split.push_back(options.substr(iofs1,iofs2-iofs1));
-    iofs1=iofs2+1;
-  }
-  // override default schema if needed
-  if (split.size()>3) {
-    m_tech=split[0];
-    m_server=split[1];
-    m_schema=split[2];
-    m_dbname=split[3];
-    if (split.size()>4) m_user=split[4];
-    if (split.size()>5) m_passwd=split[5];
-  }
-  if (newschema!="") m_schema=newschema;
-  m_active=false;
-  m_coracool=false;
-}
-
-DBConnection::~DBConnection() {}
- 
-std::string DBConnection::coolStr() const {
-  std::string coolcon;
-  if (m_tech=="logical") {
-    coolcon=m_schema+"/"+m_dbname;
-  } else {
-    coolcon=m_tech+"://"+m_server+";schema="+m_schema;
-    if (m_user!="") coolcon+=";user="+m_user;
-    coolcon+=";dbname="+m_dbname;
-    if (m_passwd!="") coolcon+=";password="+m_passwd;
-  }
-  return coolcon;
-}
-
-std::string DBConnection::iovdbStr() const {
-  return "<db>"+coolStr()+"</db>";
-}
-
-cool::IDatabasePtr DBConnection::open() {
-  // only open if not already activated
-  if (m_coolptr.get()==0) {
-    // open the COOL DB 
-    m_coracool=false;
-    const std::string coolstr=coolStr();
-    CoraCoolDatabaseSvc& corasvc=CoraCoolDatabaseSvcFactory::databaseService();
-    cool::IDatabaseSvc& dbSvc=corasvc.coolIDatabaseSvc();
-    std::cout << "Attempt to open COOL database with connection string: "
-	      << coolstr << std::endl;
-    try {
-      m_coolptr=dbSvc.openDatabase(coolstr,false);
-      std::cout << "Connected to existing database" << std::endl;
-      m_active=true;
-    }
-    catch (std::exception& e) {
-      std::cout << "COOL exception caught: " << e.what() << std::endl;
-      std::cout << "Try to create new conditions DB" << std::endl;
-      try {
-        m_coolptr=dbSvc.createDatabase(coolstr);
-        std::cout << "Database creation succeeded" << std::endl;
-        m_active=true;
-      }
-      catch (std::exception& e) {
-        std::cout << "Database creation failed" << std::endl;
-        m_active=false;
-      }
-    }
-  }
-  return m_coolptr;
-}
-
-CoraCoolDatabasePtr DBConnection::coradbptr() {
-  // only open if not already activated
-  if (m_coradb.get()==0) {
-    const std::string coolstr=coolStr();
-    CoraCoolDatabaseSvc& corasvc=CoraCoolDatabaseSvcFactory::databaseService();
-    std::cout << "Attempt to open CoraCool database for " << coolstr <<
-      std::endl;
-    try {
-      m_coradb=corasvc.openDatabase(coolstr,false);
-      m_coracool=true;
-    }
-    catch (std::exception& e) {
-      std::cout << "CoraCool exception caught: " << e.what() << std::endl;
-    }
-  }
-  return m_coradb;
-}
-
-void DBConnection::close() {
-  if (m_active) {
-    std::cout << "Closing DB connection " << m_schema << " coracool " << 
-      m_coracool << std::endl;
-    if (m_coracool) {
-      m_coradb->disconnect();
-      m_coradb.reset();
-      m_coracool=false;
-    }
-    m_coolptr->closeDatabase();
-    m_coolptr.reset();
-    m_active=false;
-  }
-}
-

AtlasTest/DatabaseTest/AthenaDBTestRec/src/app/FolderInfo.cxx

-/*
-  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-// FolderInfo.cxx
-// class to hold details of COOL folders in reconstruction tets
-
-#include <iostream>
-#include <sstream>
-
-#include "CoolKernel/FolderSpecification.h"
-#include "CoraCool/CoraCoolDatabase.h"
-#include "CoraCool/CoraCoolFolder.h"
-#include "FolderInfo.h"
-
-FolderInfo::FolderInfo(const std::string name,
-		       DBConnection* dbconn, const int ndbconn,
-		       const int nchan, PayloadTime ptime, 
-		       PayloadType ptype, 
-		       const int ncol, const int size, const int period,
-		       const std::string tag, const bool payloadTable) :
-  m_name(name), m_dbconn(dbconn), m_ndbconn(ndbconn),
-  m_nchan(nchan), m_ptime(ptime), m_ptype(ptype),
-  m_ncol(ncol), m_size(size), m_period(period), m_noisychan(), 
-  m_tag(tag), m_paytable(payloadTable), m_poolplace(0) {
-  // construct tag
-  if (m_ptime==RUNC || m_ptime==RUNP) {
-    // construct tag from foldername - removing / and adding explicit -<tag>
-    // at end, following standard folder tagging convention
-    std::string tag2="";
-    for (std::string::const_iterator itr=m_name.begin(); 
-	 itr!=m_name.end();++itr) {
-      if (*itr!='/') tag2.push_back(*itr);
-    }
-    m_tag=tag2+"-"+m_tag;
-    std::cout << "Multi-version folder " << name << 
-      " will be tagged with tag: " << m_tag << std::endl;
-  } else {
-    // single version folders are not tagged
-    m_tag="";
-  }
-}
-
-FolderInfo::~FolderInfo() {}
-
-bool FolderInfo::createFolder() {
-  // create the folder
-
-  // set CoraCool flag from folder data type
-  bool coracool=(m_ptype==CoraCool);
-  bool coolvec=(m_ptype==CoolVector);
-
-  // construct specification 
-  cool::RecordSpecification spec;
-  // use UChar to flag undefined storage type
-  cool::StorageType::TypeId coltype=cool::StorageType::UChar;
-  std::string colnm="Undef";
-  if (m_ptype==Int || coracool || coolvec) {
-    coltype=cool::StorageType::Int32;
-    colnm="int";
-  }
-  if (m_ptype==Float) {
-    coltype=cool::StorageType::Float;
-    colnm="float";
-  }
-  if (m_ptype==String) {
-    coltype=( m_size<4000 ? 
-	      cool::StorageType::String4k : cool::StorageType::String16M );
-    colnm="string";
-  }
-  if (m_ptype==Blob) {
-     coltype=( m_size<64000 ? 
-	       cool::StorageType::Blob64k : cool::StorageType::Blob16M );
-    colnm="blob";
-  }
-  if (m_ptype==PoolRef) {
-    spec.extend("PoolRef",cool::StorageType::String4k);
-  } else {
-    // for coracool folder, also need primary and foreign keys
-    if (coracool) {
-      spec.extend("PrimKey",cool::StorageType::Int32);
-	spec.extend("ForeignKey",cool::StorageType::Int32);
-    }
-    for (int i=0;i<m_ncol;++i) {
-      std::ostringstream colstr;
-      colstr << colnm;
-      if (m_ncol>1) colstr << i;
-      spec.extend(colstr.str(),coltype);
-    }
-  }
-  // construct description
-  std::string desc="<timeStamp>";
-  // set timestamp part of description
-  if (m_ptime==DCSP || m_ptime==DCSC) {     
-    desc+="time";
-  } else {
-    desc+="run-event";
-  }
-  desc+="</timeStamp>";
-  if (m_ptype==PoolRef) {
-    desc+="<addrHeader><address_header service_type=\"71\" clid=\"117237436\" /></addrHeader><typeName>TestCoolRecPoolDataColl</typeName>";
-  } else if (m_ptype==CoraCool) {
-    desc+="<addrHeader><address_header service_type=\"71\" clid=\"55403898\" /></addrHeader><typeName>CondAttrListVec</typeName>";
-  } else if (m_ptype==CoolVector) {
-    desc+="<addrHeader><address_header service_type=\"71\" clid=\"55403898\" /></addrHeader><typeName>CondAttrListVec</typeName>";
-
-  } else {
-    desc+="<addrHeader><address_header service_type=\"71\" clid=\"1238547719\" /></addrHeader><typeName>CondAttrListCollection</typeName>";
-  }
-  std::cout << "Folder description: " << desc << std::endl;
-  if (m_paytable) std::cout << "Folder will have separate payload table"
-			      << std::endl;
-  cool::FolderVersioning::Mode mode;
-  if (m_tag=="") {
-    mode=cool::FolderVersioning::SINGLE_VERSION;
-  } else {
-    mode=cool::FolderVersioning::MULTI_VERSION;
-  }
-  // access the database
-  cool::IDatabasePtr cooldb=m_dbconn->open();
-
-  if (coracool) {
-    // set CORAL table name from folder leaf name
-    std::string coraltable;
-    std::string::size_type iofs=m_name.rfind("/");
-    if (iofs!=std::string::npos) {
-      coraltable=m_name.substr(iofs+1);
-    } else {
-      coraltable=m_name;
-    }
-    cool::RecordSpecification fkspec;
-    fkspec.extend("ForeignKey",cool::StorageType::Int32);
-    CoraCoolDatabasePtr coraDb=m_dbconn->coradbptr();
-    CoraCoolFolderPtr corafolderptr=coraDb->createFolder(m_name,coraltable,
-      	  fkspec,spec,"ForeignKey","PrimKey",desc,mode,true);
-    std::cout << "Done CoraCool folder creation" << std::endl;
-    printSpec(corafolderptr->payloadSpecification());
-  } else {
-    cool::IFolderPtr folderptr;
-    cool::PayloadMode::Mode pmode=cool::PayloadMode::INLINEPAYLOAD;
-    if (m_paytable) {
-      pmode=cool::PayloadMode::SEPARATEPAYLOAD;
-    } else if (coolvec) {
-      pmode=cool::PayloadMode::VECTORPAYLOAD;
-    }
-    folderptr=cooldb->createFolder(m_name,
-	cool::FolderSpecification(mode,spec,pmode),desc,true);
-
-    std::cout << "Done COOL folder creation payload type " << pmode << std::endl;
-    printSpec(folderptr->payloadSpecification());
-  }
-  return true;
-}
- 
-void FolderInfo::printSpec(const cool::IRecordSpecification& catrspec) const {
-  // print out payload specification
-  std::cout << "AttributeList specification for folder " << m_name << " is ";
-  for (unsigned int i=0;i<catrspec.size();++i) {
-    const cool::IFieldSpecification& field=catrspec[i];
-    std::cout << field.name() << " : " << 
-      field.storageType().name() << " , ";
-  }
-  std::cout << std::endl;
-}
-
-FolderInfo::PayloadTime string2ptime(const std::string & str) {
-  if (str=="DCSC") return FolderInfo::DCSC;
-  if (str=="DCSP") return FolderInfo::DCSP;
-  if (str=="RUNC") return FolderInfo::RUNC;
-  if (str=="RUNP") return FolderInfo::RUNP;
-  return FolderInfo::PTimeUndefined;
-}
-
-FolderInfo::PayloadType string2ptype(const std::string & str) {
-  if (str=="INT" || str=="int") return FolderInfo::Int;
-  if (str=="FLOAT" || str=="float") return FolderInfo::Float;
-  if (str=="STRING" || str=="string") return FolderInfo::String;
-  if (str=="POOLREF" || str=="poolref") return FolderInfo::PoolRef;
-  if (str=="BLOB" || str=="blob") return FolderInfo::Blob;
-  if (str=="CORACOOL" || str=="coracool") return FolderInfo::CoraCool;
-  if (str=="COOLVECTOR" || str=="coolvector") return FolderInfo::CoolVector;
-  return FolderInfo::PTypeUndefined;
-}

AtlasTest/DatabaseTest/AthenaDBTestRec/src/app/TestCoolRecWriter.cxx

-/*
-  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
-*/
-
-// TestCoolRecWriter.cxx
-// Program to write test data load to COOL database for Athena reconstruction
-// Richard Hawkings, started 19/1/06
-// Compiles in offline cmt framework to binary executable, needs offline env
-
-#include<vector>
-#include<string>
-#include<iostream>
-#include <fstream>
-#include <sstream>
-
-//POOL includes for POOL object write
-#include "PersistentDataModel/Placement.h"
-#include "PersistentDataModel/Token.h"
-#include "PersistencySvc/ISession.h"
-#include "PersistencySvc/IPersistencySvc.h"
-#include "PersistencySvc/DatabaseConnectionPolicy.h"
-#include "PersistencySvc/ITransaction.h"
-#include "StorageSvc/DbType.h"
-#include "StorageSvc/DbReflex.h"
-
-#include "FileCatalog/IFileCatalog.h"
-#include "CoralBase/Blob.h"
-#include "CoolKernel/Record.h"
-#include "AthenaDBTestRec/TestCoolRecPoolData.h"
-#include "CoraCool/CoraCoolDatabase.h"
-#include "CoraCool/CoraCoolFolder.h"
-
-#include "TestCoolRecWriter.h"
-
-TestCoolRecWriter::TestCoolRecWriter(const std::string& cooldb, const int mode,
-				     const std::string& configfile,
-                    const int nrun, const int run0, const int nevent, 
-				     const int time0, const int timerun) :
-  m_coolstr(cooldb), m_mode(mode), m_configfile(configfile),
-  m_nrun(nrun), m_run0(run0), m_nevent(nevent), 
-  m_time0(time0), m_timerun(timerun), m_poolmode(0),m_poolstem("pool"),
-  m_tagsuffix("tag1"),
-  m_usepool(false),
-  m_usecoracool(false),
-  m_poolcat(NULL),
-  m_persistencySvc(NULL) {
-  std::cout << "Starting TestCoolRecWriter" << std::endl 
-	    << "Cool database: " << m_coolstr << std::endl
-	    << "Mode: " << m_mode << std::endl
-	    << "Config file: " << m_configfile << std::endl;
-}
-
-int TestCoolRecWriter::execute() {
-  // read configuration
-  readConfig();
-  // now execute
-  if (m_mode==1) return fillDB();
-  if (m_mode==2) return genJobOpts("CoolReadConfig.py");
-  return 1;
-}
-
-bool TestCoolRecWriter::readConfig() {
-  // read lines from config file
-  std::cout << "Start to read config from " << m_configfile << std::endl;
-  FILE* p_inp=fopen(m_configfile.c_str(),"r");
-  if (p_inp==0) {
-    std::cout << "ERROR: Cannot open config file" << std::endl;
-    return false;
-  }
-  // set initial database connection
-  m_dbconn.clear();
-  m_dbconn.push_back(new DBConnection(m_coolstr));
-  int idbconn=0;
-  DBConnection* dbconn=m_dbconn[0];
-  m_folders.clear();
-  bool paytable=false;
-
-  char* p_buf=new char[999];
-  while (!feof(p_inp)) {
-    char* p_line=fgets(p_buf,999,p_inp);
-    if (p_line!=NULL) {
-    // tokenise input line based on spaces
-    std::string buf=std::string(p_line);
-    std::vector<std::string> tokens;
-    unsigned int iofs1=0;
-    while (iofs1<buf.size()) {
-      std::string::size_type iofs2=buf.find(" ",iofs1);
-      // allow for trailing linefeed
-      if (iofs2==std::string::npos) iofs2=buf.size()-1;
-      tokens.push_back(buf.substr(iofs1,iofs2-iofs1));
-      iofs1=iofs2+1;
-    }
-    if (tokens.size()>0) {
-      // definition of single folder
-      if (tokens[0]=="folder") {
-	if (tokens.size()<8) {
-	  std::cout << "Folder definition syntax: " << std::endl << 
-     "folder <path> <nchan> <ptime> <ptype> <ncolumns> <size> <period>"
-		    << std::endl;
-
-	} else {
-	  // define single folder
-	  std::cout << "Define folder " << tokens[1] << std::endl;
-          m_folders.push_back(new FolderInfo(tokens[1],dbconn,idbconn,
-	     atoi(tokens[2].c_str()),
-             string2ptime(tokens[3]),string2ptype(tokens[4]),
-	     atoi(tokens[5].c_str()),atoi(tokens[6].c_str()),
-					 atoi(tokens[7].c_str()),
-					 m_tagsuffix,paytable));
-	}			      
-      } else if (tokens[0]=="multi") {
-	if (tokens.size()<9) {
-	  std::cout << "Multi-Folder definition syntax: " << std::endl << 
-     "multi <n> <path> <nchan> <ptime> <ptype> <ncolumns> <size> <period>"
-		    << std::endl;
-
-	} else {
-	  // define multiple folder
-	  int nfold=atoi(tokens[1].c_str());
-	  std::cout << "Define " << nfold << " folders based on  " 
-            << tokens[2] << std::endl;
-          for (int ifold=0;ifold<nfold;++ifold) {
-            std::ostringstream strs;
-            strs << tokens[2] << "_" << ifold;
-            m_folders.push_back(new FolderInfo(strs.str(),dbconn,idbconn,
-	     atoi(tokens[3].c_str()),
-             string2ptime(tokens[4]),string2ptype(tokens[5]),
-	     atoi(tokens[6].c_str()),atoi(tokens[7].c_str()),
-					 atoi(tokens[8].c_str()),m_tagsuffix));
-          }
-	}			      
-      } else if (tokens[0]=="schema") {
-	if (tokens.size()!=2) {
-	  std::cout << "Schema definition syntax:" << std::endl <<
-	    "schema <schema_name>" << std::endl;
-	} else {
-	  std::cout << "Define new schema : " << tokens[1]
-		    << std::endl;
-	  dbconn=new DBConnection(m_coolstr,tokens[1]);
-          m_dbconn.push_back(dbconn);
-	  ++idbconn;
-	}
-      } else if (tokens[0]=="poolfile") {
-	if (tokens.size()!=3) {
-	  std::cout << "Poolfile definition syntax: " << std::endl <<
-	    "poolfile <mode> <file_stem>" << std::endl;
-	} else {
-	  m_poolmode=atoi(tokens[1].c_str());
-	  m_poolstem=tokens[2];
-	}
-      } else if (tokens[0]=="tag") {
-	if (tokens.size()!=2) {
-	  std::cout << "Tag definition syntax: " << std::endl <<
-	    "tag <tagsiffix>" << std::endl;
-	} else {
-	  m_tagsuffix=tokens[1];
-	}
-      } else if (tokens[0]=="payloadtable") {
-	if (tokens.size()!=2) {
-	  std::cout << "Payloadtable syntax: " <<std::endl <<
-	    "payloadtable 0|1" << std::endl;
-	} else {
-	  paytable=(atoi(tokens[1].c_str())!=0);
-	}
-      } else if (tokens[0]!="#" && tokens[0]!="//") {
-	std::cout << "Bad input line: " << buf << std::endl;
-      }
-    }
-  }
-  }
-  std::cout << "Defined total of " << m_folders.size() << " folders from input"
-	    << std::endl;
-  // check if any folders are POOL references
-  for (std::vector<FolderInfo*>::const_iterator i=m_folders.begin();
-       i!=m_folders.end();++i) {
-    if ((*i)->ptype()==FolderInfo::PoolRef) m_usepool=true;
-    if ((*i)->ptype()==FolderInfo::CoraCool) m_usecoracool=true;
-  }
-  fclose(p_inp);
-  delete [] p_buf;
-  return true;
-}
-
-int TestCoolRecWriter::fillDB() {
-  // setup POOL if needed
-  if (m_usepool) setupPool();
-  if (checkFolders()!=0) return 1;
-  
-  std::cout << "Starting write loop with following paramters" << std::endl <<
-    "Number of runs: " << m_nrun << " first run: " << m_run0 << 
-   " events/run: " << m_nevent << std::endl << "Initial time: " << m_time0 <<
-    " time per run: " <<  m_timerun << std::endl;
-  bool allIOV=false;
-  if (m_nrun==0) {
-    allIOV=true;
-    m_run0=0;
-    m_time0=0;
-    m_nrun=1;
-    std::cout << "Writing single IOV for all runs" << std::endl;
-  }
-  Placement* placement=0;
-
-  for (int irun=m_run0; irun<m_run0+m_nrun; ++irun) {
-    std::cout << "Fill database for run " << irun << 
-    " events [0," << m_nevent-1 << "] time {" << (irun-m_run0)*m_timerun << ","
-	      << (irun-m_run0+1)*m_timerun << "}" << std::endl;
-
-    // folder sequence number for POOL files
-    unsigned int fseq=0;
-    for (std::vector<FolderInfo*>::const_iterator ifold=m_folders.begin();
-	 ifold!=m_folders.end();++ifold,++fseq) {
-      FolderInfo* folderi=*ifold;
-      std::cout << "Run " << irun << " folder " << folderi->name() <<
-	std::endl;
-
-      const FolderInfo::PayloadTime ptime=folderi->ptime();
-      const bool coracool=(folderi->ptype()==FolderInfo::CoraCool);
-      const bool coolvec=(folderi->ptype()==FolderInfo::CoolVector);
-
-      // access the database
-      cool::IDatabasePtr cooldb=folderi->dbConnection()->open();
-      cool::IFolderPtr folder;
-      CoraCoolFolderPtr corafolder;
-      if (coracool) {
-	CoraCoolDatabasePtr coradb=folderi->dbConnection()->coradbptr();
-	corafolder=coradb->getFolder(folderi->name());
-      } else {
-        folder=cooldb->getFolder(folderi->name());
-      }
-
-      const std::string tag=folderi->tag();
-      bool utonly=(tag!="");
-      int nobj=0;
-      // setup buffer to receive updates
-      if (coracool) {
-	corafolder->setupStorageBuffer();
-      } else {
-        folder->setupStorageBuffer();
-      }
-      // setup POOL if needed
-      if (folderi->ptype()==FolderInfo::PoolRef && folderi->poolplace()==0) {
-	if (placement==0 || (m_poolmode & 1)) {
-  	  std::cout << "Setup POOL for folder " << folderi->name() << 
-	    std::endl;
-    	  placement=new Placement;
-  	  std::ostringstream sfile;
-	  sfile << m_poolstem;
-          if (m_poolmode & 1) sfile << fseq;
-	  if (m_poolmode & 2) sfile << "_run" << irun;
-          sfile << ".root";
-	  std::cout << "Setup new POOL file: " << sfile.str() << std::endl;
- 	  placement->setFileName(sfile.str());
-	  placement->setTechnology(pool::ROOTTREE_StorageType.type());
-	  placement->setContainerName("POOLContainer_TestCoolRecPoolData");
-	}
-	folderi->setpoolplace(placement);
-      } 
-
-      // loop over all channels
-      for (int ichan=0;ichan<folderi->nchan();++ichan) {
-	// different time structures depending on folder type
-	if (ptime==FolderInfo::DCSC || ptime==FolderInfo::DCSP) {
-	  // loop in time
-	  int itime=(irun-m_run0)*m_timerun+m_time0;
-	  int itime1=itime+m_timerun;
-	  while (itime<itime1) {
-	    // convert time to nanoseconds
-	    cool::ValidityKey since=itime*1000000000LL;
-	    try {
-	      if (coracool) {
-		std::vector<coral::AttributeList> payloads;
-		setCoraPayload(folderi,corafolder->payloadSpecification(),
-			       payloads,irun,ichan);
-		corafolder->storeObject(since,cool::ValidityKeyMax,
-					payloads.begin(),payloads.end(),
-					ichan,tag,utonly);
-	    } else if (coolvec) {
-	      std::vector<cool::IRecordPtr> payloads;
-	      setCoolVecPayload(folderi,folder->payloadSpecification(),
-				payloads,irun,ichan);
-	      folder->storeObject(since,cool::ValidityKeyMax,payloads,
-				  ichan,tag,utonly);
-	      } else {
-	        cool::Record payload(folder->payloadSpecification());
-  	        setPayload(folderi,payload,irun,ichan);
-                folder->storeObject(since,cool::ValidityKeyMax,payload,
-				  ichan,tag,utonly);
-	      }
- 	      ++nobj;
-	    } catch (std::exception& e) {
-	      std::cout << "Exception thrown from storeObject: " << e.what()
-			<< std::endl;
-	    }
-	    int itinc=folderi->period();
-	    if (ptime==FolderInfo::DCSP) {
-	      // uniform (0 to itinc*2) random time increment
-	      itime+=1+static_cast<int>(2.*static_cast<float>(itinc)*rand()/
-                  (RAND_MAX+1.0));
-	    } else {
-	      // constant time increment
-    	      itime+=itinc;
-	    }
-	  }
-	} else if (ptime==FolderInfo::RUNC || ptime==FolderInfo::RUNP) {
-	  // loop over events within run
-	  int ievent=0;
-	  int ieventinc;
-	  // period interpreted as number of events per update (+ve)
-	  // or number of runs per update, only done on some runs (-ve)
-	  if (folderi->period()>0) {
-  	    ieventinc=m_nevent/folderi->period();
-	  } else {
-	    ieventinc=-m_nevent*folderi->period();
-	    // if not run zero of group, skip updating
-	    if ((irun % folderi->period())!=0) ievent+=m_nevent;
-	  }
-	  while (ievent<m_nevent) {
-	    cool::ValidityKey since=(static_cast<unsigned long long>(irun) 
-                  << 32)+ievent;
-	    cool::ValidityKey till;
-	    if (folderi->period()>0) {
-	      till=(static_cast<unsigned long long>(irun) 
-				    << 32)+ievent+ieventinc;
-	    } else {
-	      till=(static_cast<unsigned long long>(irun-folderi->period())
-		    << 32);
-	    }
-	    if (allIOV) till=cool::ValidityKeyMax;
-	    if (coracool) {
-	      std::vector<coral::AttributeList> payloads;
-	      setCoraPayload(folderi,corafolder->payloadSpecification(),
-			     payloads,irun,ichan);
-	      corafolder->storeObject(since,till,payloads.begin(),
-				      payloads.end(),ichan,tag,utonly);
-	    } else if (coolvec) {
-	      std::vector<cool::IRecordPtr> payloads;
-	      setCoolVecPayload(folderi,folder->payloadSpecification(),
-				payloads,irun,ichan);
-	      folder->storeObject(since,till,payloads,ichan,tag,utonly);
-	    } else {
-	      cool::Record payload(folder->payloadSpecification());
-	      if (folderi->ptype()==FolderInfo::PoolRef) {
-	        setPoolPayload(folderi,payload,irun,ichan);
-	      } else {
-  	        setPayload(folderi,payload,irun,ichan);
-	      }
-              folder->storeObject(since,till,payload,ichan,tag,utonly);
-	    }
-	    ++nobj;
-            ievent+=ieventinc;
-	  }
-	}
-      }
-
-      // flush buffer - write updates to COOL
-      try {
-	if (coracool) {
-	  corafolder->flushStorageBuffer();
-	} else {
-          folder->flushStorageBuffer();
-	}
-	std::cout << "Stored " << nobj << " objects in " << folderi->nchan() 
-		  << " channels" << std::endl;
-      }
-      catch (std::exception& e) {
-	std::cout << "ERROR: Exception thrown from COOL bulk insert: " <<
-	  e.what() << std::endl;
-      }
-    }
-    // loop over folders again to finish with any POOL files as needed
-    bool first=true;
-    for (std::vector<FolderInfo*>::const_iterator ifold=m_folders.begin();
-	 ifold!=m_folders.end();++ifold) {
-      FolderInfo* folderi=*ifold;
-      if (m_usepool && folderi->poolplace()!=0 && (m_poolmode &2)) {
-	if ((m_poolmode & 1) || first) {
-	  const Placement* placement=folderi->poolplace();
-	  delete placement;
-	  folderi->setpoolplace(0);
-	} else {
-	  // folder sharing placement - delete only reference
-	  folderi->setpoolplace(0);
-	}
-      }
-      first=false;
-    }
-  }
-  // finalise POOL if needed
-  if (m_usepool) finalizePool();
-  std::cout << "Finalised POOL" << std::endl;
-
-  // close all database connections
-  for (std::vector<DBConnection*>::iterator itr=m_dbconn.begin();
-       itr!=m_dbconn.end();++itr) {
-    (*itr)->close();
-    delete *itr;
-  }
-  std::cout << "Finished fillDB" << std::endl;
-  return 0;
-}
-
-void TestCoolRecWriter::setPayload(const FolderInfo* folderi,
-				   cool::Record& payload,
-				   const int irun,const int ichan,
-				   const int iarray) {
-  // setup the payload appropriate for this folder (types already set)
-  FolderInfo::PayloadType ptype=folderi->ptype();
-  for (unsigned int iat=0;iat<payload.size();++iat) {
-    if (ptype==FolderInfo::Int) {
-      // for integers, first one is run, second, channel, then random
-      int ipay;
-      if (iat==0) {
-	ipay=irun;
-      } else if (iat==1) {
-	ipay=ichan;
-      } else {
-	ipay=static_cast<int>(1000.*rand()/RAND_MAX+1);
-      }
-      payload[iat].setValue(ipay);
-    } else if (ptype==FolderInfo::Float) {
-      // for floats, first one is run, second, channel, then random
-      float fpay;
-      if (iat==0) {
-	fpay=irun;
-      } else if (iat==1) {
-	fpay=ichan;
-      } else {
-	fpay=static_cast<int>(1000.*rand()/RAND_MAX+1);
-      }
-      payload[iat].setValue(fpay);
-    } else if (ptype==FolderInfo::String) {
-      // start by writing the run and channel numbers into the string
-      // separated by commas
-      std::ostringstream strs;
-      strs << irun << "," << ichan << ",";
-      // generate string of random characters to pad upto required length
-      std::string pstring=strs.str();
-      int nextra=folderi->size()-pstring.size();
-      if (nextra>0) {
-        for (int i=0;i<nextra;++i) {
-	  int iasc=32+static_cast<int>(90.*rand()/RAND_MAX+1);
-          pstring+=static_cast<char>(iasc);
-        }
-      }
-      payload[iat].setValue(pstring);
-    } else if (ptype==FolderInfo::Blob) {
-      coral::Blob& blob=
-        const_cast<coral::Blob&>(payload[iat].data<coral::Blob>());
-      unsigned int blobsize=folderi->size();
-      blob.resize(blobsize);
-      unsigned char* p=static_cast<unsigned char*>(blob.startingAddress());
-      int* q=static_cast<int*>(blob.startingAddress());
-      // first two 32-bit ints are run and channel number
-      *q=irun;
-      *(q+1)=ichan;
-      p+=8;
-      // the rest is random values
-      for (int i=8;i<folderi->size();++i,++p)
-	*p=(static_cast<int>(256.*rand()/RAND_MAX)) % 256;
-    } else if (ptype==FolderInfo::CoraCool || ptype==FolderInfo::CoolVector) {
-      // for CoraCool, payload are integers
-      // first two are keys to be overwritten (coracool only ), 
-      // next are run/chan/array then random
-      int ipay;
-      if (iat==2) {
-	ipay=irun;
-      } else if (iat==3) {
-	ipay=ichan;
-      } else if (iat==4) {
-	ipay=iarray;
-      } else {
-	ipay=static_cast<int>(1000.*rand()/RAND_MAX+1);
-      }
-      payload[iat].setValue(ipay);
-    }
-  }
-}
-
-void TestCoolRecWriter::setCoraPayload(const FolderInfo* folderi,
-				       const cool::IRecordSpecification& rspec,
-		      std::vector<coral::AttributeList>& payloads,
-				       const int irun,const int ichan) {
-  cool::Record payload(rspec);
-  unsigned int nobj=folderi->size();
-  for (unsigned int i=0;i<nobj;++i) {
-    setPayload(folderi,payload,irun,ichan,i);
-    payloads.push_back(payload.attributeList());
-  }
-}
-
-void TestCoolRecWriter::setCoolVecPayload(const FolderInfo* folderi,
-		    const cool::IRecordSpecification& rspec,
-		    std::vector<cool::IRecordPtr>& payloads,
-					 const int irun, const int ichan) {
-  unsigned int nobj=folderi->size();
-  for (unsigned int i=0;i<nobj;++i) {
-    cool::Record* payload=new cool::Record(rspec);
-    setPayload(folderi,*payload,irun,ichan,i);
-    payloads.push_back(cool::IRecordPtr(payload));
-  }
-}
-
-int TestCoolRecWriter::genJobOpts(const std::string& file) {
-  // generate joboption file for Athena
-  std::cout << "Generating Athena joboptions into file: " << file << std::endl;
-
-  std::ofstream* outfile;
-  outfile=new std::ofstream(file.c_str());
-  if (outfile==0) {
-    std::cout << "Problem opening output file" << std::endl;
-    return 1;
-  }
-  *outfile << "# AthenaDBTestRec config generated from input " << m_configfile
-	   << std::endl;
-  // write list of connections
-  for (unsigned int iconn=0;iconn<m_dbconn.size();++iconn)
-    *outfile << "CondDBCool_Schema" << iconn << "=\"" << 
-     (m_dbconn[iconn])->iovdbStr() << "\"" << std::endl;
-
-  // write list of folders and options
-  for (unsigned int ifold=0;ifold<m_folders.size();++ifold) {
-    const FolderInfo* folderi=m_folders[ifold];
-    *outfile << "svcMgr.IOVDbSvc.Folders+=[CondDBCool_Schema";
-    *outfile << folderi->ndbconn() << " + \"";
-    *outfile << folderi->name();
-    if (folderi->tag()!="") 
-      *outfile << " <tag>" << folderi->tag() << "</tag>";
-    *outfile << "\"]" << std::endl;
-    *outfile << "theTestCoolRecRead.Folders+=[\"" << folderi->name() << "\"]" 
-	     << std::endl;
-    int iftype=0;
-    if (folderi->ptype()==FolderInfo::PoolRef) iftype=1;
-    if (folderi->ptype()==FolderInfo::CoraCool) iftype=2;
-    if (folderi->ptype()==FolderInfo::CoolVector) iftype=2;
-    // for folders spanning more than one run, use ftype to store run period
-    // which will be > 1
-    if (folderi->period()<-1) iftype=-folderi->period();
-    *outfile << "theTestCoolRecRead.FTypes+=[" << iftype << "]" << std::endl;
-  }
-
-  outfile->close();
-  delete outfile;
-  return 0;
-}
-
-int TestCoolRecWriter::checkFolders() {
-  std::cout << "Checking existance of " << m_folders.size() << " COOL folders"
-	    << std::endl;
-  for (std::vector<FolderInfo*>::iterator itr=m_folders.begin();
-       itr!=m_folders.end();++itr) {
-    FolderInfo* folder=*itr;
-    cool::IDatabasePtr cooldb=folder->dbConnection()->open();
-    const std::string& name=folder->name();
-    if (cooldb->existsFolder(name)) {
-      std::cout << "Connected to existing folder " << name << std::endl;
-    } else {
-      std::cout << "Attempting to create folder " << name << std::endl;
-      if (!folder->createFolder()) return 1;
-    }
-  }
-  return 0;
-}
-
-bool TestCoolRecWriter::setupPool() {
-  std::cout << "Setup POOL for referenced object output" << std::endl;
-  m_poolcat=new pool::IFileCatalog;
-  try {
-    m_poolcat->setWriteCatalog("file:PoolFileCatalog.xml");
-    m_poolcat->connect();
-  }
-  catch (std::exception& e) {
-    std::cout << "Could not setup POOL catalogues, exception:" << e.what() 
-	      << std::endl;
-  }
-  m_poolcat->start();
-  m_persistencySvc = pool::IPersistencySvc::create(*m_poolcat).release();
-  pool::DatabaseConnectionPolicy policy;
-  policy.setWriteModeForNonExisting(pool::DatabaseConnectionPolicy::CREATE);
-  policy.setWriteModeForExisting(pool::DatabaseConnectionPolicy::UPDATE);
-  m_persistencySvc->session().setDefaultConnectionPolicy(policy);
-  if (!m_persistencySvc->session().transaction().start(pool::ITransaction::UPDATE)) {
-     std::cout << "TestCollRecWriter::setupPool: start fails." << std::endl;
-     return false;
-  }
-  return true;
-}
-
-bool TestCoolRecWriter::finalizePool() {
-   if (!m_persistencySvc->session().transaction().commit()) {
-     std::cout << "TestCollRecWriter::finalizePool: commit fails." << std::endl;
-     return false;
-   }
-   m_persistencySvc->session().disconnectAll();
-   m_poolcat->commit();
-   m_poolcat->disconnect();
-   delete m_persistencySvc;
-   delete m_poolcat;
-   return true;
-}
-
-void TestCoolRecWriter::setPoolPayload(const FolderInfo* folderi,
-		      cool::Record& payload, const int irun,
-				       const int ichan) {
-   // create object, mark for output
-   // note: this could be considered a memory leak, but the objects need to be kept till commit anyhow
-   TestCoolRecPoolData *data = new TestCoolRecPoolData(irun,ichan,folderi->name(),folderi->size());
-   // fill vector of floats in object
-   for( std::vector<float>::iterator it = data->dbegin(); it != data->dend(); ++it) {
-      *it=rand()/(float(RAND_MAX)+1);
-   }
-   Token *tok = m_persistencySvc->registerForWrite(*(folderi->poolplace()), data, pool::DbReflex::forTypeInfo(typeid(TestCoolRecPoolData)) );
-   // set payload data for COOL to Pool object reference
-   payload["PoolRef"].setValue<std::string>( tok->toString() );
-   delete tok;
-}
-
-
-int main ATLAS_NOT_THREAD_SAFE (int argc, const char* argv[]) {
-  if (argc<4) {
-    std::cout << "Syntax: TestCoolRecWriter <coolDBconnection> <mode> <config_file> {<nrun> <run0> <nevent> <time0> <timerun>}" << std::endl;
-    return 1;
-  }
-  // run paramter defaults
-  int nrun=1;
-  int run0=10000;
-  int nevent=720000;
-  int time0=0;
-  int timerun=3600;
-  if (argc>4) nrun=atoi(argv[4]);
-  if (argc>5) run0=atoi(argv[5]);
-  if (argc>6) nevent=atoi(argv[6]);
-  if (argc>7) time0=atoi(argv[7]);
-  if (argc>8) timerun=atoi(argv[8]);
-
-  TestCoolRecWriter tester(argv[1],atoi(argv[2]),argv[3],
-			   nrun,run0,nevent,time0,timerun);
-  return tester.execute();
-}

AtlasTest/DatabaseTest/AthenaDBTestRec/src/components/AthenaDBTestRec_entries.cxx

-#include "AthenaDBTestRec/TestCoolRecRead.h"
-#include "AthenaDBTestRec/DetStoreDump.h"
-
-DECLARE_COMPONENT( TestCoolRecRead )
-DECLARE_COMPONENT( DetStoreDump )
-

AtlasTest/DatabaseTest/AthenaDBTestRec/src/lib/DetStoreDump.cxx

-/*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-// DetStoreDump.cxx
-// Athena algorithm to dump detector store status at end of init 
-// and at first event execute
-// started Richard Hawkings 24/1/06
-
-#include "GaudiKernel/SmartDataPtr.h"
-
-#include "AthenaDBTestRec/DetStoreDump.h"
-
-DetStoreDump::DetStoreDump(const std::string& name, 
-  ISvcLocator* pSvcLocator) :
-   AthAlgorithm(name,pSvcLocator),
-   m_first(true)
-{
-  declareProperty("Mode",m_mode); 
-}
-
-DetStoreDump::~DetStoreDump() {}
-
-StatusCode DetStoreDump::initialize() {
-
-  ATH_MSG_INFO("Initialise - mode " << m_mode);
-
-  msg(MSG::INFO) << "Dump of complete detector store at initialize"
-	<< detStore()->dump() << endmsg;
-  msg(MSG::INFO) << "Dump finished" << endmsg;
-
-  return StatusCode::SUCCESS;
-}
-
-StatusCode DetStoreDump::execute() {
-  if (m_first && m_mode>0) {
-    msg(MSG::INFO) << 
-     "Dump of complete detector store at first event execute"
-	  << detStore()->dump() << endmsg;
-    msg(MSG::INFO) << "Dump finished" << endmsg;
-  }
-  m_first=false;
-  return StatusCode::SUCCESS;
-}
-
-StatusCode DetStoreDump::finalize() {
-  return StatusCode::SUCCESS;
-}

AtlasTest/DatabaseTest/AthenaDBTestRec/src/lib/TestCoolRecFolder.cxx

-/*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
-*/
-
-// TestCoolRecFolder.cxx
-// impl class to hold details of COOL folders in reconstruction tests
-// Richard Hawkings, started 3/3/06
-
-#include <math.h>
-#include <fstream>
-#include <sstream>
-#include "AthenaDBTestRec/TestCoolRecFolder.h"
-#include "CoralBase/Blob.h"
-#include "StoreGate/StoreGateSvc.h"
-#include "AthenaPoolUtilities/CondAttrListCollection.h"
-#include "AthenaPoolUtilities/CondAttrListVec.h"
-#include "AthenaKernel/IOVRange.h"
-#include "AthenaDBTestRec/TestCoolRecPoolDataColl.h"
-
-TestCoolRecFolder::TestCoolRecFolder(const std::string& key, int type, 
-				     const SG::DataProxy* proxy,
-				     const int dumpchan,std::ofstream* dumpf) :
-  m_key(key), m_type(type), m_proxy(proxy),
-  m_dumpchan(dumpchan),m_dumpf(dumpf),
-  m_naccess(0), m_nerror(0), m_nmismatch(0),
-  m_nitems(0),m_ncallback(0)
-{}
-
-StatusCode TestCoolRecFolder::regCallBack(StoreGateSvc* detstore) {
-  if (m_type==1) {
-    const DataHandle<TestCoolRecPoolDataColl> poolcol;
-    return (detstore->regFcn(&TestCoolRecFolder::callBack,this,poolcol,m_key));
-  } else if (m_type==2) {
-    const DataHandle<CondAttrListVec> atrvec;
-    return (detstore->regFcn(&TestCoolRecFolder::callBack,this,atrvec,m_key));
-  } else if (m_type==3) {
-    // no callback registered for type 3 (generic)
-    return StatusCode::SUCCESS;
-  } else {
-    // no callback registered for type 3 (generic)
-    const DataHandle<CondAttrListCollection> atrcol;
-    return (detstore->regFcn(&TestCoolRecFolder::callBack,this,atrcol,m_key));
-  }
-}
-
-StatusCode TestCoolRecFolder::access(StoreGateSvc* detstore, const int run,
-				     const int event,const IOVTime iovkey) {
-
-  // access the data for the folder
-  int modrun=run;
-  if (m_type>3) {
-    // for folders with type > 3, have to modify the run to reflect the
-    // run modularity
-    modrun=(run-(run % m_type));
-  }
-  ++m_naccess;
-  if (m_type==1) {
-    // branch for POOL file objects
-    const TestCoolRecPoolDataColl* poolcol;
-    if (StatusCode::SUCCESS==
-      detstore->retrieve(poolcol,m_key)) {
-    // loop over objects in collection, keeping parallel channel iterator
-      TestCoolRecPoolDataColl::chan_const_iterator 
-	chanitr=poolcol->chan_begin();
-      for (DataVector<TestCoolRecPoolData>::const_iterator 
-          citr=poolcol->begin();citr!=poolcol->end();++citr,++chanitr) {
-        // access the data and check consistency for run,folder and channel
-        ++m_nitems;
-	if (modrun!=(*citr)->run() || 
-	    static_cast<int>(*chanitr)!=(*citr)->chan()
-	    || m_key!=(*citr)->folder()) {
-	  ++m_nmismatch;
-	}
-      }
-    } else {
-      ++m_nerror;
-      return StatusCode::FAILURE;
-    }
-  } else if (m_type==2) {
-    // branch for CoraCool/CoolVector objects (both appear as CondAttrListVec)
-    const CondAttrListVec* atrvec;
-    if (StatusCode::SUCCESS==detstore->retrieve(atrvec,m_key)) {
-      // loop over objects in list
-      for (CondAttrListVec::const_iterator citr=atrvec->begin();
-	   citr!=atrvec->end();++citr) {
-	// access the data - put in string
-	int chan=citr->first;
-	const coral::AttributeList& adata=citr->second;
-  	std::ostringstream atrstring;
-	adata.toOutputStream(atrstring);
-	++m_nitems;
-	// check the attribute list - fields 2 and 3 should be run/channel
-	// and size should be at least 4 (0/1 are PK/FK)
-	if (adata.size()<4 || adata[2].data<int>()!=modrun ||
-	    adata[3].data<int>()!=chan) ++m_nmismatch;
-      }
-      // alternative access via index
-      const std::vector<unsigned int>& channels=atrvec->channelIDs();
-      std::cout << "ChannelIDs vector for " << m_key << " has " << 
-	channels.size() << " elements" << std::endl;
-      // loop over the channels and get the attributes
-      for (std::vector<unsigned int>::const_iterator ci=channels.begin();
-	   ci!=channels.end();++ci) {
-	int chan=(*ci);
-	bool haschan=atrvec->hasChannel(chan);
-	if (haschan) {
-	  const std::vector<const coral::AttributeList*>& atrv=
-	    atrvec->attrListVec(chan);
-	  std::cout << "Check channel " << chan << " has info " << haschan <<
-	  " vecsize " << atrv.size() << std::endl;
-	  // dump attributelist 0 for first two channels
-	  if (chan<2) {
-	    const coral::AttributeList& atrlist=*(atrv[0]);
-	    std::cout << "Dumping AtrList for channel " << chan;
-	    atrlist.toOutputStream(std::cout);
-	    std::cout << std::endl;
-	  }
-	} else {
-	  std::cout << "Check channel " << chan << " has no info" << std::endl;
-	}
-      }
-    } else {
-      ++m_nerror;
-      return StatusCode::FAILURE;
-    }
-  } else if (m_type==3) {
-    // use DataProxy for generic folder without knowing type
-    if (m_proxy) {
-      try {
-	(const_cast<SG::DataProxy*>(m_proxy))->accessData();
-	++m_nitems;
-      }
-      catch (std::exception& e) {
-	++m_nerror;
-      }
-    } else {
-      ++m_nerror;
-    }
-  } else {
-    // branch for basic CondAttrListCollection
-    const CondAttrListCollection* atrlistcol;
-    if (StatusCode::SUCCESS==
-      detstore->retrieve(atrlistcol,m_key)) {
-      // loop over objects in collection
-      int nobj=0;
-      for (CondAttrListCollection::const_iterator citr=atrlistcol->begin();
-           citr!=atrlistcol->end();++citr) {
-        // access the data - put into a string
-  	std::ostringstream atrstring;
-  	(*citr).second.toOutputStream(atrstring);
-	++m_nitems;
-	// loop over the attributes to check possible mismatches
-	// first two are checked in case of int or float
-	// attr 0=run, attr 1=channel number
-	int natr=citr->second.size();
-	if (natr>2) natr=2;
-	for (int icol=0;icol<natr;++icol) {
-	  int target=modrun;
-	  if (icol==1) target=citr->first;
-	  const coral::Attribute& atr=(*citr).second[icol];
-	  if ((atr.specification().typeName()=="int" && 
-	       atr.data<int>()!=target) || 
-	      (atr.specification().typeName()=="float" &&
-	       fabsf(atr.data<float>()-target)>1.E-3)) ++m_nmismatch;
-          if ((atr.specification().typeName()=="string" && icol==0)) {
-	    // for first string, check begins with run,chan, sep by commas
-	    std::string::size_type iofs1,iofs2;
-	    const std::string& sdata=atr.data<std::string>();
-	    iofs1=sdata.find(",");
-	    iofs2=sdata.find(",",iofs1+1);
-	    if (iofs1!=std::string::npos && iofs2!=std::string::npos) {
-	      // correctly formed string, check numbers
-	      if (atoi(sdata.substr(0,iofs1).c_str())!=modrun || 
-		  atoi(sdata.substr(iofs1+1,iofs2-iofs1-1).c_str())!=
-		  static_cast<int>(citr->first))
-		++m_nmismatch;
-	    } else {
-	      // malformed string - counts as a mismatch
-	      ++m_nmismatch;
-	    }
-	  }
-	  if (atr.specification().typeName()=="blob") {
-	    const coral::Blob& blob=atr.data<coral::Blob>();
-	    const int* p=static_cast<const int*>
-	      (blob.startingAddress());
-	    if (*p!=modrun || *(p+1)!=static_cast<int>(citr->first)) 
-	      ++m_nmismatch;
-	  }
-	}
-	// dump information into file
-	if (nobj<abs(m_dumpchan)) {
-	  // find the IOV of this element
-	  unsigned int channum=citr->first;
-	  CondAttrListCollection::iov_const_iterator 
-	    ciov=atrlistcol->chanIOVPair(channum);
-	  const IOVRange& iovrange=ciov->second;
-	  const IOVTime& start=iovrange.start();
-	  const IOVTime& stop=iovrange.stop();
-	  bool isTS=start.isTimestamp();
-	  std::string checkstr="";
-	  if (start>iovkey || stop<=iovkey) {
-	    checkstr=" BAD";
-	    ++m_nerror;
-	  }
-	  *m_dumpf << m_key << " " << event << " " << channum << " " << 
-	    iovprint(iovkey,isTS) << " [" << iovprint(start,isTS) << "," 
-		 << iovprint(stop,isTS) << "]" << checkstr;
-	  // only dump payload if number of channels is set negative
-	  if (m_dumpchan<0) *m_dumpf << " : " << atrstring.str();
-	  *m_dumpf << std::endl;
-	}
-	++nobj;
-      }
-    } else {
-      ++m_nerror;
-      return StatusCode::FAILURE;
-    }
-  }
-  return StatusCode::SUCCESS;
-}
-
-StatusCode TestCoolRecFolder::callBack( IOVSVC_CALLBACK_ARGS_P( /* I */ ,keys) ) {
-  // use callbacks to count the number of times the object actually changes
-  for (std::list<std::string>::const_iterator itr=keys.begin();
-       itr!=keys.end(); ++itr) {
-    if (*itr==m_key) {
-      ++m_ncallback; 
-      if (m_dumpchan!=0) *m_dumpf << "Callback " << m_key << std::endl;
-    }
-  }
-  return StatusCode::SUCCESS;
-}
-
-std::string TestCoolRecFolder::iovprint(const IOVTime& time,const bool isTS) {
-  // return the IOVTime as run:event or TS
-  std::ostringstream out;
-  if (isTS) {
-    out << time.timestamp();
-  } else {
-    out << time.run() << ":" << time.event();
-  }
-  return out.str();
-}

AtlasTest/DatabaseTest/AthenaDBTestRec/src/lib/TestCoolRecPoolData.cxx

-/*
-  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
-*/
-
-// TestCoolRecPoolData.cxx
-// Richard Hawkings, started 15/9/06
-
-#include "AthenaDBTestRec/TestCoolRecPoolData.h"
-
-TestCoolRecPoolData::TestCoolRecPoolData() {m_run=0; m_chan=0; }
-
-TestCoolRecPoolData::TestCoolRecPoolData(const int run, const int chan, 
-		 const std::string& folder, const int size) : 
-  m_run(run), m_chan(chan), m_folder(folder) {
-  m_data.resize(size);
-}
-
-TestCoolRecPoolData::~TestCoolRecPoolData() {}