python.TileCalibTools.TileBlobReader Class Reference

Inheritance diagram for python.TileCalibTools.TileBlobReader:

Collaboration diagram for python.TileCalibTools.TileBlobReader:

Public Member Functions
def	__init__ (self, db, folder, tag="")
def	getComment (self, pointInTime, split=False)
def	getDefault (self, ros, drawer)
def	getDrawer (self, ros, drawer, pointInTime, printError=True, useDefault=True)
def	getDefaultDrawer (self, ros, drawer, pointInTime, printError=True)
def	getDBobjsWithinRange (self, ros, drawer, point1inTime=(0, 0), point2inTime=(2147483647, 4294967295), printError=True)
def	getIOVsWithinRange (self, ros, drawer, point1inTime=(0, 0), point2inTime=(2147483647, 4294967295), printError=True)
def	getBlobsWithinRange (self, ros, drawer, point1inTime=(0, 0), point2inTime=(2147483647, 4294967295))
def	folderIsMultiVersion (self)

Private Attributes
	__db
	__folder
	__folderType
	__tag
	__objDict

Detailed Description

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

Definition at line 748 of file TileCalibTools.py.

Constructor & Destructor Documentation

__init__()

def python.TileCalibTools.TileBlobReader.__init__	(		self,
			db,
			folder,
			tag = ""
	)

Input:
- db    : db should be an open database connection
- folder: full folder path
- tag   : The folder tag, e.g. \"000-00\"

Definition at line 755 of file TileCalibTools.py.

    def __init__(self, db, folder, tag=""):
        """
        Input:
        - db    : db should be an open database connection
        - folder: full folder path
        - tag   : The folder tag, e.g. \"000-00\"
        """
        #=== initialize base class
        TileCalibLogger.__init__(self,"TileBlobReader")
 
        #=== try to open db
        try:
            self.__db  = db                             # CoraCoolDatabase
            self.__folder = self.__db.getFolder(folder) # CoraCoolFolder
        except Exception as e:
            self.log().critical( e )
            raise
 
        #=== determine if "run-lumi" or "time" folder
        validFolderTypes = ("run-lumi","time")
        folderDescr = self.__folder.description()
        self.__folderType = getAthenaFolderType(folderDescr)
        if self.__folderType not in validFolderTypes:
            raise Exception("Invalid folder type found: \'%s\'" % self.__folderType)
 
        #=== use camelized full folder path only if tag is given
        self.__tag = tag
 
        #=== initialize dictionary to keep reference to DB object of given ros/drawer
        #=== and timestamp, so they do not go out of scope
        self.__objDict = {}
 

Member Function Documentation

folderIsMultiVersion()

def python.TileCalibTools.TileBlobReader.folderIsMultiVersion

(

self

)

Returns true if MultiVersion folder is connected

Definition at line 1078 of file TileCalibTools.py.

    def folderIsMultiVersion(self):
        """
        Returns true if MultiVersion folder is connected
        """
        if self.__folder.versioningMode()==cool.FolderVersioning.MULTI_VERSION:
            return True
        else:
            return False
 
 
#======================================================================
#===
#=== TileASCIIParser
#===
#======================================================================
 
#
#______________________________________________________________________

getBlobsWithinRange()

def python.TileCalibTools.TileBlobReader.getBlobsWithinRange	(		self,
			ros,
			drawer,
			point1inTime = (0,0),
			point2inTime = (2147483647,4294967295)
	)

Returns all blob objects for the given ROS and drawer, within given validity range -- default: [0-Infty)
Note: the blobs don't contain validity range info.  Check method getDBobjsWithinRange()

