python.TileCalibTools Namespace Reference

Classes
class	TileBlobWriter
class	TileBlobReader
class	TileASCIIParser
class	TileASCIIParser2
class	TileASCIIParser3

Functions
	getLastRunNumber ()
	getNextRunNumber ()
	getPromptCalibRunNumber ()
	getAliasFromFile (aliastype='Current')
	getTilePrefix (ofl=True, splitOnlInOflSchema=True)
	getTilePrefixes ()
	getAthenaFolderDescr (type="run-lumi")
	getAthenaFolderType (folderDescr)
	openDb (db, instance, mode="READONLY", schema="COOLOFL_TILE", sqlfn="tileSqlite.db")
	openDbOracle (db, schema, folder)
	openDbConn (connStr, mode="READONLY")
	coolTimeFromRunLumi (runNum, lbkNum)
	decodeTimeString (timeString)
	getCoolValidityKey (pointInTime, isSince=True)
	getFolderTag (db, folderPath, globalTag)
	findTag (folder, tag)
	runLumiFromCoolTime (iov)
	copyFolder (dbr, dbw, folder, tagr, tagw, chanNum, pointInTime1, pointInTime2)
	moduleListToString (modules, checkAUX=True, checkMOD=True, checkComment=True, shortLength=15, exceptLength=15)

Variables
	log = getLogger("TileCalibTools")
int	MINRUN = 0
int	MINLBK = 0
	MAXRUN = cool.Int32Max
	MAXLBK = cool.UInt32Max
int	UNIX2COOL = 1000000000
	UNIXTMAX = cool.Int32Max
int	LASPARTCHAN = 43

Function Documentation

coolTimeFromRunLumi()

python.TileCalibTools.coolTimeFromRunLumi	(		runNum,
			lbkNum )

Returns COOL timeStamp build from run and lumi block numbers

Definition at line 364 of file TileCalibTools.py.

def coolTimeFromRunLumi(runNum, lbkNum):
    """
    Returns COOL timeStamp build from run and lumi block numbers
    """
    return (int(runNum)<<32) + int(lbkNum)
 
#
#______________________________________________________________________

copyFolder()

python.TileCalibTools.copyFolder	(		dbr,
			dbw,
			folder,
			tagr,
			tagw,
			chanNum,
			pointInTime1,
			pointInTime2 )

Definition at line 515 of file TileCalibTools.py.

def copyFolder(dbr, dbw, folder, tagr, tagw, chanNum, pointInTime1, pointInTime2):
 
    log.info("Copy channel %i", chanNum)
 
    folderR = dbr.getFolder(folder)
    folderW = dbw.getFolder(folder)
 
    chansel = cool.ChannelSelection(chanNum)
 
    iov1 = getCoolValidityKey(pointInTime1,False)
    iov2 = getCoolValidityKey(pointInTime2,False)
 
    if tagr=='':
        multiVersion = False
        objs = folderR.browseObjects(iov1,iov2,chansel)
    else:
        multiVersion = True
        objs = folderR.browseObjects(iov1,iov2,chansel,tagr)
    while objs.goToNext():
        obj=objs.currentRef()
        sinceCool=obj.since()
        if sinceCool < iov1:
            sinceCool = iov1
        untilCool=obj.until()
        data=obj.payload()
        sinceTup = runLumiFromCoolTime(sinceCool)
        untilTup = runLumiFromCoolTime(untilCool)
        log.debug("Copy entry: [%i,%i] - [%i,%i]: %s", sinceTup[0],sinceTup[1],untilTup[0],untilTup[1], data)
        folderW.storeObject(sinceCool, untilCool, data, chanNum, tagw, multiVersion)
 
#
#____________________________________________________________________

decodeTimeString()

python.TileCalibTools.decodeTimeString

(

timeString

)

Retruns UNIX time stamp given an input time string

Definition at line 372 of file TileCalibTools.py.

def decodeTimeString(timeString):
    """
    Retruns UNIX time stamp given an input time string
    """
    return int(time.mktime(time.strptime(timeString,"%Y-%m-%d %H:%M:%S")))
 
#
#______________________________________________________________________

findTag()

