python.CaloCondTools.CaloBlobWriter Class Reference

Inheritance diagram for python.CaloCondTools.CaloBlobWriter:

Collaboration diagram for python.CaloCondTools.CaloBlobWriter:

Public Member Functions
	__init__ (self, db, folderPath, caloBlobType=None, isMultiVersionFolder=True, isRunLumiTimeStamp=True)
	register (self, since=(MINRUN, MINLBK), until=(MAXRUN, MAXLBK), tag="")
	getCells (self, systemId)
	zeroBlob (self, systemId)

Private Attributes
	__db = db
	__folder = self.__db.getFolder(folderPath)
dict	__chanDictRecord = {}
dict	__chanDictCells = {}

Detailed Description

Helper class that enables writing to Calo DB

Definition at line 391 of file CaloCondTools.py.

Constructor & Destructor Documentation

__init__()

python.CaloCondTools.CaloBlobWriter.__init__	(		self,
			db,
			folderPath,
			caloBlobType = None,
			isMultiVersionFolder = True,
			isRunLumiTimeStamp = True )

Input:
- db        : db should be an open database connection 
- folderPath: full folder path to create or update

Definition at line 397 of file CaloCondTools.py.

            isMultiVersionFolder=True, isRunLumiTimeStamp=True):
        """
        Input:
        - db        : db should be an open database connection 
        - folderPath: full folder path to create or update
        """
 
        #=== initialize base class
        CaloCondLogger.__init__(self,"CaloBlobWriter")
 
        #=== store db
        self.__db  = db
 
        #=== determine folder mode
        folderMode = cool.FolderVersioning.MULTI_VERSION
        if not isMultiVersionFolder:
            folderMode = cool.FolderVersioning.SINGLE_VERSION
 
        #=== determine folder description
        folderDescr = getAthenaFolderDescr()
 
        #=== access folder in db
        try:
        #=== create folder if it does not exist
            if self.__db.existsFolder(folderPath):
                self.__folder = self.__db.getFolder(folderPath)
                #=== check folder mode
                modeInCool = self.__folder.versioningMode()
                if modeInCool!=folderMode:
                    str = "Incompatible folder mode detected, COOL folder has type "
                    if modeInCool==cool.FolderVersioning.MULTI_VERSION:
                        str += "MULTI"
                    else:
                        str += "SINGLE"
                    raise Exception(str)
            else:
                #=== create folder if it does not exist
                payloadSpec = cool.RecordSpecification()
                payloadSpec.extend( 'CaloCondBlob16M', cool.StorageType.Blob16M )
                folderSpec = cool.FolderSpecification(folderMode, payloadSpec)
                self.__folder = db.createFolder(folderPath, folderSpec, folderDescr, True)
        except Exception as e:
            self.log().critical( e )
            raise
 
        #=== initialize channel dictionaries
        self.__chanDictRecord  = {} # <int, cool.Record    >
        self.__chanDictCells   = {} # <int, CaloCondBlobFlt>
 

Member Function Documentation

getCells()

python.CaloCondTools.CaloBlobWriter.getCells	(		self,
			systemId )

Returns a CaloCondBlob object of given system Id.

Definition at line 515 of file CaloCondTools.py.

    def getCells(self, systemId):
        """
        Returns a CaloCondBlob object of given system Id.
        """
 
        #try:
        chanNum = cool.ChannelId(systemId)
        flt = self.__chanDictCells.get(chanNum,None)
        #=== ... if not, get it from DB
        if not flt:
            #=== create new blob
            spec = self.__folder.payloadSpecification()
            data = cool.Record( spec )
            self.__chanDictRecord[chanNum] = data
            for key in data:
                blob = data[key]
            flt = g.CaloCondBlobFlt.getInstance(blob)
 
        self.__chanDictCells[chanNum] = flt    
        return flt
        
        #except Exception as e:
        #    self.log().critical( e )
        #    return None
 

register()

python.CaloCondTools.CaloBlobWriter.register	(		self,
			since = (MINRUN,MINLBK),
			until = (MAXRUN,MAXLBK),
			tag = "" )

Registers the folder in the database.
- since: lower limit of IOV
- until: upper limit of IOV
- tag  : The cool folder tag to write to

The interpretation of the 'since' and 'until' inputs depends on their type:
- tuple(int,int) : run and lbk number 
- integer        : Values are interpreted as unix time stamps
                   If since<0, current time is assumed
                   If until<0, infinity is assumed
- string         : time stamp of format 'yyyy-mm-dd hh:mm:ss'

