consumerPlotter.py

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

__facility__ = "Online"
__abstract__ = "Glast Online consumer plotter"
__author__   = "Lester Miller"
__date__     = "11/20/2003"
__version__  = "$Revision: 1.10 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC
import LATTE.consumer.consumer as consumer
import LATTE.consumer.standardPlotter as standardPlotter
import threading
import sys
from qt import *
import Numeric as numarray
import os
import sihippo

class consumerPlotter(consumer.Consumer,standardPlotter.standardPlotter,QMainWindow):
  """\brief Consumer class to consume LDF data
  This class just handles file open/close or server
  open/close
  """
  
  def __init__(self,argv):
    """consumer constructor
    """
    QMainWindow.__init__(self,None,None,0)
    if 'ONLINE_ROOT' in os.environ:
      self.configFile = os.path.join(os.environ['ONLINE_ROOT'],'LATTE/consumer/consumerPlotter.cfg')
    else:
      self.configFile = ''
    consumer.Consumer.__init__(self,argv)
    standardPlotter.standardPlotter.__init__(self, self.lci)
    # used for status
    self.COMPL_STATUS_FAILED = 'FAILED'
    self.COMPL_STATUS_PASSED = 'PASSED'
    self.COMPL_STATUS_UNDEFINED = 'PASSED'
    self.COMPL_STATUS_ABORTED = 'ABORTED'
    self.COMPL_STATUS_PASSED_CONDITIONALLY = 'PASSED_CONDITIONALLY'
    self.__status = self.COMPL_STATUS_UNDEFINED
    self.__exportedFileList = []
    self.initializePlotter()
    self.guiThread = threading.Thread(None,self.loop,'consumerloop',())
    self.guiThread.start()
    
  def getName(self):
    return 'consumerPlotter'

  def parseEvent(self):
    """Analyse an event
    """
    self.ldbi.iterate(self.eventData, len(self.eventData)) 
    self.checkUDF()
    if self.endRun:
      self.setCompletionStatus(self.COMPL_STATUS_PASSED)
      self.reportResults()
      self.exportFiles()
    if self.startRun:
      self.setCompletionStatus(self.COMPL_STATUS_UNDEFINED)
      self.clearPlots()
      self.readPedestals()
    self.updatePlots()
    if self.lci.nEvtSeen>0 and self.lci.nEvtSeen%self.checkInterval==0:
      self.checkLimits()
    
  def checkUDF(self):
    udfDict = self.lcti.getUdfDict()
    self.startRun = False
    if 'startRun' in udfDict:
      self.setRunId(udfDict['startRun'])
      self.startRun = True
    self.endRun = False
    if 'endRun' in udfDict:
      self.endRun = True
    if 'configFile' in udfDict:
      self.setConfigFile(udfDict['configFile'])
    if 'dataType' in udfDict:
      self.setDataType(udfDict['dataType'])
    self.lcti.clearUdfDict()
  
  def checkLimits(self):
    print 'checking limits...'
    for plot in self.limits.keys():
      cLimit = self.limits[plot]
      # check ringBuffer for completion
      if self.ntRequests[self.getPlotNtuple(plot)]<=0 or self.lci.ntDict[self.getPlotNtuple(plot)].rows()>=self.ntRequests[self.getPlotNtuple(plot)]:
        (limitName,limitLabelList,limitFailList,errorLabelList,errorFailList)  = self.checkLimit(plot,cLimit)
        if len(limitFailList)>0 or len(errorFailList)>0:
          #self.histDict[plot].getDataRep(0).setRepColor(sihippo.Color.orange)
          print 'Plot ',plot,' is out of limits!!'

  # these methods are needed for reporting, they pretend to be rcTransitions
  def setCompletionStatus(self,status):
    self.__status = status
  def getCompletionStatusStr(self):
    return self.__status
  def getCompletionStatus(self):
    return self.__status

  def addExportedFile(self,file,delete=False):
    self.__exportedFileList.append((file,delete))

  def exportFiles(self):
    if self.reportPath is not None and os.path.exists(self.reportPath) and len(self.__exportedFileList)>0:
      exportDirName = self.getName()+'_'+self.getRunId()
      exportDir = os.path.join(self.reportPath,exportDirName)
      if os.access(self.reportPath,os.W_OK):             # can we write?
        os.mkdir(exportDir)
        for (file,delete) in self.__exportedFileList:
          import shutil
          fileName = os.path.basename(file)
          outFile = os.path.join(exportDir,fileName)
          # avoid copying to itself
          if os.path.exists(file) and not os.path.exists(outFile):
            if delete:
              shutil.move(file,outFile)
            else:
              shutil.copy(file,outFile)
    
if __name__ == '__main__':
  a = QApplication(sys.argv)
  consumer = consumerPlotter(sys.argv[1:])
  QObject.connect(a,SIGNAL("lastWindowClosed()"),a,SLOT("quit()"))
  a.setMainWidget(consumer)
  a.exec_loop()

---