python.TileCalibTools.findTag	(		folder,
			tag )

Definition at line 498 of file TileCalibTools.py.

def findTag(folder,tag):
    taglist=folder.listTags()
    if len(taglist):
        if tag=='FIRST':
            return taglist[0]
        else:
            return taglist[-1]
    else:
        return 'tag-not-found'
 
#
#____________________________________________________________________

getAliasFromFile()

python.TileCalibTools.getAliasFromFile

(

aliastype = 'Current'

)

Return name of top-level tag for 'Current' or 'CurrentES' or 'Next' or 'NextES' aliases

Definition at line 141 of file TileCalibTools.py.

def getAliasFromFile(aliastype='Current'):
    """
    Return name of top-level tag for 'Current' or 'CurrentES' or 'Next' or 'NextES' aliases
    """
 
    try:
        aliasfolder = os.getenv(
            'TILE_ALIAS_FOLDER',
            '/afs/cern.ch/atlas/conditions/poolcond/buffer/BestKnowledge'
            )
        if not aliasfolder or not os.path.isdir(aliasfolder):
            log.warning("Alias folder not found: %s", aliasfolder)
            raise FileNotFoundError(aliasfolder)
        falias = open('%s/%s' % (aliasfolder, aliastype))
        alias = falias.readline()
        falias.close()
        return alias.replace('\n','').replace('*','')
    except Exception:
        aliasfolder = os.getcwd()+'/BestKnowledge'
        print("Looking for %s in %s" % (aliastype,aliasfolder))
        try:
            falias = open('%s/%s' % (aliasfolder, aliastype))
            alias = falias.readline()
            falias.close()
            return alias.replace('\n','').replace('*','')
        except Exception:
            return aliastype.upper()
 
#
#______________________________________________________________________

getAthenaFolderDescr()

python.TileCalibTools.getAthenaFolderDescr

(

type = "run-lumi"

)

Returns the run-lumi type folder description needed to read back the folder content
as a CondAttrListCollection in Athena.

Definition at line 199 of file TileCalibTools.py.

def getAthenaFolderDescr(type="run-lumi"):
    """
    Returns the run-lumi type folder description needed to read back the folder content
    as a CondAttrListCollection in Athena.
    """
    desc ='<timeStamp>'+type+'</timeStamp>'
    desc+='<addrHeader><address_header service_type="71" clid="1238547719" /></addrHeader>'
    desc+='<typeName>CondAttrListCollection</typeName>'
    return desc
 
#
#______________________________________________________________________

getAthenaFolderType()

python.TileCalibTools.getAthenaFolderType

(

folderDescr

)

Definition at line 211 of file TileCalibTools.py.

def getAthenaFolderType(folderDescr):
    type = re.compile(".*<timeStamp>(.*)</timeStamp>.*").search(folderDescr)
    if not type:
        raise Exception("No folder type info found in \'%s\'" % folderDescr)
    return type.groups()[0]
 
#
#______________________________________________________________________

getCoolValidityKey()

python.TileCalibTools.getCoolValidityKey	(		pointInTime,
			isSince = True )

The interpretation of pointInTime depends on their type:
- tuple(int,int) : run and lbk number
- integer        : Values are interpreted as unix time stamps
- string         : time stamp of format 'yyyy-mm-dd hh:mm:ss'

Definition at line 380 of file TileCalibTools.py.

def getCoolValidityKey(pointInTime, isSince=True):
    """
    The interpretation of pointInTime depends on their type:
    - tuple(int,int) : run and lbk number
    - integer        : Values are interpreted as unix time stamps
    - string         : time stamp of format 'yyyy-mm-dd hh:mm:ss'
    """
 
    validityKey = None
 
    #=== string: convert to unix time and treat as latter
    if isinstance(pointInTime, str):
        pointInTime = decodeTimeString(pointInTime)
 
    #=== integer: unix time stamp
    if isinstance(pointInTime, int):
        if pointInTime >=0:
            validityKey = pointInTime * UNIX2COOL
        else:
            if isSince:
                validityKey = int(time.time()) * UNIX2COOL
            else      :
                validityKey = cool.ValidityKeyMax
    #=== run-lumi tuple
    elif isinstance(pointInTime, tuple):
        validityKey = coolTimeFromRunLumi(pointInTime[0],pointInTime[1])
    #=== catch other types
    else:
        raise Exception("Unrecognized pointInTime type=%s" % type(pointInTime))
    return cool.ValidityKey(validityKey)
 
 
