python.TileCalibTools Namespace Reference

Classes
class	TileASCIIParser
class	TileASCIIParser2
class	TileASCIIParser3
class	TileBlobReader
class	TileBlobWriter

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

Variables
	log
	MINRUN
	MINLBK
	MAXRUN
	MAXLBK
	UNIX2COOL
	UNIXTMAX
	LASPARTCHAN

Function Documentation

coolTimeFromRunLumi()

def python.TileCalibTools.coolTimeFromRunLumi	(		runNum,
			lbkNum
	)

Returns COOL timeStamp build from run and lumi block numbers

Definition at line 344 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()

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

Definition at line 494 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)
 
 
 
#======================================================================
#===
#=== TileBlobWriter
#===
#======================================================================
 
#
#______________________________________________________________________

decodeTimeString()

def python.TileCalibTools.decodeTimeString

(

timeString

)

Retruns UNIX time stamp given an input time string

Definition at line 352 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()

def python.TileCalibTools.findTag	(		folder,
			tag
	)

Definition at line 477 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()

def python.TileCalibTools.getAliasFromFile

(

aliastype = 'Current'

)

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

Definition at line 126 of file TileCalibTools.py.

def getAliasFromFile(aliastype='Current'):
    """
    Return name of top-level tag for 'Current' or 'CurrentES' or 'Next' or 'NextES' aliases
    """
 
    aliasfolder = '/afs/cern.ch/atlas/conditions/poolcond/buffer/BestKnowledge'
    try:
        falias = open('%s/%s' % (aliasfolder, aliastype))
        alias = falias.readline()
        falias.close()
        return alias.replace('\n','').replace('*','')
    except Exception:
        import os
        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()

def 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 179 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()

def python.TileCalibTools.getAthenaFolderType

(

folderDescr

)

Definition at line 191 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()

def 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 360 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()

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

Definition at line 394 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:]
            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()

def python.TileCalibTools.getLastRunNumber

(

)

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

Definition at line 55 of file TileCalibTools.py.

def getLastRunNumber():
    """
    Return the run number of next run to be taken in the pit
    """
 
    urls = ["http://atlas-service-db-runlist.web.cern.ch/atlas-service-db-runlist/cgi-bin/latestRun.py",
            "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
            if run>0:
                break
        except Exception:
            continue
 
    return max(run+1,222222)
 
#
#______________________________________________________________________

getPromptCalibRunNumber()

def python.TileCalibTools.getPromptCalibRunNumber

(

)

Return the minimal run number of runs in prompt calibration loop

Definition at line 81 of file TileCalibTools.py.

def getPromptCalibRunNumber():
    """
    Return the minimal run number of runs in prompt calibration loop
    """
 
    promptCalibRuns = []
 
    try:
        fin = open("/afs/cern.ch/user/a/atlcond/scratch0/nemo/prod/web/calibruns.txt","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 getLastRunNumber()
 
#
#______________________________________________________________________

getTilePrefix()

def 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 151 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()

def python.TileCalibTools.getTilePrefixes

(

)

Returns a list of all TILE folder prefixes

Definition at line 171 of file TileCalibTools.py.

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

openDb()

def 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 199 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()

def 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 275 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()

def 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 249 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()

def python.TileCalibTools.runLumiFromCoolTime

(

iov

)

Definition at line 489 of file TileCalibTools.py.

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

Variable Documentation

LASPARTCHAN

python.TileCalibTools.LASPARTCHAN

Definition at line 51 of file TileCalibTools.py.

log

python.TileCalibTools.log

Definition at line 32 of file TileCalibTools.py.

MAXLBK

python.TileCalibTools.MAXLBK

Definition at line 47 of file TileCalibTools.py.

MAXRUN

python.TileCalibTools.MAXRUN

Definition at line 46 of file TileCalibTools.py.

MINLBK

python.TileCalibTools.MINLBK

Definition at line 45 of file TileCalibTools.py.

MINRUN

python.TileCalibTools.MINRUN

Definition at line 44 of file TileCalibTools.py.

UNIX2COOL

python.TileCalibTools.UNIX2COOL

Definition at line 48 of file TileCalibTools.py.

UNIXTMAX

python.TileCalibTools.UNIXTMAX

Definition at line 49 of file TileCalibTools.py.