rpchv.py

Go to the documentation of this file.

"""
RPC HV scraping specialization 
"""
import os, logging
log = logging.getLogger(__name__)
from datetime import datetime, timedelta

from base import Regime, Scraper, Faker, DCS, SourceContext
from GaudiPython import gbl
SiteFromString = gbl.Site.FromString

class RpcHv(Regime):
    """
    Regime frontend class with simple prescribed interface, 
    takes the cfg argument into this dict and no args in call.
    This allows the frontend to be entirely generic.
    """
    srcs    = property( lambda self:RpcHvSource( DCS(self['source']) ))
    scraper = property( lambda self:RpcHvScraper(self.srcs, self.target, self ))
    faker   = property( lambda self:RpcHvFaker(self.srcs,self ))



class RpcHvSource(list):
    def __init__(self, srcdb):    
        """
        :param srcdb: source DB instance of :py:class:`Scraper.base.DCS` 

        List of source SA classes that map tables/joins in srcdb 
        Three sites for RPC HVs
        
        """
        dtn = SourceContext(table="DBNS_RPC_HV_Vmon",ksite="kDayaBay",ksubsite="kRPC")
        self.append(srcdb.kls(dtn) ) 
        dtn = SourceContext(table="LANS_RPC_HV_Vmon",ksite="kLingAo",ksubsite="kRPC")
        self.append(srcdb.kls(dtn) ) 
        dtn = SourceContext(table="FARS_RPC_HV_Vmon",ksite="kFar",ksubsite="kRPC")
        self.append(srcdb.kls(dtn) ) 

        
class RpcHvScraper(Scraper):

    def changed(self, sv  ):
        """
        :param sv: source vector instance :py:class:`Scraper.base.sourcevector.SourceVector` 

        Decide if sufficient change to propagate based on differences between the first and last elements of `SourceVector` instance argument
        """

        p = self._detectordict( sv[0] )
        c = self._detectordict( sv[-1] )
        site = p.pop('site')
        det = p.pop('det')['det']
        for label in sorted(p.keys()):
            pv = p[label]
            cv = c[label]
            if abs(pv['voltage']-cv['voltage']) > self.threshold:
                return True
        return False

    def propagate(self, sv ):
        """
        :param sv: source vector instance :py:class:`Scraper.base.sourcevector.SourceVector` 

        Yield write ready DybDbi target dicts to base class, note that a single source vector
        instance is yielding multiple target dicts. The keys of the target dict must match
        the specified attributes of the ``DybDbi`` target class. 

        Here the output is based entirely on the last element of the source vector. A smarter
        implementation might average the first and last to smooth variations.
        The python ``yield`` command makes it possible to iterate over a what is returned by 
        a function/method.

        ETW Aug 2012: write voltage from sv[0], NOT sv[-1]
        """

        dd = self._detectordict(sv[0])
        n = 0
        site = dd.pop('site')
        siteval = site['site'] 
        det = dd.pop('det')
        detval = det['det']
        ksite = self._getsite(siteval)
        detnum = 7
        for (label,sign),v in sorted(dd.items()):
            if (sign > 0):
                vp = dd[label,1]
                vn = dd[label,-1]
                vpos = vp['voltage']
                vneg = vn['voltage']
                d = dict(LocationId=label,VoltagePos=vpos,VoltageNeg=vneg)
                log.info("Writing out LocationId={}, VoltagePos={}, VoltageNeg={}".format(label,vpos,vneg))
                n += 1
                yield d
                log.debug("yielded %s target dicts for  %s " % ( n, sv ))


    def seed(self, sc):
        """
        Used for seeding target DB when testing into empty tables

        :param sc: source class, potentially different seeds will be needed 
                   for each source that feeds into a single target
        """

        scstr = str(sc)
        
        if scstr.find("DBNS_RPC") > 0:
            return dict(LocationId="F00",VoltagePos=0,VoltageNeg=0)
        if scstr.find("LANS_RPC") > 0:
            return dict(LocationId="F00",VoltagePos=0,VoltageNeg=0)
        if scstr.find("FARS_RPC") > 0:
            return dict(LocationId="F00",VoltagePos=0,VoltageNeg=0)

    def _detectordict(self,inst):
        """
        :param inst: SQLAlchemy source instance

        Examines source instance, extracting detector name, DCS detector id, and values into a dict.
        """

        dd={}
        inststr = str(inst)
        sitestr = inststr[1:4]
        detstr = inststr[6:9]
        dd['site'] = {'site':sitestr}
        dd['det'] = {'det':detstr}

        for k,v in inst.asdict.items():
            if k in 'id date_time'.split():
                continue
            if v is None:
                v = -999
            sign = k.find("P")
            if (sign > 0):
                kp = 1
            else:
                kp = -1
            if (k[5] == 'F'):
                kshort = k[5:6]+k[7:9]
            else:
                kshort = 'T'+k[8:10]
            kk = (kshort,kp)
            qty,kk = ('voltage',kk)
            if dd.has_key(kk):
                dd[kk].update({qty:v})
            else:
                dd[kk] = {qty:v}
        return dd

    def _getsite(self,site):
        """
        Returns ksite number given string input
        """

        if site == 'DBN':
            return SiteFromString("DayaBay")
        elif site == 'LAN':
            return SiteFromString("LingAo")
        elif site == 'FAR':
            return SiteFromString("Far")
        else:
            msg = "Do not recognize site...must be DBNS, LANS, or FARS"
            log.fatal(msg)
            raise Exception(msg)
            return -1

class RpcHvFaker(Faker):
    """
    Creates fake instances and inserts them into sourcedb   
    """
    def fake(self, inst, id , dt ):
        """
        Invoked from base class call method, 
        set attributes of source instance to form a fake 

        :param inst: source instance
        :param id: id to assign to the instance instance
        """
#         fakefn=lambda (l,c,r),qty:l*100 + c*10 + r if qty == "voltage" else 1 
#         for k,v in inst.asdict.items():
#             if k in 'id P_id'.split():
#                  setattr( inst, k, id )
#             elif k in 'date_time P_date_time'.split():
#                  setattr( inst, k, dt )
#             else:
#                 qty,kk = ('pw',k[2:]) if k.startswith('P_') else ('voltage',k)
#                 lcr = self.lcr_matcher(kk)    
#                 setattr( inst , k, fakefn( lcr, qty) )


# if __name__ == '__main__':
#     pass