python.CaloCondTools Namespace Reference

Classes
class	CaloBlobReader
class	CaloBlobWriter

Functions
def	getCaloPrefix ()
def	getAthenaFolderDescr ()
def	getAthenaFolderType (folderDescr)
def	openDb (db, instance, mode="READONLY", schema="COOLOFL_CALO", sqlfn="caloSqlite.db")
def	openDbConn (connStr, mode="READONLY")
def	iovFromRunLumi (runNum, lbkNum)
def	decodeTimeString (timeString)
def	getCoolValidityKey (pointInTime, isSince=True)
def	getCellHash (detectorId, part, module, sample, tower)

Variables
	g = cppyy.gbl
	log = getLogger("CaloCondTools")
int	MINRUN = 0
int	MINLBK = 0
	MAXRUN = cool.Int32Max
	MAXLBK = cool.UInt32Max
int	UNIX2COOL = 1000000000
	UNIXTMAX = cool.Int32Max

Function Documentation

decodeTimeString()

def python.CaloCondTools.decodeTimeString

(

timeString

)

Returns UNIX time stamp given an input time string

Definition at line 187 of file CaloCondTools.py.

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

getAthenaFolderDescr()

def python.CaloCondTools.getAthenaFolderDescr

(

)

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

Definition at line 40 of file CaloCondTools.py.

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

getAthenaFolderType()

def python.CaloCondTools.getAthenaFolderType

(

folderDescr

)

Definition at line 52 of file CaloCondTools.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]
 
#
#______________________________________________________________________

getCaloPrefix()

def python.CaloCondTools.getCaloPrefix

(

)

Returns the common Calo prefix used for all COOL folders

Definition at line 32 of file CaloCondTools.py.

def getCaloPrefix():
    """
    Returns the common Calo prefix used for all COOL folders
    """
    return "/CALO/"
 
#
#______________________________________________________________________

getCellHash()

def python.CaloCondTools.getCellHash	(		detectorId,
			part,
			module,
			sample,
			tower
	)

Returns cell subHash given partition,module,sample, and tower (TILE only)

Definition at line 228 of file CaloCondTools.py.

def getCellHash(detectorId,part,module,sample,tower):
    """
    Returns cell subHash given partition,module,sample, and tower (TILE only)
    """
    if detectorId != 48:
        raise Exception('getCellHash only available for TileCells.')
    section = 0 # 1=LB* 2=EB* 3=ITC
    side = 0    # 1=A-side -1=C-side
    if part == 1 or part == 2:
        section = 1
    elif part == 3 or part == 4:
        if sample == 3 or (sample==1 and tower==9) or (sample==2 and tower==8): # Gap and ITC
            section = 3
        else:
            section = 2
    if part%2 ==0:
        side = -1
    else:
        side = 1
    if section==0 or side==0 or module>63 or sample>3 or tower>15:
        raise Exception('Non-physical cell specification')
    
    # hash array for mod0 of entire TileCal.  Use to determine cell hash for any cell
    hash = [0, 1, -1, -1, 2, 3, -1, -1, 4, 5, 6, -1, 7, 8, -1, -1, 9, 10, 11, -1, 12, 13, -1, -1, 14, 15, 16, -1, 17, 18, -1, -1, 19, 20, 4416, -1, 21, 4417, -1, -1, -1, 2880, 2881, 4418, 2882, 2883, -1, 4419, 2884, 2885, 2886, -1, 2887, 2888, -1, 4420, 2889, 2890, -1, -1, 2891, -1, -1, 4421, 1408, 1409, 1410, -1, 1411, 1412, -1, -1, 1413, 1414, 1415, -1, 1416, 1417, -1, -1, 1418, 1419, 1420, -1, 1421, 1422, -1, -1, 1423, 1424, 1425, -1, 1426, 1427, -1, -1, 1428, 1429, 4800, -1, 1430, 4801, -1, -1, -1, 3648, 3649, 4802, 3650, 3651, -1, 4803, 3652, 3653, 3654, -1, 3655, 3656, -1, 4804, 3657, 3658, -1, -1, 3659, -1, -1, 4805]
 
    # Section specific offset to be added to cell hash for module different from 0
    # [LBC,LBA,EBC,EBA,ITC-C,ITC-A]
    modOffset = [22,23,12,12,6,6]
    if side==1:
        sideOffset=1
    else:
        sideOffset=0
 
    return hash[sideOffset*16*4+tower*4+sample]+modOffset[sideOffset+2*(section-1)]*module
 
#======================================================================
#===
#=== CaloBlobReader 
#===
#======================================================================
 
#
#______________________________________________________________________

getCoolValidityKey()

def python.CaloCondTools.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 195 of file CaloCondTools.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 = iovFromRunLumi(pointInTime[0],pointInTime[1])
    #=== catch other types
    else:
        raise Exception("Unrecognized pointInTime type=%s" % type(pointInTime))
    return cool.ValidityKey(validityKey)
 
#
#______________________________________________________________________

iovFromRunLumi()

def python.CaloCondTools.iovFromRunLumi	(		runNum,
			lbkNum
	)

Returns COOL timeStamp build from run and lumi block numbers

Definition at line 179 of file CaloCondTools.py.

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

openDb()

def python.CaloCondTools.openDb	(		db,
			instance,
			mode = "READONLY",
			schema = "COOLOFL_CALO",
			sqlfn = "caloSqlite.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 60 of file CaloCondTools.py.

def openDb(db, instance, mode="READONLY", schema="COOLOFL_CALO", sqlfn="caloSqlite.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_CALO","COOLOFL_CALO","COOLONL_LAR","COOLOFL_LAR","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.CaloCondTools.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 110 of file CaloCondTools.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( "-------------------------- CaloCondTools.openDbConn -----------------------------" )
    log.info( "- using COOL version %s", dbSvc.serviceVersion()                                   )
    log.info( "- opening CaloDb: %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
 
#
#______________________________________________________________________

Variable Documentation

g

python.CaloCondTools.g = cppyy.gbl

Definition at line 15 of file CaloCondTools.py.

log

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

Definition at line 20 of file CaloCondTools.py.

MAXLBK

python.CaloCondTools.MAXLBK = cool.UInt32Max

Definition at line 26 of file CaloCondTools.py.

MAXRUN

python.CaloCondTools.MAXRUN = cool.Int32Max

Definition at line 25 of file CaloCondTools.py.

MINLBK

int python.CaloCondTools.MINLBK = 0

Definition at line 24 of file CaloCondTools.py.

MINRUN

int python.CaloCondTools.MINRUN = 0

Definition at line 23 of file CaloCondTools.py.

UNIX2COOL

int python.CaloCondTools.UNIX2COOL = 1000000000

Definition at line 27 of file CaloCondTools.py.

UNIXTMAX

python.CaloCondTools.UNIXTMAX = cool.Int32Max

Definition at line 28 of file CaloCondTools.py.