Definition at line 1012 of file TileCalibTools.py.

    def getBlobsWithinRange(self, ros, drawer, point1inTime=(0,0), point2inTime=(2147483647,4294967295)):
        """
        Returns all blob objects for the given ROS and drawer, within given validity range -- default: [0-Infty)
        Note: the blobs don't contain validity range info.  Check method getDBobjsWithinRange()
        """
 
        validityKey1 = getCoolValidityKey(point1inTime,True)
        validityKey2 = getCoolValidityKey(point2inTime,False)
 
        print ("Validity keys range is %s - %s" % (validityKey1, validityKey2))
        self.log().debug("Validity key range is %s - %s", validityKey1,validityKey2)
 
        objs = self.getDBobjsWithinRange(self, ros, drawer, point1inTime, point2inTime)
 
        #-- Loop over objs to extract blobs
        blobs = []
        calibDrawer = None
        while objs.goToNext():
            obj=objs.currentRef()
            sinceCool=obj.since()
            if sinceCool < validityKey1:
                sinceCool = validityKey1
            untilCool=obj.until()
            blob = obj.payload()[0]
            print ("[%d,%d)-[%d,%d) - %s" % ((sinceCool>>32),(sinceCool&0xFFFFFFFF),(untilCool>>32),(untilCool&0xFFFFFFFF),blob))
            self.log().debug("blob size: %d", blob.size())
 
            #=== default policy
            while blob.size()==0:
                #=== no default at all?
                if ros==0 and drawer==0:
                    raise Exception('No default available')
                #=== follow default policy
                ros,drawer = self.getDefault(ros,drawer)
                chanNum = TileCalibUtils.getDrawerIdx(ros,drawer)
                obj = self.__folder.findObject(sinceCool, chanNum, self.__tag)
                blob = obj.payload()[0]
                self.log().debug("blob size: 0 --> default: %d", blob.size())
 
            #=== store object in dictionary
            self.__objDict[sinceCool] = obj
 
            #=== create calibDrawer depending on type
            calibDrawer = TileCalibDrawerCmt.getInstance(blob)
            typeName =    TileCalibType.getClassName(calibDrawer.getObjType())
            del calibDrawer
            if   typeName=='TileCalibDrawerFlt':
                calibDrawer = TileCalibDrawerFlt.getInstance(blob)
                self.log().debug( "typeName = Flt " )
            elif typeName=='TileCalibDrawerInt':
                calibDrawer = TileCalibDrawerInt.getInstance(blob)
                self.log().debug( "typeName = Int " )
            elif typeName=='TileCalibDrawerBch':
                calibDrawer = TileCalibDrawerBch.getInstance(blob)
                self.log().debug( "typeName = Bch " )
            elif typeName=='TileCalibDrawerOfc':
                calibDrawer = TileCalibDrawerOfc.getInstance(blob)
                self.log().debug( "typeName = Ofc " )
            else:
                raise Exception( "Invalid blob type requested: %s" % typeName )
 
            blobs.append( calibDrawer )
 
        return blobs
 

getComment()

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

Returns the general comment (default if none is set)

Definition at line 788 of file TileCalibTools.py.

    def getComment(self, pointInTime, split=False):
        """
        Returns the general comment (default if none is set)
        """
        validityKey = getCoolValidityKey(pointInTime)
        try:
            chanNum = TileCalibUtils.getCommentChannel()
            obj = self.__folder.findObject(validityKey, chanNum, self.__tag)
            self.log().debug("getComment:Fetching from DB: %s", obj)
            blob = obj.payload()[0]
            cmt = TileCalibDrawerCmt.getInstance(blob)
            if split:
                return (cmt.getAuthor(),cmt.getComment(),cmt.getDate())
            else:
                return cmt.getFullComment()
        except Exception:
            return "<no comment found>"
 

getDBobjsWithinRange()

def python.TileCalibTools.TileBlobReader.getDBobjsWithinRange	(		self,
			ros,
			drawer,
			point1inTime = (0,0),
			point2inTime = (2147483647,4294967295),
			printError = True
	)

Returns all DB objects for the given ROS and drawer, within given validity range -- default: [0-Infty)
Check getBlobsWithinRange for an example on how to loop over objects and check validity ranges.

