testAppEvt.py

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

__facility__ = "Online"
__abstract__ = "Example EBF event handling test application"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2/25/2003"
__version__  = "$Revision: 1.6 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import                      threading
import logging       as     log
from   LATTE.runcontrol.rcTransitions import rcTransitions
from   LATTE.runcontrol.ArgumentImpl  import ArgumentImpl
import                      time
import                      math
import                      sys

from support.SimpleGasuExample   import *
from support.MiniGLTExample      import *

import LDF

import Numeric as Numeric


def _unsigned(arg):
  """\brief Convert an unsigned int argument to an unsigned long

  This funtion exists to help format unsigned ints greater than 0x7fffffff,
  which in Python 2.4 and up will be displayed as signed strings.
  """
  return arg & (2L * sys.maxint + 1)


class myLATcomponentIterator(LDF.LATcomponentIterator):
  def __init__(self):
    LDF.LATcomponentIterator.__init__(self)

  def UDFcomponent(self, event, ebfContribution):
    print ""
    print "Undefined EBF component"
    return 0

  def GLTcomponent(self, event, gemContribution):
    data = Numeric.fromstring(gemContribution.data(), 'i')
    print "GEM data: %08x %08x" % (_unsigned(data[0]), _unsigned(data[1]))
    print "Time = %f" % (gemContribution.timeFloat())
    return 0

  def ACDcomponent(self, event, aemContribution):
    print "ACD summary word        = 0x%08x" % (aemContribution.summary())
    print "ACD contribution length = %d"     % (aemContribution.length())
    data = Numeric.fromstring(aemContribution.data(), 'i')
    for i in range(aemContribution.payloadSize() >> 2):
      print "ACD data[%3d]: 0x%08x" % (i, _unsigned(data[i]))
    return 0

  def CALcomponent(self, event, calContribution):
    print "CAL summary word        = 0x%08x" % (calContribution.summary())
    print "CAL contribution length = %d"     % (calContribution.length())
    print "CAL accepts             = 0x%08x" % (calContribution.logAccepts())
    data = Numeric.fromstring(calContribution.data(), 'i')
    for i in range(calContribution.numLogAccepts()):
      print "CAL Log Data[%3d]: 0x%08x" % (i, _unsigned(data[i]))

    #evt  = data[0:384]
    #evt.shape = (4,4,2,12)
    #evt = Numeric.swapaxes(evt,0,1)
    #evt = Numeric.resize(evt, (4,8,12))
    return 0

  def TKRcomponent(self, event, tkrContribution):
    print "TKR summary word        = 0x%08x" % (tkrContribution.summary())
    print "TKR contribution length = %d"     % (tkrContribution.length())
    array = 8*4*' '          # 8 longwords of space to receive accepts
    accepts = Numeric.fromstring(tkrContribution.acceptsMask(event, array), 'i')
    print "TKR accepts             = 0x%03x 0x%03x 0x%03x 0x%03x 0x%03x 0x%03x 0x%03x 0x%03x" % \
          (accepts[0], accepts[1], accepts[2], accepts[3],
           accepts[4], accepts[5], accepts[6], accepts[7])
    data = Numeric.fromstring(tkrContribution.data(event), 'i')
    for i in range(tkrContribution.numAccepts(event)):
      print "TKR data[%3d]: 0x%08x" % (i, _unsigned(data[i]))
    return 0


#  This class puts up a GUI for inputting a value of some sort.  It is used by
#  the userApplication example to get the number of self triggers to take.
class userArgument(ArgumentImpl):
  "GUI for getting the user to input some sort of value."
  def __init__(self, parent = None, name = None, modal = 0, fl = 0):
    ArgumentImpl.__init__(self, parent, name, modal, fl)
    self.__value = 0
    self.setCaption("Hello world!")

  def OKButtonClicked(self):
    self.__value = int(self.ArgumentList.text().latin1())
    self.close()

  def CancelButtonClicked(self):
    self.__value = None
    self.close()

  def getValue(self, caption):
    self.setCaption(caption)
    self.show()
    self.exec_loop()
    return self.__value

class userArgText(object):
  "Text user interface for getting the user to input some sort of value"
  def __init__(self):
    pass

  def getValue(self, caption):
    return int(raw_input("%s: " % (caption)))


