mapr.py

Go to the documentation of this file.

#!/usr/bin/env python
"""
Mapr instances provide mappings between sensorData integers and 
corresponding FEEChannelId

"""
import os, logging, pickle, time
log = logging.getLogger(__name__)


class Mapr(object):

    @classmethod 
    def scan(cls, kls):
        mpr = cls()
        return mpr.validity_scan(kls)

    def __init__(self):
        """ 
        Provide ``DetectorSensor`` to ``feeChannelId`` mappings at context and task 
        corresponding to the validity record (obtainable from any DBI table eg using ``rpt.vrec`` )

        The validity record specifies both ``Context`` and task.  
        The timestamp used corresponds to the ``INSERTDATE`` of the validity record.

        """ 
        self._vrec = None 
        self.svcMode = None
        self.cableSvc = self._cableSvc()       

    def _set_vrec(self, vrec):
        """
        :param vrec: validity record 

        Setting `vrec` attribute updates the ``svcMode`` used to make cablesvc calls
        """
        self._vrec = vrec
        self.svcMode = self._insertDateSvcMode(vrec)        
    def _get_vrec(self):
        return self._vrec 
    vrec = property(_get_vrec, _set_vrec, doc=_set_vrec.__doc__)

    def _cableSvc(self):
        """
        :return: cableSvc
        """
        from Gaudi.Configuration import ApplicationMgr
        theApp = ApplicationMgr()
        theApp.ExtSvc.append('DybCableSvc/DybCableSvc')
        from GaudiPython import AppMgr
        global appMgr
        appMgr = AppMgr()
        appMgr.initialize()
        global cableSvc
        cableSvc = appMgr.service('DybCableSvc','ICableSvc')
        assert cableSvc, 'Failed to lookup DybCableSvc'
        return cableSvc

    def _insertDateSvcMode(self, vrec):
        """
        :param vrec: validity record
        :return: ``SvcMode`` instance corresponding to the insertdate of the record
        """ 
        from GaudiPython import gbl
        ServiceMode = gbl.ServiceMode
        Context = gbl.Context
        ictx = Context(vrec.contextrange.sitemask,vrec.contextrange.simmask,vrec.insertdate,vrec.subsite)
        svcMode = ServiceMode(ictx,vrec.task)
        return svcMode         

    def _sensorId(self, sensorData ):
        """
        :param sensorData: fullPackedData integer of a ``DetectorSensor`` 
        :return: instance of appropriate ``DetectorSensor`` subclass 

        See :dybgaudi:`DataModel/Conventions/Conventions/Detectors.h`
        """
        from GaudiPython import gbl
        DetectorSensor = gbl.DayaBay.DetectorSensor
        AdPmtSensor = gbl.DayaBay.AdPmtSensor
        PoolPmtSensor = gbl.DayaBay.PoolPmtSensor
        RpcSensor = gbl.DayaBay.RpcSensor

        if type(sensorData) != int:
            sensorData = sensorData.fullPackedData()

        sensor = None
        ds = DetectorSensor(sensorData)
        if ds.isAD():
            sensor=AdPmtSensor(sensorData)
        elif ds.isWaterShield():
            sensor=PoolPmtSensor(sensorData)
        elif ds.isRPC():
            sensor=RpcSensor(sensorData)
        else:
            raise Exception("_sensorId: sensorData %s is unrecognized" % sensorData)
        return sensor 


    def feeChannelId(self, sensorData ):
        """
        :param sensorData: integer fullPackedData of a DetectorSensor (typically these are the raw numbers persisted in SENSORID columns of DB)

        Hmm there us potential to get stale answers depending on cableSvc cache interaction with rollback ?
        """ 
        if not self.svcMode:
            raise Exception("must establish svcMode (context,task) by assigning .vrec before calling ")
        sensorId = self._sensorId(sensorData)
        channelId = self.cableSvc.feeChannelId(sensorId,self.svcMode);
        return channelId


    def __call__(self, sensorData ):
        return self.feeChannelId( sensorData )


    def toDict(self, rpt, mapkey=True, smry=False ):
        """
        :param rpt: DybDbi `Rpt` instance
        :param mapkey: when `True` the keying id is mapped
        :param smry: when `True` provide just the fullPackedData as the value, rather than the row instance
        :return: dict containing DbiTableRow instances keyed my mapped or direct `.sensorid`

        Assumptions:

        #. rows obtained from the `rpt` have `sensorid` attribute which can mapped to the id used for keying 

        """
        d = {}
        for r in rpt:
            sid = r.sensorid
            if mapkey:
                cid = self(sid)
                k = cid.fullPackedData()
                assert k not in d, "key already present %s " % k
                v = sid.fullPackedData()   
            else:
                k = sid.fullPackedData() 
                v = None                # smry without mapkey not yet implemented
            d[k] = v if smry else r  
        return d

    def validity_scan( self, kls , skips=() ):
        """
        :param kls: `DybDbi` class
        :param skips: list of SEQNO to skip

        :return: (`SEQNO` keyed dict containing mappings, running time in seconds)

        Check cableMap-ings at all validities of the kls, using Rollback to 
        apply the approriate vintage of CableMap

        """
        from DybDbi import Rollback
        t0 = time.time()
        sqlcontext, task, subsite = "1=1", -1, -1     ## all validities
        vrb = kls.GetTableProxy().MakeValidityRecBuilder( sqlcontext, subsite, task )
        seqno_ = lambda _:int(_.seqno)
        seq = map(seqno_,vrb)
        seqnos = filter(lambda _:_ not in skips, seq )
        log.info("skipping %s " % repr(skips) )
        amap = {}
        for seqno in sorted(seqnos): 
            vrec = vrb.GetValidityRecFromSeqNo(seqno)  
            rpt = kls.Rpt().Clone()
            rpt.ctx(validityrec=vrec )
            log.info("seqno %s" % seqno)
            self.vrec = vrec   # adjusts svcMode to use the appropriate CableMap and Rollback ensures the correct vintage
            with Rollback(self.vrec.insertdate):
                amap[seqno] = self.toDict( rpt, mapkey=True, smry=True ) 
            pass
        t1 = time.time()
        log.warn("from total of %s seqno skipped %s namely %s " % ( len(seq), len(skips), repr(skips)))
        return amap, t1 - t0