Definition at line 968 of file TileCalibTools.py.

    def getDBobjsWithinRange(self, ros, drawer, point1inTime=(0,0), point2inTime=(2147483647,4294967295), printError=True):
        """
        Returns all DB objects for the given ROS and drawer, within given validity range -- default: [0-Infty)
        Check getBlobsWithinRange for an example on how to loop over objects and check validity ranges.
        """
 
        validityKey1 = getCoolValidityKey(point1inTime,True)
        validityKey2 = getCoolValidityKey(point2inTime,False)
 
        #print "Validity keys range is %s - %s" % (validityKey1, validityKey2)
        self.log().debug("Validity key range is %s - %s", validityKey1,validityKey2)
 
        objs = None
        try:
            dbChanNum = drawer if ros<0 else TileCalibUtils.getDrawerIdx(ros,drawer)
            dbChanSel = cool.ChannelSelection(dbChanNum)
            #self.log().debug("Fetching blobs from DB: %s" % obj)
            objs = self.__folder.browseObjects(validityKey1,validityKey2,dbChanSel,self.__tag)
        except Exception as e:
            if printError:
                self.log().error("TileCalibTools.getDBobjsWithinRange(): Fetching of ros=%i, drawer=%i failed with exception %s", ros,drawer,e)
 
        return objs
 

getDefault()

def python.TileCalibTools.TileBlobReader.getDefault	(		self,
			ros,
			drawer
	)

Returns a default drawer number (among first 20 COOL channels) for any drawer in any partition

Definition at line 807 of file TileCalibTools.py.

    def getDefault(self, ros, drawer):
        """
        Returns a default drawer number (among first 20 COOL channels) for any drawer in any partition
        """
        if ros==0:
            if drawer<=4 or drawer==12 or drawer>=20:
                drawer1=0
            elif drawer<12:
                drawer1=4
            else:
                drawer1=12
        elif ros==1 or ros==2:
            drawer1=4
        elif ros==3:
            OffsetEBA = [ 0, 0, 0, 0, 0, 0, 3, 2, #// Merged E+1: EBA07; Outer MBTS: EBA08
                          0, 0, 0, 0, 7, 6, 5, 7, #// D+4: EBA13, EBA16; Special D+4: EBA14; Special D+40: EBA15
                          7, 6, 6, 7, 0, 0, 0, 2, #// D+4: EBA17, EBA20; Special D+4: EBA18, EBA19; Outer MBTS: EBA24
                          3, 0, 0, 0, 0, 0, 0, 0, #// Merged E+1:  EBA25
                          0, 0, 0, 0, 0, 0, 1, 1, #// Inner MBTS + special C+10: EBA39, EBA40
                          1, 1, 2, 3, 0, 0, 0, 0, #// Inner MBTS + special C+10: EBA41, EBA42; Outer MBTS: EBA43; Merged E+1: EBA44
                          0, 0, 0, 0, 3, 2, 1, 1, #// Merged E+1: EBA53; Outer MBTS: EBA54; Inner MBTS + special C+10: EBA55, EBA56
                          1, 1, 0, 0, 0, 0, 0, 0] #// Inner MBTS + special C+10: EBA57, EBA58
            drawer1 = 12 + OffsetEBA[drawer]
        elif ros==4:
            OffsetEBC = [ 0, 0, 0, 0, 0, 0, 3, 2, #// Merged E-1: EBC07; Outer MBTS: EBC08
                          0, 0, 0, 0, 7, 6, 6, 7, # // D-4: EBC13, EBC16; Special D-4: EBC14, EBC15;
                          7, 5, 6, 7, 0, 0, 0, 2, #// D-4: EBC17, EBC20; Special D-40 EBC18; Special D-4: EBC19; Outer MBTS: EBC24
                          3, 0, 0, 3, 4, 0, 3, 4, #// Merged E-1:  EBC25, EBC28, EBC31; E-4': EBC29, EBC32
                          0, 4, 3, 0, 4, 3, 1, 1, #// E-4': EBC34, EBC37; Merged E-1: EBC35, EBC38; Inner MBTS + special C-10: EBC39, EBC40
                          1, 1, 2, 3, 0, 0, 0, 0, #// Inner MBTS + special C-10: EBC41, EBC42; Outer MBTS: EBC43; Merged E-1: EBC44
                          0, 0, 0, 0, 3, 2, 1, 1, #// Merged E-1: EBC53; Outer MBTS: EBC54; Inner MBTS + special C-10: EBC55, EBC56
                          1, 1, 0, 0, 0, 0, 0, 0] #// Inner MBTS + special C-10: EBC57, EBC58
            drawer1 = 12 + OffsetEBC[drawer]
        else:
            drawer1=0
 
        return (0,drawer1)
 