#
#____________________________________________________________________

getFolderTag()

python.TileCalibTools.getFolderTag	(		db,
			folderPath,
			globalTag )

Definition at line 414 of file TileCalibTools.py.

def getFolderTag(db, folderPath, globalTag):
 
    tag=""
    gTAG = globalTag.upper()
    findTAG = (gTAG == "ANY" or gTAG == "FIRST" or gTAG == "LAST")
    if globalTag.startswith("/") or globalTag.startswith("TileO") or globalTag.upper().startswith("CALO"):
        tag = globalTag
        log.warning("Using tag as-is for folder %s", folderPath)
    elif '/TILE/ONL01' in folderPath:
        log.info("Using empty tag for single-version folder %s", folderPath)
    elif globalTag.startswith(" "):
        log.warning("Using empty tag for folder %s", folderPath)
    elif globalTag=="":
        tag = TileCalibUtils.getFullTag(folderPath, globalTag)
        log.warning("Using tag with empty suffix for folder %s", folderPath)
    else:
        if folderPath.startswith('/CALO'):
            dbname = 'COOLOFL_CALO' if folderPath.startswith('/CALO/Ofl') else 'COOLONL_CALO'
        else:
            dbname ='COOLOFL_TILE'
        schema=dbname+'/CONDBR2'
        if isinstance(db, str):
            if 'OFLP200' in db or 'MC' in db:
                schema=dbname+'/OFLP200'
                if not globalTag.startswith("OFLCOND"):
                    if globalTag.startswith("RUN"):
                        globalTag='OFLCOND-'+globalTag
                        log.info("Using Simulation global tag \'%s\'", globalTag)
            elif 'COMP200' in db or 'RUN1' in db:
                schema=dbname+'/COMP200'
                if globalTag!='UPD1' and globalTag!='UPD4' and ('UPD1' in globalTag or 'UPD4' in globalTag or 'COND' not in globalTag):
                    if not findTAG:
                        log.info("Using suffix \'%s\' as it is", globalTag)
                else:
                    findTAG = False
                    globalTag='COMCOND-BLKPA-RUN1-06'
                    log.info("Using RUN1 global tag \'%s\'", globalTag)
        if schema == dbname+'/CONDBR2':
            if globalTag=='CURRENT' or globalTag=='UPD4' or globalTag=='':
                globalTag=getAliasFromFile('Current')
                log.info("Resolved CURRENT globalTag to \'%s\'", globalTag)
            elif globalTag=='CURRENTES' or globalTag=='UPD1':
                globalTag=getAliasFromFile('CurrentES')
                log.info("Resolved CURRENT ES globalTag to \'%s\'", globalTag)
            elif globalTag=='NEXT':
                globalTag=getAliasFromFile('Next')
                log.info("Resolved NEXT globalTag to \'%s\'", globalTag)
            elif globalTag=='NEXTES':
                globalTag=getAliasFromFile('NextES')
                log.info("Resolved NEXT ES globalTag to \'%s\'", globalTag)
        globalTag=globalTag.replace('*','')
        if not findTAG and ('UPD1' in globalTag or 'UPD4' in globalTag or 'COND' not in globalTag):
            tag = TileCalibUtils.getFullTag(folderPath, globalTag)
            if tag.startswith('Calo') and 'NoiseCell' not in tag:
                tag='CALO'+tag[4:]
                tag=tag.replace('Pileupnoiselumi','PileUpNoiseLumi')
            log.info("Resolved localTag \'%s\' to folderTag \'%s\'", globalTag,tag)
        else:
            if not isinstance(db, str):
                try:
                    folder = db.getFolder(folderPath)
                    if findTAG:
                        tag = findTag(folder,gTAG)
                    else:
                        tag = folder.resolveTag(globalTag)
                    log.info("Resolved globalTag \'%s\' to folderTag \'%s\'", globalTag,tag)
                    schema=""
                except Exception as e:
                    log.warning(e)
                    log.warning("Using %s to resolve globalTag",schema)
            if len(schema):
                dbr = openDbConn(schema,'READONLY')
                folder = dbr.getFolder(folderPath)
                if findTAG:
                    tag = findTag(folder,gTAG)
                else:
                    tag = folder.resolveTag(globalTag)
                dbr.closeDatabase()
                log.info("Resolved globalTag \'%s\' to folderTag \'%s\'", globalTag,tag)
 
    return tag
 