#  Example application implementation.
#  Note that the name of the class must be userApplication.
#  Look at rcTransitions for names of other transition methods that can be used.
class userApplication(rcTransitions):
  "Implmentation class for a user application"
  def __init__(self, rc, userId, debug):
    rcTransitions.__init__(self, rc, userId, debug)
    log.debug("userApplication.__init__()")
    self.__eventSem    = threading.Semaphore(0)
    self.__cmdSynchSem = threading.Semaphore(0)
    self.__lci         = myLATcomponentIterator()
    self.__ldbi        = LDF.LATdataBufferIterator(self.__lci)

  def getName(self):
    return __name__

  def setup(self):
    log.debug("userApplication.setup()")

    if self.rc is None:
      self.__arg = userArgText()
    else:
      self.__arg = self.rc.createGUI(userArgument, self.rc, 'test1', 1)

    # Get a TEM instance
    if self.lat.TEMcnt() == 1:
      tem = self.lat.TEM[self.lat.TEM.keys()[0]]
    elif self.lat.TEMcnt() > 1:
      tem = self.lat.TEM.all()
    else:
      log.fatal("No TEM(s) found in the schema")
      return -1

    if tem is not None:
      # clear TEM stats reg
      tem.COMMAND_RESPONSE = 0

      # clear TEM status reg
      tem.STATUS = 0
    else:
      log.fatal("No TEM found in the schema: aborting...")
      return -1
      
    ccc2 = tem.downCCC(2) # O$GCCC_02
    ccc2.LAYER_MASK_1 = 0x3BFD3FFFL
      
    # Two choices for the trigger, GEM and MiniGLT
    if self.lat.existsGEM():
      self.trigger( SimpleGasuExample() )
    else:
      self.trigger( MiniGLTExample() )

    # A state transition can be rejected by not returning None
    return None

  def startRun(self):
    log.debug("userApplication.startRun()")

    caption = "Enter number of triggers to take"
    if self.rc is None:
      cnt = self.__arg.getValue(caption)
    else:
      cnt = self.rc.execGUImethod(self.__arg.getValue, caption)

    if cnt is None:  return -1
    self.__cnt = cnt

    # Spawn a thread to synchronize commands with events
    self.__cmdSynchQuit = False

    # A state transition can be rejected by not returning None
    return None

  def stopRun(self):
    log.debug("userApplication.stopRun()")

    self.setCompletionStatus(self.COMPL_STATUS_SUCCESS)
    self.__cmdSynchQuit = True
    self.__eventSem.release()

    # The STOP_RUN transition can not be rejected

  def resume(self):
    log.debug("userApplication.resume()")

    # Issue self trigger to make up for the one that was lost during PAUSE
    self.trigger().solicit()

    return None

  def stop(self):
    log.debug("userApplication.stop()")

    return self.stopRun()

  def teardown(self):
    log.debug("userApplication.teardown()")
    # Allow the C++ object to be deleted
    if self.rc is not None and self.__arg is not None:
      self.__arg.deleteLater()

  def process(self, (status, buffer)):
    "Method called back for each data event taken"
    ##log.debug("userApplication.process()")

    evtCli = self.evtCli

    if status == 0:
     if 0:                              # One _OR_ the other method, not both
      self.__ldbi.iterate(buffer, len(buffer))
     else:                              # Old way of doing things
       pass
    else:
      if evtCli.isGGLTStatus():
        log.error("GGLT_STATUS=%d %s" % (evtCli.getGGLTStatus(), evtCli.getGGLTStatusStr()))
      elif not evtCli.checkOnlineStatus(status, evtCli.PLAYBACK_ERROR):
        log.error("EVENT ERROR= 0x%x %s" % (status, evtCli.getOnlineStatusStr()))
      self.__eventSem.release()
      return

    try:
      # In the future this event may contain additional data
      if evtCli.isSweepEvent(): return
    except:
      # Event summary word inaccessible, handle the bad event here
      log.exception("")
      return

    print "Event Size           =", evtCli.getEvtSize()
    print "Event Status         =", evtCli.getEvtStatus()
    ts = evtCli.evGetTimestamp()
    print "Event Timestamp (GMT)=", time.asctime(time.gmtime(ts)), \
                                    "and", int(math.modf(ts)[0]*1000), "ms"
    contList = evtCli.getContributionList()
    for cId in contList:
      evtCli.setCurrentContribution(cId)
      if cId.startswith('TEM'):
        evtCli.evDumpSummary()
        evtCli.evDumpCAL_LogAccepts()
        evtCli.evDumpCAL_Logs()
        evtCli.evDumpTKR()
        evtCli.evDumpTEM_Error()
        evtCli.evDumpDiagnostic()
        for acc in evtCli.evt.CAL_LogAccepts:
          print "CAL Log Accept: 0x%08x" % acc.ui

        for logData in evtCli.evt.CAL_LogData:
          print "CAL Log Data: 0x%08x" % logData.data.ui
      elif cId == 'ACD':
        evtCli.evDumpSummary()
        evtCli.evDumpEventAEM()
        print "AEM Veto Hit Vectors:"
        j = 0
        for hitVect in evtCli.evt.aem.vetoHitVectors:
          print "\tCable %2d Raw Data 0x%05x" % (j, hitVect)
          j+=1
        print "\nAEM Accept Hit Vectors:"
        j = 0
        for hitVect in evtCli.evt.aem.acceptHitVectors:
          print "\tCable %2d Raw Data 0x%05x" % (j, hitVect)
          j+=1
        print "\nAEM PHA Values:"
        j = 0
        for pha in evtCli.evt.aem.PHA:
          print "\tPHA Value: 0x%04x" % pha

    # Get next event triggered
    self.__eventSem.release()

  #def __commandSynch(self, count):
  def commandSynch(self):
    "Method called by the command synchronization task"
    import time
    trigger  = self.trigger()
    eventSem = self.__eventSem
    # Drain the semaphore release count
    # Handles the case when the stop run release collided with a trigger release
    while eventSem.acquire(0):  pass

    t0  = time.time()

    # Compensate for the extra CMD_SELF_TRIGGER below
    cnt = 1
    count = self.__cnt

    # Wait for START_RUN to enable triggers
    trigger.waitForMaskEnable()

    trigger.solicit()                   # Issue an internal trigger
    eventSem.acquire()                  # Wait for the event to be processed

    t1 = trigger.getEnableTime()        # get the last trigger enable time from GLT

    while cnt < count and not self.__cmdSynchQuit:
      cnt += 1
      trigger.solicit()                 # Issue an internal trigger
      time.sleep(.0001)
      eventSem.acquire()                # Wait for the event to be processed
      #trigger.disable()                # Disable triggers
      # Do stuff
      #trigger.enable()                 # Enable triggers

    t2 = trigger.getTimeStamp()                 # Get the last trigger timestamp
    # When we get here the triggers should still be enabled.
    # If the glt.MASK needs to be set through any other means
    # then it needs to be restored to its SETUP value here.

    if t1 is None:
      t1 = t0
    if t2 is None:
      t2 = time.time()
    dT = t2 - t1
    if dT == 0.0:  dT = 0.000001
    log.info("%s processed %d events in %.3f seconds = %.1f events/second" % \
             (self.getName(), self.evtCnt, dT, self.evtCnt/dT))

    # Get out of waiting when in suite or standalone mode
    self.sync()

    # execute the GUI functions for stopRun, just in case
    if not self.__cmdSynchQuit and not self.isRunFromSuite():
      if self.rc is not None:
        self.rc.doStop()

  def wait(self):
    self.__cmdSynchSem.acquire()

  def sync(self):
    if __name__ == "__main__" or self.isRunFromSuite():
      self.__cmdSynchSem.release()


# Standalone mode:
if __name__ == "__main__":
  from LATTE.runcontrol.RunControlCommon import RunControlCommon

  rcCommon = RunControlCommon()
  rcCommon.initialize()
  rcCommon.setLoggingLevel("DEBUG")
  rcCommon.connect()
  ua = userApplication(None, 321, rcCommon)
  ua.rcSetup()
  ua.rcStartRun()
  ua.wait()
  ua.rcStopRun()
  ua.rcTeardown()

---