getDefaultDrawer()

def python.TileCalibTools.TileBlobReader.getDefaultDrawer	(		self,
			ros,
			drawer,
			pointInTime,
			printError = True
	)

Returns a TileCalibDrawer object for the given ROS and drawer.

Definition at line 908 of file TileCalibTools.py.

    def getDefaultDrawer(self, ros, drawer, pointInTime, printError=True):
        """
        Returns a TileCalibDrawer object for the given ROS and drawer.
        """
 
        validityKey = getCoolValidityKey(pointInTime)
        self.log().debug("Validity key is %s", validityKey)
        try:
            calibDrawer = None
            #=== Have we retrieved data previously?
            key = (ros,drawer,validityKey)
            obj = self.__objDict.get(key)
            #=== ... if not, get it from DB
            if not obj:
                chanNum = TileCalibUtils.getDrawerIdx(ros,drawer)
                obj = self.__folder.findObject(validityKey, chanNum, self.__tag)
                self.log().debug("Fetching from DB: %s", obj)
                blob = obj.payload()[0]
                self.log().debug("blob size: %d", blob.size())
                #=== default policy
                while blob.size()==0:
                    #=== no default at all?
                    if ros==0 and drawer==0:
                        raise Exception('No default available')
                    #=== follow default policy
                    ros,drawer = self.getDefault(ros,drawer)
                    chanNum = TileCalibUtils.getDrawerIdx(ros,drawer)
                    obj = self.__folder.findObject(validityKey, chanNum, self.__tag)
                    blob = obj.payload()[0]
                #=== store object in dictionary
                self.__objDict[key] = obj
            #=== get blob
            blob = obj.payload()[0]
            self.log().debug("blob size: %d", blob.size())
 
            #=== create calibDrawer depending on type
            calibDrawer = TileCalibDrawerCmt.getInstance(blob)
            typeName =    TileCalibType.getClassName(calibDrawer.getObjType())
            del calibDrawer
            if   typeName=='TileCalibDrawerFlt':
                calibDrawer = TileCalibDrawerFlt.getInstance(blob)
                self.log().debug( "typeName = Flt " )
            elif typeName=='TileCalibDrawerInt':
                calibDrawer = TileCalibDrawerInt.getInstance(blob)
                self.log().debug( "typeName = Int " )
            elif typeName=='TileCalibDrawerBch':
                calibDrawer = TileCalibDrawerBch.getInstance(blob)
                self.log().debug( "typeName = Bch " )
            elif typeName=='TileCalibDrawerOfc':
                calibDrawer = TileCalibDrawerOfc.getInstance(blob)
                self.log().debug( "typeName = Ofc " )
            else:
                raise Exception( "Invalid blob type requested: %s" % typeName )
            return calibDrawer
        except Exception as e:
            if printError:
                self.log().error("TileCalibTools.getDefaultDrawer(): Fetching of ros=%i, drawer=%i failed with exception %s", ros,drawer,e)
            return None
 

getDrawer()

def python.TileCalibTools.TileBlobReader.getDrawer	(		self,
			ros,
			drawer,
			pointInTime,
			printError = True,
			useDefault = True
	)

Returns a TileCalibDrawer object for the given ROS and drawer.