Definition at line 448 of file CaloCondTools.py.

    def register(self, since=(MINRUN,MINLBK), until=(MAXRUN,MAXLBK), tag=""):
        """
        Registers the folder in the database.
        - since: lower limit of IOV
        - until: upper limit of IOV
        - tag  : The cool folder tag to write to
 
        The interpretation of the 'since' and 'until' inputs depends on their type:
        - tuple(int,int) : run and lbk number 
        - integer        : Values are interpreted as unix time stamps
                           If since<0, current time is assumed
                           If until<0, infinity is assumed
        - string         : time stamp of format 'yyyy-mm-dd hh:mm:ss'
        """
 
        #=== check for inconsistent input
        if type(since)!=type(until):
            raise Exception("Inconsistent types: since=%s, until=%s" % (type(since),type(until)))
 
        #=== write to user tag only if multiversion mode
        userTagOnly = True
        if self.__folder.versioningMode()==cool.FolderVersioning.SINGLE_VERSION:
            userTagOnly = False
            #=== no folder Tag allowed for singleversion
            if tag!="":
                self.log().warning( "Trying to store with tag \"%s\" to SINGLE_VERSION folder", tag )
                self.log().warning( "... resetting tag to \"\"!"                                     )
                tag=""
 
        #=== get IOV limits
        sinceCool = getCoolValidityKey(since, True )
        untilCool = getCoolValidityKey(until, False)
        if untilCool <= sinceCool:
            raise Exception("Until(%i) <= Since(%i)" % (untilCool,sinceCool))
 
        #=== build IOV string
        iovString = ""       
        if isinstance(since, tuple):
            iovString = "[%i,%i] - [%i,%i]" % (since[0],since[1],until[0],until[1])
        else:
            sinceInfo = time.localtime( sinceCool//UNIX2COOL )
            untilInfo = time.localtime(min(UNIXTMAX, (untilCool//UNIX2COOL)))
            untilStr = "<infinity>"
            if untilCool<cool.ValidityKeyMax:
                untilStr = time.asctime(untilInfo)
                if (untilCool//UNIX2COOL)>UNIXTMAX:
                    untilStr = " > "+untilStr
            iovString = "[%s] - [%s]" % (time.asctime(sinceInfo), untilStr)
 
        #=== build tag
        folderTag=tag
        
        #=== print info
        self.log().info( "Registering folder %s with tag \"%s\"", self.__folder.fullPath(),folderTag)
        self.log().info( "... with IOV          : %s",  iovString                          )
        #self.log().info( "... with comment field: \"%s\"", self.__chanDictDrawer[48].getComment()                  )
 
        #=== register all channels by increasing channel number
        chanList = sorted(self.__chanDictRecord.keys())
        for chanNum in chanList:
            data = self.__chanDictRecord[chanNum]
            strout = "cool channel=%4i" % chanNum
            self.log().debug("Registering %s %s", strout, data)
            channelId = cool.ChannelId(chanNum)
            self.__folder.storeObject(sinceCool, untilCool, data, channelId, folderTag, userTagOnly)
 

zeroBlob()

python.CaloCondTools.CaloBlobWriter.zeroBlob	(		self,
			systemId )

Resets blob size to zero

Definition at line 560 of file CaloCondTools.py.

    def zeroBlob(self, systemId):
        """
        Resets blob size to zero
        """
        try:
            chanNum = cool.ChannelId(systemId)
            data = self.__chanDictRecord.get(systemId)
            if not data:
                spec = self.__folder.payloadSpecification()
                data = cool.Record( spec )
                self.__chanDictRecord[chanNum] = data
            blob = data['CaloCondBlob16M']
            blob.resize(0)
        except Exception as e:
            self.log().critical( e )
            return None
 

Member Data Documentation

__chanDictCells

dict python.CaloCondTools.CaloBlobWriter.__chanDictCells = {}

private

Definition at line 445 of file CaloCondTools.py.

__chanDictRecord

dict python.CaloCondTools.CaloBlobWriter.__chanDictRecord = {}

private

Definition at line 444 of file CaloCondTools.py.

__db

python.CaloCondTools.CaloBlobWriter.__db = db

private

Definition at line 409 of file CaloCondTools.py.

__folder

python.CaloCondTools.CaloBlobWriter.__folder = self.__db.getFolder(folderPath)

private

Definition at line 423 of file CaloCondTools.py.

---

The documentation for this class was generated from the following file:

• CaloCondTools.py