#
#____________________________________________________________________

getLastRunNumber()

python.TileCalibTools.getLastRunNumber

(

)

Return the run number of next run to be taken in the pit
Keep this function temporary for backward compatibility

Definition at line 50 of file TileCalibTools.py.

def getLastRunNumber():
    """
    Return the run number of next run to be taken in the pit
    Keep this function temporary for backward compatibility
    """
    return getNextRunNumber()
 
#
#______________________________________________________________________

getNextRunNumber()

python.TileCalibTools.getNextRunNumber

(

)

Return the run number of next run to be taken in the pit

Definition at line 59 of file TileCalibTools.py.

def getNextRunNumber():
    """
    Return the run number of next run to be taken in the pit
    """
 
    urls = ["http://atlas-run-info-api.web.cern.ch/api/runs?sort=runnumber:DESC&size=1",
            "http://pcata007.cern.ch/cgi-bin/getLastRunNumber.py",
            "http://pcata007.cern.ch/latestRun"]
 
    run=0
    for url in urls:
        try:
            for line in urlopen(url).readlines():
                r=line.strip()
                if r.isdigit():
                    run=int(r)
                    break
                else:
                    jdata=json.loads(r)
                    run=int(jdata['resources'][0]['runnumber'])
                    break
            if run>0:
                break
        except Exception:
            continue
 
    return max(run+1,222222)
 
#
#______________________________________________________________________

getPromptCalibRunNumber()

python.TileCalibTools.getPromptCalibRunNumber

(

)

Return the minimal run number of runs in prompt calibration loop

Definition at line 89 of file TileCalibTools.py.

def getPromptCalibRunNumber():
    """
    Return the minimal run number of runs in prompt calibration loop
    """
 
    promptCalibRuns = []
 
    try:
        aliascalibrun = os.getenv(
            'TILE_ALIAS_CALIBRUN',
            '/afs/cern.ch/user/a/atlcond/scratch0/nemo/prod/web/calibruns.txt'
            )
        if not aliascalibrun or not os.path.exists(aliascalibrun):
            log.warning("Prompt calib run file not found: %s", aliascalibrun)
            raise FileNotFoundError(aliascalibrun)
        fin = open(aliascalibrun, 'r').read().split()
        for line in fin:
            try:
                if line:
                    promptCalibRuns.append( int(line) )
            except ValueError:
                pass
    except Exception:
        promptCalibRuns=[]
 
    if len(promptCalibRuns)==0:
 
        urls = ["http://pcata007.cern.ch/cgi-bin/getBulkRunNumber.py",
                "http://pcata007.cern.ch/latestRun"]
 
        run=0
        for url in urls:
            try:
                for line in urlopen(url).readlines():
                    r=line.strip()
                    if r.isdigit():
                        run=int(r)
                        break
                if run>0:
                    promptCalibRuns=[run]
                    break
            except Exception:
                continue
 
    if len(promptCalibRuns) >= 1:
        promptCalibRuns.sort()
        return promptCalibRuns[0]
    else:
        return getNextRunNumber()
 
#
#______________________________________________________________________

getTilePrefix()

python.TileCalibTools.getTilePrefix	(		ofl = True,
			splitOnlInOflSchema = True )

Returns the common Tile prefix used for all COOL folders.
ofl = False ... single version folders
ofl = True  ... multiversion folders
splitOnlInOflSchema = False ... offline only folders or
                splitOnline folders in Online schema
splitOnlInOflSchema = True ... splitOnlineFolders in
                offline schema

Definition at line 171 of file TileCalibTools.py.