Definition at line 846 of file TileCalibTools.py.

    def getDrawer(self, ros, drawer, pointInTime, printError=True, useDefault=True):
        """
        Returns a TileCalibDrawer object for the given ROS and drawer.
        """
 
        validityKey = getCoolValidityKey(pointInTime)
        self.log().debug("Validity key is %s", validityKey)
        try:
            calibDrawer = None
            #=== Have we retrieved data previously?
            key = (ros,drawer,validityKey)
            obj = self.__objDict.get(key)
            #=== ... if not, get it from DB
            if not obj:
                chanNum = TileCalibUtils.getDrawerIdx(ros,drawer)
                obj = self.__folder.findObject(validityKey, chanNum, self.__tag)
                self.log().debug("Fetching from DB: %s", obj)
                blob = obj.payload()[0]
                self.log().debug("blob size: %d", blob.size())
                #=== default policy
                if not useDefault and blob.size()==0:
                    return 0
                while blob.size()==0:
                    #=== no default at all?
                    if ros==0 and drawer==0:
                        raise Exception('No default available')
                    #=== follow default policy
                    ros,drawer = self.getDefault(ros,drawer)
                    chanNum = TileCalibUtils.getDrawerIdx(ros,drawer)
                    obj = self.__folder.findObject(validityKey, chanNum, self.__tag)
                    blob = obj.payload()[0]
                #=== store object in dictionary
                self.__objDict[key] = obj
            #=== get blob
            blob = obj.payload()[0]
            self.log().debug("blob size: %d", blob.size())
 
            #=== create calibDrawer depending on type
            calibDrawer = TileCalibDrawerCmt.getInstance(blob)
            typeName =    TileCalibType.getClassName(calibDrawer.getObjType())
            del calibDrawer
            if   typeName=='TileCalibDrawerFlt':
                calibDrawer = TileCalibDrawerFlt.getInstance(blob)
                self.log().debug( "typeName = Flt " )
            elif typeName=='TileCalibDrawerInt':
                calibDrawer = TileCalibDrawerInt.getInstance(blob)
                self.log().debug( "typeName = Int " )
            elif typeName=='TileCalibDrawerBch':
                calibDrawer = TileCalibDrawerBch.getInstance(blob)
                self.log().debug( "typeName = Bch " )
            elif typeName=='TileCalibDrawerOfc':
                calibDrawer = TileCalibDrawerOfc.getInstance(blob)
                self.log().debug( "typeName = Ofc " )
            else:
                raise Exception( "Invalid blob type requested: %s" % typeName )
            return calibDrawer
        except Exception as e:
            if printError:
                self.log().error("TileCalibTools.getDrawer(): Fetching of ros=%i, drawer=%i failed with exception %s", ros,drawer,e)
            return None
 

getIOVsWithinRange()

def python.TileCalibTools.TileBlobReader.getIOVsWithinRange	(		self,
			ros,
			drawer,
			point1inTime = (0,0),
			point2inTime = (2147483647,4294967295),
			printError = True
	)

Returns list of IOVS for the given ROS and drawer, within given validity range -- default: [0-Infty)

Definition at line 993 of file TileCalibTools.py.

    def getIOVsWithinRange(self, ros, drawer, point1inTime=(0,0), point2inTime=(2147483647,4294967295), printError=True):
        """
        Returns list of IOVS for the given ROS and drawer, within given validity range -- default: [0-Infty)
        """
        iovs=[]
        dbobjs = self.getDBobjsWithinRange(ros,drawer,point1inTime, point2inTime, printError)
        if (dbobjs is None):
            log.warning( "Warning: can not read IOVs for ros %d drawer %d from input DB file", ros,drawer )
        else:
            while dbobjs.goToNext():
                obj = dbobjs.currentRef()
                objsince = obj.since()
                sinceRun = objsince >> 32
                sinceLum = objsince & 0xFFFFFFFF
                since    = (sinceRun, sinceLum)
                iovs.append(since)
        return iovs
 

Member Data Documentation

__db

python.TileCalibTools.TileBlobReader.__db

private

Definition at line 767 of file TileCalibTools.py.

__folder

python.TileCalibTools.TileBlobReader.__folder

private

Definition at line 768 of file TileCalibTools.py.

__folderType

python.TileCalibTools.TileBlobReader.__folderType

private

Definition at line 776 of file TileCalibTools.py.

__objDict

python.TileCalibTools.TileBlobReader.__objDict

private

Definition at line 785 of file TileCalibTools.py.

__tag

python.TileCalibTools.TileBlobReader.__tag

private

Definition at line 781 of file TileCalibTools.py.

---

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

• TileCalibTools.py