HskGuiReceiver.py

#!/usr/local/bin/python
#
#                               Copyright 2004
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "GLAST LAT Housekeeping server infrastructure"
__author__   = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST I&T"
__date__     = "07/28/04"
__version__  = "$Revision: 1.9 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from LATTE.monitoring.HskReceiver import HskCfgTextReceiver
from LATTE.client.gOptions        import Options

import logging
import gc,sys
from   linecache import *
import time
import qt
from sihippo import Observer
import sihippo

second  = 1
minute  = 60 * second
hour    = minute * 60
day     = hour * 24
era     = 10**9

timeFmt      = '%H:%M:%S'
dataFile     = None
timeDepth    = 2*hour

class QtReceiver(qt.QObject,HskCfgTextReceiver):

  class TrendUpdateEvent(qt.QCustomEvent):
    def __init__(self,trendMap):
      qt.QCustomEvent.__init__(self,qt.QEvent.MaxUser-20)
      self.trendMap = trendMap

  def __init__(self, flatFile, startTime, trendList):
    HskCfgTextReceiver.__init__(self, flatFile, startTime, trendList)
    qt.QObject.__init__(self)

  def process(self,trendMap):
    qt.QApplication.postEvent(self,QtReceiver.TrendUpdateEvent(trendMap))

  def customEvent(self,event):
    self.emit(qt.PYSIGNAL('TrendUpdate(trendMap)'),(event.trendMap,))



class TrendPlotter(qt.QWidget):
  def __init__(self,keyList,*args):
    qt.QWidget.__init__(self,*args)

    self.__ntuples       = {}
    self.__plots         = {}
    self.__views         = {}
    self.__gen           = {}
    self.__defaultDepth  = 500                 # assuming 1 hz data rate
    self.__defaultLabels = ['Time','']

    self.__dynamic       = True
    self.__keyList       = keyList

    self.grid            = qt.QGridLayout(self,3,2)
    self.grid.setAutoAdd(1)
    self.true            = True

  def isDynamic(self):
    return self.__dynamic
  def setDynamic(self,bool):
    self.__dynamic=bool

  def addPlot(self, key):
    labels  = self.__defaultLabels
    depth   = self.__defaultDepth
    name    = self.__keyList[key]

    # Create the Circular buffer to store the data
    ntc     = sihippo.NTupleController.instance()
    nt      = ntc.createCircularBuffer(labels)
    nt.reserve(depth)
    nt.setTitle(name)
    nt.setName(name)

    # Create the Plot
    dc      = sihippo.DisplayController.instance()
    plot=dc.createDisplay('XY Plot',nt,labels)
    # plot    = dc.createDisplay('Strip Chart',nt,labels)

    # kludge so that the range is initialized, and autoscales when we need.
    plot.setRange('x',0,1)
    plot.setAutoRanging('x',True)

    # Add the time axis observer
    gen     = TimeAxisGen()
    gen.setPlotter(plot, key)
    plot.addObserver(gen)

    # Add the plot to the screen
    view    = sihippo.QtViewWidget(self)
    view.setPlotter(plot)
    view.setDoubleBuffering(1)
    view.resize(200,100)
    view.setMinimumSize(qt.QSize(100,50))
    # self.grid.addWidget(view)
    view.show()

    # Maintain a reference to the created objects to prevent garbage collection
    self.__ntuples[key]  = nt
    self.__plots[key]    = plot
    self.__views[key]    = view
    self.__gen[key]      = gen

  def update(self, trendMap):
    # if not self.true: return
    self.true=False
    # trendMap has timestamp, val1, val2, val3...
    timeStamp = trendMap['TimeStamp']
    for key in trendMap:
      if key == 'TimeStamp': continue
      if key not in self.__views.keys() and self.__dynamic:
        self.addPlot(key)
      if key not in self.__views.keys():
        return
      x=timeStamp
      y=trendMap[key]
      if y is None:
        continue
      self.__ntuples[key].addRow([x,y])