def getTilePrefix(ofl=True,splitOnlInOflSchema=True):
    """
    Returns the common Tile prefix used for all COOL folders.
    ofl = False ... single version folders
    ofl = True  ... multiversion folders
    splitOnlInOflSchema = False ... offline only folders or
                    splitOnline folders in Online schema
    splitOnlInOflSchema = True ... splitOnlineFolders in
                    offline schema
    """
    if ofl:
        if splitOnlInOflSchema:
            return "/TILE/OFL02/"
        else:
            return "/TILE/OFL01/"
    else:
        return "/TILE/ONL01/"
 
#
#______________________________________________________________________

getTilePrefixes()

python.TileCalibTools.getTilePrefixes

(

)

Returns a list of all TILE folder prefixes

Definition at line 191 of file TileCalibTools.py.

def getTilePrefixes():
    """
    Returns a list of all TILE folder prefixes
    """
    return ["/TILE/ONL01/","/TILE/OFL01/","/TILE/OFL02/"]
 
#
#______________________________________________________________________

moduleListToString()

python.TileCalibTools.moduleListToString	(		modules,
			checkAUX = True,
			checkMOD = True,
			checkComment = True,
			shortLength = 15,
			exceptLength = 15 )

Definition at line 547 of file TileCalibTools.py.

def moduleListToString(modules, checkAUX=True, checkMOD=True, checkComment=True, shortLength=15, exceptLength=15):
 
    fulllist = "@".join(modules)
    mlist = []
 
    if checkAUX:
        list1=re.findall("AUX..",fulllist)
        if len(list1)==20:
            mlist += ["ALL 20 AUX modules"]
        elif list1:
            mlist += [" ".join(list1)]
        else:
            mlist += ["NO AUX modules"]
 
    if checkMOD:
        list2=re.findall("[LE]B[AC]..",fulllist)
        if len(list2)==256:
            mlist += ["ALL 256 modules"]
        elif 256-len(list2)<=exceptLength:
            list3 = []
            for p in ["LBA","LBC","EBA","EBC"]:
                for n in range(1,65):
                    m = "%s%02d" % (p,n)
                    if m not in list2:
                        list3 += [m]
            mlist += ["%d modules: all except %s" % (len(list2)," ".join(list3))]
        elif list2:
            if len(list2)<=shortLength:
                mlist += [" ".join(list2)]
            else:
                for p in ["LBA","LBC","EBA","EBC"]:
                    list2=re.findall(p+"..",fulllist)
                    if len(list2)==64:
                        mlist += ["64 %s modules" % p]
                    elif 64-len(list2)<=exceptLength:
                        list3 = []
                        for n in range(1,65):
                            m = "%s%02d" % (p,n)
                            if m not in list2:
                                list3 += [m]
                        mlist += ["%d %s modules: all except %s" % (len(list2),p," ".join(list3))]
                    elif list2:
                        mlist += [" ".join(list2)]
                    else:
                        mlist += ["NO %s modules" % p]
        else:
            mlist += ["NO modules"]
 
    if checkComment:
        list4=re.findall("Comment[^@]*",fulllist)
        if list4:
            mlist += [" ".join(list4)]
        else:
            mlist += ["NO COMMENT"]
 
    all = ", ".join(mlist)
    return all
 
 
 
#======================================================================
#===
#=== TileBlobWriter
#===
#======================================================================
 
#
#______________________________________________________________________

openDb()

python.TileCalibTools.openDb	(		db,
			instance,
			mode = "READONLY",
			schema = "COOLOFL_TILE",
			sqlfn = "tileSqlite.db" )

Opens a COOL db connection.
- db:       The DB type. The following names are recognized:
                * SQLITE: Opens file mentioned in sqlfn parameter
                * ORACLE or FRONTIER: Opens ORACLE DB, forces READONLY
- instance: One of valid instances - CONDBR2 OFLP200 COMP200 CMCP200
- mode:     Can be READONLY (default), RECREATE or UPDATE
- schema:   One of valid schemas - COOLONL_CALO COOLOFL_CALO COOLONL_LAR COOLOFL_LAR COOLONL_TILE COOLOFL_TILE
- sqlfn:    Name of sqlite file if db is SQLITE

