python.TileCalibTools.TileBlobWriter Class Reference

Inheritance diagram for python.TileCalibTools.TileBlobWriter:

Collaboration diagram for python.TileCalibTools.TileBlobWriter:

Public Member Functions
def	__init__ (self, db, folderPath, calibDrawerType, isMultiVersionFolder=True, isRunLumiTimeStamp=True)
def	register (self, since=(MINRUN, MINLBK), until=(MAXRUN, MAXLBK), tag="", option=0)
def	setComment (self, author, comment=None)
def	getComment (self, split=False)
def	getDrawer (self, ros, drawer, calibDrawerTemplate=None)
def	zeroBlob (self, ros, drawer)

Private Attributes
	__db
	__folder
	__chanDictRecord
	__chanDictDrawer
	__calibDrawerType
	__defVec

Detailed Description

TileCalibBlobWriterBase is a helper class, managing the details of
COOL interactions for the user of TileCalibBlobs.

Definition at line 481 of file TileCalibTools.py.

Constructor & Destructor Documentation

__init__()

def python.TileCalibTools.TileBlobWriter.__init__	(		self,
			db,
			folderPath,
			calibDrawerType,
			isMultiVersionFolder = True,
			isRunLumiTimeStamp = True
	)

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

Definition at line 488 of file TileCalibTools.py.

    def __init__(self, db, folderPath, calibDrawerType,
                 isMultiVersionFolder=True, isRunLumiTimeStamp=True):
        """
        Input:
        - db        : db should be an open database connection
        - folderPath: full folder path to create or update
        """
 
        #=== initialize base class
        TileCalibLogger.__init__(self,"TileBlobWriter")
 
        #=== 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("run-lumi")
        if not isRunLumiTimeStamp:
            folderDescr = getAthenaFolderDescr("time")
 
        #=== 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( 'TileCalibBlob', cool.StorageType.Blob64k )
                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.__chanDictDrawer = {} # <int, TileCalibDrawer>
 
        #=== create default vectors based on calibDrawerType
        self.__calibDrawerType = calibDrawerType
        if   calibDrawerType=='Flt':
            self.__defVec = cppyy.gbl.std.vector('std::vector<float>')()
        elif calibDrawerType=='Bch' or calibDrawerType=='Int':
            self.__defVec = cppyy.gbl.std.vector('std::vector<unsigned int>')()
        else:
            raise Exception("Unknown calibDrawerType: %s" % calibDrawerType)
 
 

Member Function Documentation

getComment()

def python.TileCalibTools.TileBlobWriter.getComment	(		self,
			split = False
	)

Returns the general comment (default if none is set)

Definition at line 659 of file TileCalibTools.py.

    def getComment(self, split=False):
        """
        Returns the general comment (default if none is set)
        """
        try:
            chanNum = TileCalibUtils.getCommentChannel()
            data = self.__chanDictRecord.get(chanNum)
            if not data:
                return "<No general comment!>"
            blob = data['TileCalibBlob']
            cmt = TileCalibDrawerCmt.getInstance(blob)
            if split:
                return (cmt.getAuthor(),cmt.getComment(),cmt.getDate())
            else:
                return cmt.getFullComment()
        except Exception as e:
            self.log().critical( e )
 

getDrawer()

def python.TileCalibTools.TileBlobWriter.getDrawer	(		self,
			ros,
			drawer,
			calibDrawerTemplate = None
	)

Returns a TileCalibDrawer object of requested type
for the given ROS and drawer.

Definition at line 678 of file TileCalibTools.py.

    def getDrawer(self, ros, drawer, calibDrawerTemplate=None):
        """
        Returns a TileCalibDrawer object of requested type
        for the given ROS and drawer.
        """
        try:
 
            #=== check for already initialized calibDrawers
            chanNum = TileCalibUtils.getDrawerIdx(ros,drawer)
            calibDrawer = self.__chanDictDrawer.get(chanNum,None)
 
            #=== initialize new calibDrawer if needed
            if not calibDrawer:
 
                #=== create new blob
                spec = self.__folder.payloadSpecification()
                data = cool.Record( spec )
                self.__chanDictRecord[chanNum] = data
                blob = data['TileCalibBlob']
 
                #=== Create calibDrawer based on requested calibDrawerType
                if   self.__calibDrawerType=='Flt':
                    calibDrawer = TileCalibDrawerFlt.getInstance(blob,self.__defVec,0,0)
                elif self.__calibDrawerType=='Int':
                    calibDrawer = TileCalibDrawerInt.getInstance(blob,self.__defVec,0,0)
                elif self.__calibDrawerType=='Bch':
                    calibDrawer = TileCalibDrawerBch.getInstance(blob,self.__defVec,0,0)
                else:
                    raise Exception( "Invalid blob type requested: %s" % type )
 
            #=== clone if requested
            if calibDrawerTemplate:
                calibDrawer.clone(calibDrawerTemplate)
 
            #=== put updated calibDrawer in dictionary and return
            self.__chanDictDrawer[chanNum] = calibDrawer
            return calibDrawer
 
        except Exception as e:
            self.log().critical( e )
            return None
 