class TimeAxisGen ( Observer ) :
  __labelFmt   = '%Y/%m/%d'
  __tickFmt    = '%H:%M'
  __stepSet    = [ 1*second, 5*second, 10*second, 30*second,
                   1*minute, 2*minute, 5*minute, 10*minute, 15*minute, 20*minute, 30*minute,
                   1*hour, 2*hour, 6*hour, 12*hour,
                   1*day, 3*day, 7*day, 30*day, 90*day, 180*day, 364*day,
                   era]

  def setPlotter ( self, plotter, name ) :
    self.plotter = plotter
    self.name    = name
    self.__goodStep = 0

  def update ( self, obs ) :
    # return
    lowTime = self.plotter.getLowRangeOnX()
    highTime = self.plotter.getHighRangeOnX()

    if ((highTime - lowTime)/TimeAxisGen.__stepSet[self.__goodStep]) < 1:
      # print "reset of goodStep", self.name, self.__goodStep , highTime, lowTime,  ((highTime - lowTime)/TimeAxisGen.__stepSet[self.__goodStep])
      self.__goodStep -= 1
    if ((highTime - lowTime)/TimeAxisGen.__stepSet[self.__goodStep]) > 6:
      # print self.name, highTime, lowTime,  ((highTime - lowTime)/TimeAxisGen.__stepSet[self.__goodStep])
      step = 0
      while ((highTime - lowTime)/TimeAxisGen.__stepSet[step]) > 5:
        # print "step:", step
        step += 1
      self.__goodStep = step
    step = TimeAxisGen.__stepSet[self.__goodStep]

    lowTick = lowTime - (lowTime % step) + step
    values = []
    values.append( lowTick )

    labels = []
    labels.append( time.strftime(TimeAxisGen.__tickFmt, time.localtime(lowTick)) )
    tick = lowTick
    tick += step
    while tick < highTime:
      values.append ( tick )
      labels.append ( time.strftime(TimeAxisGen.__tickFmt, time.localtime(tick)) )
      tick += step

    self.plotter.setAutoTicksOnX( False )
    self.plotter.setTicksOnX( values, labels )

    # REALLY REALLY don't do this:
    #   setLabel calls "notifyObservers", which brings us back here...
    # xlabel = time.strftime(TimeAxisGen.__labelFmt, time.localtime(highTime))
    # self.plotter.setLabel( 'x', xlabel )

def memget():
  import win32pdh
  hq = win32pdh.OpenQuery()
  # ch = win32pdh.AddCounter(hq, "\\\\gitow1\\Process(python)\\Private Bytes")
  ch = win32pdh.AddCounter(hq, "\\\\gitow1\\Process(python#1)\\Private Bytes")
  win32pdh.CollectQueryData(hq)
  type, val =win32pdh.GetFormattedCounterValue(ch,win32pdh.PDH_FMT_LONG)
  return val

def startup():
  # print memget()
  logging.basicConfig()
  logging.root.setLevel(logging.DEBUG)
  gc.set_debug(gc.DEBUG_LEAK)
  print "Garbage collection: ", gc.isenabled()#, gc.get_objects()

def startQT(dataFile, startTime, keyList):
  import sys

  app=qt.QApplication(sys.argv)
  r=QtReceiver(dataFile, startTime, keyList.keys())

  gui=TrendPlotter(keyList)
  gui.connect(r,qt.PYSIGNAL('TrendUpdate(trendMap)'),gui.update)

  app.connect(app,qt.SIGNAL("lastWindowClosed()"),
              app,qt.SLOT("quit()"))

  app.setMainWidget(gui)
  gui.show()

  r.setReceiving(1)
  app.exec_loop()
  r.shutdown()

def usage():
  return """

HskGuiReceiver Usage:

Mandatory options:
--dataFile  define the flat file that contains housekeeping data.

Optional options:
--timeDepth define the time depth of the housekeeping plots.  Default is 2 hours.
            Units are in seconds
--keyFile   define the file of variables to plot
            Note: keyFile format is "KEY  :  Plot title"

Example:
$ HskGuiReceiver --dataFile c:\TEMP\lat-elf11.dat --timeDepth 3600 --keyFile keys.dat

"""


if __name__ == '__main__':
  startup()

  # Options, first list mandatory, second list optional
  options = Options(['dataFile'], ['timeDepth', 'keyFile'])
  try:
    options.parse()
  except Exception, msg:
    options.usage()
    raise Exception, msg

  dataFile = options.dataFile
  if options.timeDepth is not None:
    timeDepth = int(options.timeDepth)
  else:
    timeDepth = 2*hour
  startTime = time.time() - timeDepth

  if options.keyFile is not None:
    keyFile = options.keyFile
    from HskReceiver import parseKeyFile
    keyList = parseKeyFile(keyFile)
  else:  # really really basic set of histos.
    keyList = {'LHKAEMDAQB33V':'AEM DAQ board 3.3 V',
               'LHKAEMFR11T'  :'AEM Free board 11 Temp',
               'LHKAEMDAQBT'  :'AEM DAQ board Temp',
               'LHKAEMFR11V1' :'AEM Free 11 HV 1',
               'LHKAEMFR11V2' :'AEM Free 11 HV 2',
               'LHKAEMFR11VD' :'AEM Free 11 VDD',
               }

  startQT(dataFile, startTime, keyList)

---