Definition at line 219 of file TileCalibTools.py.

def openDb(db, instance, mode="READONLY", schema="COOLOFL_TILE", sqlfn="tileSqlite.db"):
    """
    Opens a COOL db connection.
    - db:       The DB type. The following names are recognized:
                    * SQLITE: Opens file mentioned in sqlfn parameter
                    * ORACLE or FRONTIER: Opens ORACLE DB, forces READONLY
    - instance: One of valid instances - CONDBR2 OFLP200 COMP200 CMCP200
    - mode:     Can be READONLY (default), RECREATE or UPDATE
    - schema:   One of valid schemas - COOLONL_CALO COOLOFL_CALO COOLONL_LAR COOLOFL_LAR COOLONL_TILE COOLOFL_TILE
    - sqlfn:    Name of sqlite file if db is SQLITE
    """
    #=== check for valid db names
    if db is not None:
        validDb = ["SQLITE", "ORACLE", "FRONTIER"]
        if db not in validDb:
            raise Exception( "DB not valid: %s, valid DBs are: %s" % (db,validDb) )
        elif db == "ORACLE" or db == "FRONTIER":
            mode = "READONLY"
 
    #=== check for valid instance names
    validInstance = ["COMP200", "CONDBR2", "CMCP200", "OFLP200"]
    if instance not in validInstance:
        raise Exception( "Instance not valid: %s, valid instance are: %s" % (instance,validInstance) )
 
    #=== check for valid schema names
    validSchema = ["COOLONL_TILE","COOLOFL_TILE"]
    if schema not in validSchema:
        raise Exception( "Schema not valid: %s, valid schemas are: %s" % (schema,validSchema) )
 
    #=== construct connection string
    connStr = ""
    if db=='SQLITE':
        if mode=="READONLY" and not os.path.exists(sqlfn):
            raise Exception( "Sqlite file %s does not exist" % (sqlfn) )
        if (mode=="RECREATE" or mode=="UPDATE") and not os.path.exists(os.path.dirname(sqlfn)):
            dirn=os.path.dirname(sqlfn)
            if dirn:
                os.makedirs(dirn)
        connStr="sqlite://X;schema=%s;dbname=%s" % (sqlfn,instance)
    elif db=='FRONTIER':
        connStr='frontier://ATLF/()/;schema=ATLAS_%s;dbname=%s' % (schema,instance)
    elif db=='ORACLE':
        connStr='oracle://%s;schema=ATLAS_%s;dbname=%s' % ('ATLAS_COOLPROD',schema,instance)
    else:
        connStr=schema+'/'+instance
 
    return openDbConn(connStr, mode)
 
#
#______________________________________________________________________

openDbConn()

python.TileCalibTools.openDbConn	(		connStr,
			mode = "READONLY" )

Opens a COOL db connection.
- connStr: The DB connection string
- mode:    Can be READONLY (default), RECREATE or UPDATE
           or ORACLE or FRONTIER if connStr is only short name of the database

Definition at line 295 of file TileCalibTools.py.