register()

def python.TileCalibTools.TileBlobWriter.register	(		self,
			since = (MINRUN,MINLBK),
			until = (MAXRUN,MAXLBK),
			tag = "",
			option = 0
	)

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 551 of file TileCalibTools.py.

    def register(self, since=(MINRUN,MINLBK), until=(MAXRUN,MAXLBK), tag="", option=0):
        """
        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
        comment=self.getComment()
        onlyComment = (option<0)
        noComment = (comment is None) or (comment == "None") or (comment.startswith("None") and comment.endswith("None")) or (option>0)
        self.log().info( "Registering folder %s with tag \"%s\"", self.__folder.fullPath(),folderTag)
        self.log().info( "... with IOV          : %s" , iovString                          )
        if noComment:
            if (option<=0):
                self.log().info( "... WITHOUT comment field" )
        else:
            self.log().info( "... with comment field: \"%s\"", self.getComment()                  )
 
        #=== register all channels by increasing channel number
        if onlyComment:
            chanList = [1000]
        else:
            chanList = sorted(self.__chanDictRecord.keys())
        cnt=0
        for chanNum in chanList:
            if chanNum==1000 and noComment:
                continue
            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)
            cnt+=1
        if noComment:
            self.log().info( "... %d cool channels have been written in total", cnt )
        elif onlyComment:
            self.log().info( "... 1 cool channel with comment field has been written" )
        else:
            self.log().info( "... %d cool channels have been written in total (including comment field)", cnt )
 

setComment()

def python.TileCalibTools.TileBlobWriter.setComment	(		self,
			author,
			comment = None
	)

Sets a general comment in the comment channel.

Definition at line 638 of file TileCalibTools.py.

    def setComment(self, author, comment=None):
        """
        Sets a general comment in the comment channel.
        """
        try:
            chanNum = TileCalibUtils.getCommentChannel()
            data = self.__chanDictRecord.get(chanNum)
            if not data:
                spec = self.__folder.payloadSpecification()
                data = cool.Record( spec )
                self.__chanDictRecord[chanNum] = data
            blob = data['TileCalibBlob']
            if isinstance(author,tuple) and len(author)==3:
                tm=time.mktime(datetime.datetime.strptime(author[2], "%a %b %d %H:%M:%S %Y").timetuple())
                TileCalibDrawerCmt.getInstance(blob,author[0],author[1],int(tm))
            else:
                TileCalibDrawerCmt.getInstance(blob,author,comment)
        except Exception as e:
            self.log().critical( e )
 

zeroBlob()

def python.TileCalibTools.TileBlobWriter.zeroBlob	(		self,
			ros,
			drawer
	)

Resets blob size to zero

Definition at line 721 of file TileCalibTools.py.

    def zeroBlob(self, ros, drawer):
        """
        Resets blob size to zero
        """
        try:
            chanNum = TileCalibUtils.getDrawerIdx(ros,drawer)
            data = self.__chanDictRecord.get(chanNum)
            if not data:
                spec = self.__folder.payloadSpecification()
                data = cool.Record( spec )
                self.__chanDictRecord[chanNum] = data
            blob = data['TileCalibBlob']
            blob.resize(0)
        except Exception as e:
            self.log().critical( e )
            return None
 
 
 
#======================================================================
#===
#=== TileBlobReader
#===
#======================================================================
 
#
#______________________________________________________________________

Member Data Documentation

__calibDrawerType

python.TileCalibTools.TileBlobWriter.__calibDrawerType

private

Definition at line 540 of file TileCalibTools.py.

__chanDictDrawer

python.TileCalibTools.TileBlobWriter.__chanDictDrawer

private

Definition at line 537 of file TileCalibTools.py.

__chanDictRecord

python.TileCalibTools.TileBlobWriter.__chanDictRecord

private

Definition at line 536 of file TileCalibTools.py.

__db

python.TileCalibTools.TileBlobWriter.__db

private

Definition at line 499 of file TileCalibTools.py.

__defVec

python.TileCalibTools.TileBlobWriter.__defVec

private

Definition at line 542 of file TileCalibTools.py.

__folder

python.TileCalibTools.TileBlobWriter.__folder

private

Definition at line 515 of file TileCalibTools.py.

---

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

• TileCalibTools.py