BTdump.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 LAT Data Format (LDF) data dumper functions for Beam Test"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "6/17/2006"
__version__  = "$Revision: 1.1 $"
__credits__  = "SLAC"

import copyright_SLAC

import os, stat, struct

import LDF

import LDFdumper as LD
from   LDFdumper import _u

from   LDFdump               import myLATcomponentIterator
from   ancillaryContribution import AncillaryContribution

import sys


def _testDg(dgBuf):
  """Iterate over a buffer containing a list of LATdatagrams.
  """
  class myEBFeventIterator(LDF.LDBI_EBFeventIterator):
    def __init__(self, lci):
      LDF.LDBI_EBFeventIterator.__init__(self, lci)
      self.__lci = lci

    def process(self, evt):
      LD.EBFevent(evt).dump()
      if evt.status() != 0:
        print
        print "Bad status %d in event header" % (evt.status())
        print "Aborting processing of event"
        print
        return evt.status()
      else:
        self.__lci.iterate(evt)
        return self.__lci.status()

    def handleError(self, event, code, p1, p2):
      if code == LDF.EBFeventIterator.ERR_NonEBFevent:
        print >> sys.stderr, "EBFeventIterator::iterate: ", \
                            "Encountered a non-EBFevent datagram contribution ", \
                            "with typeId %08x\n" % (p1)
        return 1
      else:
        print >> sys.stderr, "myEBFeventIterator.handleError got unknown error code:", \
                             "  code=%d, p1=%d, p2=%d\n" % ( code, p1, p2)
      return 0

  class myASCtileContributionIterator(LD.ASCtileContributionIteratorDump):
    def __init__(self):
      LD.ASCtileContributionIteratorDump.__init__(self)

  class myASCcontributionIterator(LD.ASCcontributionIteratorDump):
    def __init__(self):
      LD.ASCcontributionIteratorDump.__init__(self)

  class myLATcontributionIterator(LDF.LDBI_LATcontributionIterator):
    __typeIds = [AncillaryContribution.EventId,
                 AncillaryContribution.HeaderId,
                 AncillaryContribution.TrailerId]
    def __init__(self, eei):
      LDF.LDBI_LATcontributionIterator.__init__(self, eei)

    def handleError(self, contribution, code, p1, p2):
      if code == LDF.LATcontributionIterator.ERR_UDFcontribution:
        typeId = _u(p1)
        if typeId & 0x000fffff in myLATcontributionIterator.__typeIds:
          import Numeric
          buffer = Numeric.fromstring(contribution.string(0), 'i')
          i      = 0
          prefix = "  "
          print "ANC:"
          print "%s  %08x, %08x, %08x, %08x" % (prefix,
                                                _u(buffer[0  ]),_u(buffer[i+1]),
                                                _u(buffer[i+2]),_u(buffer[i+3]))
          print
          return 0
        else:
          print >> sys.stderr, "LATcontributionIterator::UDF: ", \
                               "Found unrecognized LATdatagram contribution type 0x%08X" % \
                               (typeId)
          return -1
      else:
        print >> sys.stderr, "myLATcontributionIterator.handleError got unknown error code:", \
                             "  code=%d, p1=%d, p2=%d\n" % ( code, p1, p2)
      return 0

    def ASC(self, start, end):
      print ""
      print "ASC"
      asci = myASCcontributionIterator()
      asci.iterate(start)
      return asci.status()

  class myLATdatagramIterator(LDF.LDBI_LATdatagramIterator):
    def __init__(self, lci):
      LDF.LDBI_LATdatagramIterator.__init__(self, lci)
      self.__lci = lci

    def handleError(self, contribution, code, p1, p2):
      if code == LDF.LATdatagramIterator.ERR_IDmismatch:
        print >> sys.stderr, "LATdatagramIterator.iterate: ", \
                             "Identity mismatch: got %08x, expected %08x\n" % \
                            (p1, p2)
        return -1
      else:
        print >> sys.stderr, "myLATcontributionIterator.handleError got unknown error code:", \
                             "  code=%d, p1=%d, p2=%d\n" % ( code, p1, p2)
      return 0

    def process(self, dg):
      LD.LATdatagram(dg).dump()

      self.__lci.iterate(dg)      # Returns the number of objects iterated over
      status = self.__lci.status()
      if status:  print "Datagram iteration returned status 0x%08x = %d" % \
         (_u(status), _u(status))

      return 0

  latCompIt    = myLATcomponentIterator()
  ebfEvtIt     = myEBFeventIterator(latCompIt)
  ascContIt    = myASCcontributionIterator()
  latContIt    = myLATcontributionIterator(ebfEvtIt)
  latDgIt      = myLATdatagramIterator(latContIt)
  latDataBufIt = LDF.LATdataBufferIterator(latDgIt)

  latDataBufIt.iterate(dgBuf, len(dgBuf)) # Returns # of objects iterated over
  return latDgIt.status()

def testDG(dg):
  _testDg(dg)

def testRaw(filename="muon-5.arch", skip=0, saveFile=None):
  """This function is meant for use with datagram encapsulated EBF event files.
  It assumes the first contribution to the datagram is an EBF event and ignores
  any subsequent contributions.  An EBF event as defined here contains an
  identification value in its first longword and is followed by the raw EBF
  event format as described in the TEM, AEM, GEM, etc. documents.
  """
  ebfFile = open(filename, 'rb')
  fileLen = os.stat(filename)[stat.ST_SIZE]
  if saveFile is not None:  saveFile = open(saveFile, 'wb')
  n = 0

  while fileLen > 0:
    try:
      data               = ebfFile.read(8)
      if len(data) < 8:  break
      (identity, length) = struct.unpack('!LL', data)
      data              += ebfFile.read(length - 8)

      if n == skip:
        if saveFile is not None:  saveFile.write(data)
        print
        status = _testDg(data)
        if status > 0: break
        if status < 0:
          skip = -status
          n    = 0
      else:
        if n % 30000 == 0:
          print "\n%7d" % (n),
        else:
          if n % 1000 == 0:
            print ".",
        n += 1

      fileLen -= length
    except KeyboardInterrupt:
      n = skip
    except MemoryError, e:
      print "MemoryError exception: ", e
      print "Length = 0x%08x" % length

  if saveFile is not None:  saveFile.close()
  ebfFile.close()


if __name__ == '__main__':
  import sys

  def usage():
    print "%s <filename>" % sys.argv[0]
    print
    print "  runs testRaw(<filename>)"
    print
    print "Other functions are available by running with python -i:"
    print "  test(<string buffer>)"
    print "  testEBF(<filename>, <identity>)"
    print "  testRaw(<filename>, <skip count>, <save filename>"
    print "  testFITS(<filename>)"
    print "  testFITS_Dist(<filename>, <multicast address>)"
    print "  testRaw_Dist(<server>)"
    print "  testHex(<filename>)"


  if len(sys.argv) == 1:
    usage()
  else:
    testRaw(sys.argv[1])

---