def openDbConn(connStr, mode="READONLY"):
    """
    Opens a COOL db connection.
    - connStr: The DB connection string
    - mode:    Can be READONLY (default), RECREATE or UPDATE
               or ORACLE or FRONTIER if connStr is only short name of the database
    """
 
    #=== split the name into schema and dbinstance
    splitname=connStr.split('/')
    if (len(splitname)!=2):  # string connection ready to be used as it is
        connStr_new=connStr
    else:                    # construct connection string
        schema=splitname[0]
        instance=splitname[1]
        if mode=="ORACLE":
            connStr_new='oracle://%s;schema=ATLAS_%s;dbname=%s' % ('ATLAS_COOLPROD',schema,instance)
        else:
            connStr_new='frontier://ATLF/()/;schema=ATLAS_%s;dbname=%s' % (schema,instance)
 
    #=== get dbSvc and print header info
    dbSvc = cool.DatabaseSvcFactory.databaseService()
    log.info( "---------------------------------------------------------------------------------" )
    log.info( "-------------------------- TileCalibTools.openDbConn ----------------------------" )
    log.info( "- using COOL version %s", dbSvc.serviceVersion()                                   )
    log.info( "- opening TileDb: %s",connStr_new                                                  )
    log.info( "- mode: %s", mode                                                                  )
    log.info( "---------------------------------------------------------------------------------" )
 
    #=== action depends on mode
    if mode in ["READONLY","ORACLE","FRONTIER","",None]:
        #=== open read only
        try:
            db=dbSvc.openDatabase(connStr_new,True)
        except Exception as e:
            log.debug( e )
            log.critical("Could not connect to %s" % connStr_new )
            return None
        return db
    elif mode=="RECREATE":
        #=== recreating database
        dbSvc.dropDatabase(connStr_new)
        try:
            db = dbSvc.createDatabase(connStr_new)
        except Exception as e:
            log.debug( e )
            log.critical( "Could not create database, giving up..." )
            return None
        return db
    elif mode=="UPDATE":
        #=== update database
        try:
            db=dbSvc.openDatabase(connStr_new,False)
        except Exception as e:
            log.debug( e )
            log.warning( "Could not connect to \'%s\', trying to create it....", connStr_new )
            try:
                db=dbSvc.createDatabase(connStr_new)
            except Exception as e:
                log.debug( e )
                log.critical( "Could not create database, giving up..." )
                return None
        return db
    else:
        log.error("Mode \"%s\" not recognized", mode )
        return None
 
#
#______________________________________________________________________

openDbOracle()

python.TileCalibTools.openDbOracle	(		db,
			schema,
			folder )

Opens a COOL db connection.
- db:       The DB type. The following names are recognized:
                * ORACLE or FRONTIER: Opens ORACLE DB, forces READONLY
- schema:   Full schema string for sqlite file, dbname will be extracted from this string
- folder:   Fill folder path, schema string will be construced using folder name

Definition at line 269 of file TileCalibTools.py.

def openDbOracle(db, schema, folder):
    """
    Opens a COOL db connection.
    - db:       The DB type. The following names are recognized:
                    * ORACLE or FRONTIER: Opens ORACLE DB, forces READONLY
    - schema:   Full schema string for sqlite file, dbname will be extracted from this string
    - folder:   Fill folder path, schema string will be construced using folder name
    """
 
    connStr = 'COOL'
    if '/OFL' in folder.upper():
        connStr += 'OFL_'
    else:
        connStr += 'ONL_'
    connStr += folder.strip('/').split('/')[0].upper()
    dbn=schema.split('dbname=')
    if len(dbn)==2:
        dbname=dbn[1].split(';')[0]
    else:
        dbname='CONDBR2'
    connStr += '/' + dbname
 
    return openDbConn(connStr,db)
 
#
#______________________________________________________________________

runLumiFromCoolTime()

python.TileCalibTools.runLumiFromCoolTime

(

iov

)

Definition at line 510 of file TileCalibTools.py.

def runLumiFromCoolTime(iov):
    return (int(iov >> 32), int(iov & 0xFFFFFFFF))
 
#
#____________________________________________________________________

Variable Documentation

LASPARTCHAN

int python.TileCalibTools.LASPARTCHAN = 43

Definition at line 46 of file TileCalibTools.py.

log

python.TileCalibTools.log = getLogger("TileCalibTools")

Definition at line 27 of file TileCalibTools.py.

MAXLBK

python.TileCalibTools.MAXLBK = cool.UInt32Max

Definition at line 42 of file TileCalibTools.py.

MAXRUN

python.TileCalibTools.MAXRUN = cool.Int32Max

Definition at line 41 of file TileCalibTools.py.

MINLBK

int python.TileCalibTools.MINLBK = 0

Definition at line 40 of file TileCalibTools.py.

MINRUN

int python.TileCalibTools.MINRUN = 0

Definition at line 39 of file TileCalibTools.py.

UNIX2COOL

int python.TileCalibTools.UNIX2COOL = 1000000000

Definition at line 43 of file TileCalibTools.py.

UNIXTMAX

python.TileCalibTools.UNIXTMAX = cool.Int32Max

Definition at line 44 of file TileCalibTools.py.