splitOutTem.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.2 $"
__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 binascii import hexlify

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

import LDF

import 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)
    self.parent = None
  
  def TEM(self, event, ebfContribution):
    cellHdr = LDF.LATPcellHeader(ebfContribution.header())
    tem = cellHdr.source()  # enum maps 1:1 with tower number
    self.parent.tem[tem] = self.parseContrib(ebfContribution)
    
    return 0
    
  def GEM(self, event, ebfContribution):
    self.parent.gem = self.parseContrib(ebfContribution)
    return 0
    
  def AEM(self, event, ebfContribution):
    self.parent.aem = self.parseContrib(ebfContribution)
    return 0
  
  def OSW(self, event, ebfContribution):
    self.parent.osw = self.parseContrib(ebfContribution)
    return 0
    
  def headerStr(self, contrib):
    header      = long(contrib.header()     )
    packetError = long(contrib.packetError())
    sequence    = long(contrib.sequence()   )
    length      = long(contrib.length()     )
    
    pack = ((packetError&0x7)<<13) | ((sequence&0x1f)<<8) | ((length>>4)&0xff)
    hpknum = 0L
    hpknum = hpknum | (header<<16|pack); 
    rst = ""
    
    # print hex(header), packetError, sequence, length, hex(summary)
    for i in range(4):
      rst = chr(hpknum&0xff) + rst
      hpknum = hpknum >> 8
    return rst
    
  def summaryStr(self, contrib):
    summary = long(contrib.summary())
    rst = ""
    for i in range(4):
      rst = chr(summary&0xff) + rst
      summary = summary >> 8
    return rst
  
  def payloadStr(self, ebfContribution):
    pd = ebfContribution.payload()
    return Numeric.fromstring(pd).byteswapped().tostring()
  
  def parseContrib(self, ebfContribution):
    str  = self.headerStr(ebfContribution)
    str += self.summaryStr(ebfContribution)
    str += self.payloadStr(ebfContribution)
    return str
    
    
class myLATdbIterator(LDF.LATdataBufferIterator):
  def __init__(self, lci, temList):
    LDF.LATdataBufferIterator.__init__(self, lci)
    self.__lci = lci
    lci.parent = self
    
    self.ldfFiles = {}
    for tem in temList:
      fName = "tem_%x.ldf" % tem
      self.ldfFiles[tem] = open(fName, mode='wb')
      
  
  def iterate(self, buffer, size):
    hdr = buffer[0:16]
    hdrStr = Numeric.fromstring(hdr).byteswapped().tostring()
    # print "LDBI: ", hexlify(hdr)
    
    # set up contrib buffers
    self.gem = ""
    self.aem = ""
    self.osw = ""
    self.tem = [""] *16
    
    LDF.LATdataBufferIterator.iterate(self, buffer, size)
    
    for tem, ldfFile in self.ldfFiles.items():
      bufstr = ""
      bufstr += self.osw
      bufstr += self.gem
      bufstr += self.tem[tem]
      bufstr += self.aem
      
      dgLength = len(hdr) + len(bufstr) 
      evLength = dgLength - 8
      tmp = divmod(dgLength, 0x100)
      dgLenStr = chr(tmp[0]) + chr(tmp[1])
      tmp = divmod(evLength, 0x100)
      evLenStr = chr(tmp[0]) + chr(tmp[1])
      
      newHdr = hdr[0:6] + dgLenStr + hdr[8:14] + evLenStr
      bufstr = newHdr + bufstr
      
      ldfFile.write(bufstr)
    
    
  def closeAll(self):
    for tem in self.ldfFiles.values():
      tem.close()


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)))


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)

  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)

    # Split the run file into N parts, where N is the number of TEMs
    if self.lat.existsGEM():
      self.trigger( SimpleGasuExample() )
    else:
      self.trigger( MiniGLTExample() )

    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)

    # 1) Determine TEMs present in Schema
    temList = self.lat.TEM.keys()
    if temList == []:
      raise RuntimeError("No TEMs in schema, aborting split of LDF file")
    if len(temList) == 1:
      raise RuntimeError("Only one TEM in schema, aborting split of LDF file")

    # 2) pass temList to routines which do the work
    self.__lci         = myLATcomponentIterator()
    self.__ldbi        = myLATdbIterator(self.__lci,temList)
    
    if cnt is None:  return -1
    self.__cnt = cnt

    self.__cmdSynchQuit = False

    return None

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

    self.setCompletionStatus(self.COMPL_STATUS_SUCCESS)
    self.__cmdSynchQuit = True
    self.__eventSem.release()
    # don't forget to close the TEM files
    self.__ldbi.closeAll()


  def resume(self):
    log.debug("userApplication.resume()")
    self.trigger().solicit()
    return None

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

  def teardown(self):
    log.debug("userApplication.teardown()")
    if self.rc is not None and self.__arg is not None:
      self.__arg.deleteLater()

  def process(self, (status, buffer)):
    log.debug("userApplication.process()")

    evtCli = self.evtCli
    self.__ldbi.iterate(buffer, len(buffer))

    if status == 0:
      if 0:                              # One _OR_ the other method, not both
        pass
      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


    # 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
    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

    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



    # 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()

---