class MaprMonitor(dict):
    def __init__(self, path ):
        self.path = path 

    def load(self):
        if os.path.exists(self.path):
            log.info("reading prior persisted maps from %s " % self.path )
            with open(self.path,"r") as fp:
                prior = pickle.load(fp)
            return prior    
        return None

    def save(self, maph ):
        with open(self.path,"w") as fp:
            log.info("writing map to %s " % self.path )
            pickle.dump( maph , fp ) 

    def compare(self, amap, bmap ):
        ak = set(amap.keys())
        bk = set(bmap.keys())
        ik = ak.intersection(bk)
        log.info("comparing current and prior maps for the %s common keys" % len(ik) )
        for i,k in enumerate(ik):
            a = amap[k]
            b = bmap[k]
            #log.info("i %s k %s a\n%s\nb\n%s\n" % ( i, k, a, b ))
            if a!=b:
                log.warn("change in map for seqno %s \n%s\n%s\n" % (k,a,b) )
                self[k] = dict(a=a,b=b)

    def __repr__(self):
        return "%s : %s differnces for seqnos %s " % ( self.__class__.__name__ , len(self), self.keys() )

    def __call__(self, amap ):
        """
        only writes if no prior existing map, thus to bless a change delete and rerun
        """
        bmap = self.load()        
        if bmap:
           self.compare(amap,bmap)
        else:
           self.save(amap)



def check(kls):

    sqlcontext, task, subsite = "1=1", -1, -1   ## wideopen DBI querying 
    vrb = kls.GetTableProxy().MakeValidityRecBuilder( sqlcontext, subsite, task )
    mpr = Mapr()      

    gDbi.level = "WARNING" 

    for vrec in sorted(vrb, key=lambda _:_.seqno): 
        mpr.vrec = vrec      ## update SvcMode of the mapper

        rpt = kls.Rpt().Clone()
        rpt.ctx( validityrec=vrec )     
        n = len(rpt)
        log.info("seqno %s count %s digest %s" % ( vrec.seqno, n, rpt.digest  ))

        with Rollback(vrec.insertdate):
            for i,row in enumerate(rpt):
                sid = row.sensorid
                cid = mpr(sid)
                log.debug(" %-4s sensorid %-25s channelid %-25s " % ( i+1, sid.asString(), cid.asString() )) 
                pass
        pass
 


class Vrec(object):
    def __init__(self, kls):
        sqlcontext, task, subsite = "1=1", -1, -1   ## wideopen DBI querying 
        vrb = kls.GetTableProxy().MakeValidityRecBuilder( sqlcontext, subsite, task )
        mpr = Mapr()
        #
        self.mpr = mpr 
        self.kls = kls
        self.vrb = vrb 
        self._seqno = None

    def _get_map(self):
        vrec = self.vrec 
        rpt = self.kls.Rpt().Clone()
        rpt.ctx( validityrec=vrec )     
        n = len(rpt)
        self.mpr.vrec = vrec
        return self.mpr.toDict( rpt, mapkey=True, smry=True ) 
    map = property( _get_map )
         
    def _set_seqno(self, seqno):
        self._seqno = seqno
    def _get_seqno(self):
        return self._seqno
    seqno = property( _get_seqno, _set_seqno ) 

    def _get_vrec(self):
        return self.vrb.GetValidityRecFromSeqNo(self._seqno)  
    def _set_vrec(self, vrec):
        raise Exception("set vrec by setting the seqno")
    vrec  = property( _get_vrec,  _set_vrec ) 
 

if __name__ == '__main__':

    import os
    os.environ.setdefault("DBCONF","tmp_offline_db")
    logging.basicConfig(level=logging.INFO )

    from DybDbi import gDbi, GCalibPmtHighGain as kls, Rollback
    
    vr = Vrec(kls)
    vr.seqno = 1204
    mp = vr.map