DQDumpRpc.py

Go to the documentation of this file.

#!/usr/bin/env python
#useage: nuwa.py -n 200 --no-history --repack-rpc="on" -m"RPCCalib.rpccalibTools" -m"DQDump.DQDumpRpc" inputdata

# Load DybPython
from DybPython.DybPythonAlg import DybPythonAlg
from GaudiPython import SUCCESS, FAILURE
from GaudiPython import gbl
import GaudiKernel.SystemOfUnits as units
DayaBay = gbl.DayaBay
ServiceMode = gbl.ServiceMode

from DybDbi import gDbi
from DybDbi import GDataQualityRpc as DQRpc
from DybDbi import ContextRange,Site,SimFlag,TimeStamp

import os,sys
import MySQLdb
os.environ['DBCONF'] = 'tmp_ligs_offline_db'

# Make your algorithm
class DumpRpcToDbAlg(DybPythonAlg):
    "Template Python Algorithm"
    def __init__(self,name):
        DybPythonAlg.__init__(self,name)
        self.runNo = 0
        self.fileNo = 0
        return

    def getSeqNo(self, runNo, fileNo):
        """Get file seqno by runno and fileno"""
        try:
            con = MySQLdb.connect( host = "dayabaydb.lbl.gov",
                                   user = "dayabay",
                                   passwd = "3quarks",
                                   db = "offline_db" )
            cursor = con.cursor()
            cursor.execute("SELECT seqno FROM DaqRawDataFileInfo WHERE runNo = "
                            + str(runNo) + " AND " + "fileNo = " + str(fileNo))
            row = cursor.fetchone()
            if row:
                print "get seqno successful"
        except MySQLdb.Error,e:
            print "Error %d: %s" % (e.args[0], e.args[1])
            sys.exit(1)
        cursor.close()
        con.close()
        return row[0]

    def getFileTimeInfo(self, seqNo):
        """Talk to offline DB and get the time range of the run"""
        try:
            con = MySQLdb.connect( host = "dayabaydb.lbl.gov",
                                   user = "dayabay",
                                   passwd = "3quarks",
                                   db = "offline_db" )
            cursor = con.cursor()
            cursor.execute("SELECT timestart,timeend FROM DaqRawDataFileInfoVld WHERE seqno = " + str(seqNo))
            row = cursor.fetchone()
            if row:
                print "get file time info successfully"
        except MySQLdb.Error,e:
            print "Error %d: %s" % (e.args[0], e.args[1])
            sys.exit(1)

        cursor.close()
        con.close()
        return row

    def dumptodb(self):
        seqNo = self.getSeqNo(self.runNo, self.fileNo)
        fileTime = self.getFileTimeInfo(seqNo)
        import calendar
        starttime = calendar.timegm( fileTime[0].timetuple() )
        endtime = calendar.timegm( fileTime[1].timetuple() )
        
        wrt = DQRpc.Wrt()
        cr = ContextRange( Site.kAll, 
                           SimFlag.kData|SimFlag.kMC,
                           TimeStamp(starttime),
                           TimeStamp(endtime) )
        wrt.ctx(contextrange=cr, versiondate=TimeStamp(0,0))

        FILENAME='RawRPCCalib.txt'
        f = open(FILENAME,'r')
        rowCount = 0
        for line in f:
            if line[0] != '#':
                line = line.strip()
                para = line.split()
                rpcLayerId = int( para[0] )
                row = int( para[1] )
                column = int( para[2] )
                layer = int( para[3] )
                eff = float( para[4] )
                effErr = float( para[5] )
                noiseRate = float( para[6] )
                #noise rate error may be 'inf' calculated by RPCCalib,
                #this is an ugly work-around
                if para[7] == 'inf':
                    noiseRateErr = -1
                else:
                    noiseRateErr = float( para[7] )
                record = DQRpc.Create( RunNo = self.runNo,
                                       FileNo = self.fileNo,
                                       RpcSensorId = DayaBay.RpcSensor(rpcLayerId), 
                                       PanelRow = row,
                                       PanelColumn = column,
                                       Layer = layer,
                                       Efficiency = eff,
                                       EfficiencyErr = effErr,
                                       NoiseRate = noiseRate,
                                       NoiseRateErr = noiseRateErr )
                wrt.Write(record)
        wrt.Close()
        return
    
    def initialize(self):
        status = DybPythonAlg.initialize(self)
        if status.isFailure(): return status

        self.daqDetailsSvc = self.svc('IDaqDetailsSvc','DetailsFromRecordSvc')
        if self.daqDetailsSvc == None:
            self.error("Failed to get IDaqDetailsSvc")
            return FAILURE

        self.info("initializing")
        return SUCCESS

    def execute(self):
        if((self.runNo == 0) and (self.fileNo == 0) ):
            evt = self.evtSvc()
            readoutHdr = evt["/Event/Readout/ReadoutHeader"]
            if readoutHdr == None:
                self.error("Failed to get current readout header")
                return FAILURE
            svcMode = ServiceMode(readoutHdr.context(), 0)
            self.runNo = self.daqDetailsSvc.runDetails(svcMode).runNumber()
            self.fileNo = self.daqDetailsSvc.fileDetails(svcMode).fileNumber()
        return SUCCESS

    def finalize(self):
        self.info("finalizing")
        self.dumptodb()
        os.system("mv RawRPCCalib.txt RawRPCCalib_finished.txt")
        status = DybPythonAlg.finalize(self)
        return status

#####  Job Configuration for nuwa.py ########################################
def configure():
    """ Configure """
    return

def run(app):
    '''
    Configure and add the algorithm to job
    '''
    app.ExtSvc += ["DetailsFromRecordSvc"]
    # Add Python algorithm to job here
    myAlg = DumpRpcToDbAlg("MyDumpRpcAlg")
    # Add algorithm to job
    app.addAlgorithm(myAlg)
    pass