rcTransitionsBT.py

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

__facility__ = "Online"
__abstract__ = "Replacement rcTransitions class for event merging"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "6/29/2006"
__updated__  = ("$Date: 2006/07/19 16:26:04 $").split(' ')[1]
__version__  = "$Revision: 1.4 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import struct

from   LATTE.runcontrol.rcTransitions     import rcTransitions
from   LATTE.merger.ancillaryContribution import AncillaryContribution
from   LDF                                import EBFevent
from   support.gEvtCliBT                  import EvtCliBT


class rcTransitionsBT(rcTransitions):
  def __init__(self, rc, userId, debug, merge = True):
    rcTransitions.__init__(self, rc, userId, debug)
    self.__debug       = debug
    self.__merge       = merge # Set merge to False to disable merging
    self.__autoStopRun = True

  def autoStopRun(self, value = None):
    if value is not None:  self.__autoStopRun = value
    return self.__autoStopRun

  def rcSetup(self):
    if self.__merge:
      self.__ecSave = self.evtCli
      self.__ec = EvtCliBT(debug=self.__debug)
      self.setEvtCli(self.__ec)
    return rcTransitions.rcSetup(self)

  def rcTeardown(self):
    if self.__merge:
      self.__ec.shutdown()
      self.setEvtCli(self.__ecSave)
    return rcTransitions.rcTeardown(self)

  def eventHandler(self):
    if not self.__merge:  return self._rcTransitions__datagramHandler()

    sweepEvt  = self._rcTransitions__sweepEvent
    evtCli    = self.evtCli
    sweepMkr  = rcTransitions._rcTransitions__SWEEP_MARKER
    markerMsk = 0x7 << 22
    errorMsk  = 0x1 << 21
    trgParMsk = 0x1
    pktErrMsk = 0x7 << 13

    self._rcTransitions__evtHandlerQuit = False

    # Indicate that the Event Handler is ready to take events
    self._rcTransitions__eventHandlerReady.set()

    while not (self._rcTransitions__evtHandlerQuit and sweepEvt.isSet()):
      statuses, datagram  = evtCli.readEvent()
      header = struct.unpack('!6L', datagram[0:24])

      status                = 0
      self.errorEvent       = False
      self.trgParErrorEvent = False
      self.packetErrorEvent = False
      self.eventMarker      = None
      contribId = header[2] & 0x000fffff
      if   contribId == AncillaryContribution.HeaderId:
        self.eventMarker  = -1
      elif contribId == AncillaryContribution.TrailerId:
        if self.__autoStopRun:
          import logging
          logging.info("rcTransitionsBT.eventHandler: Ancillary trailer seen.  Stopping run")
          self.rc.doStopRun()
        self.eventMarker  = -1
      elif contribId == AncillaryContribution.EventId:
        # Count every event to ensure displayed rate makes sense
        self.evtCnt                    += 1
        self._rcTransitions__dgSize     = header[1]
        self._rcTransitions__dgSumSize += header[1]

        ancSize = header[3]
        if self._rcTransitions__dgSize > ancSize + 8:
          status    = statuses[1]       #!\todo deal with other statuses
          ebfEvent  = datagram[ancSize + 8:]
          ebfHeader = struct.unpack('!4L', ebfEvent[0:16])

          # Give application quick access to error bit and marker
          self.errorEvent       = (ebfHeader[3] & errorMsk)  != 0
          self.trgParErrorEvent = (ebfHeader[3] & trgParMsk)
          self.packetErrorEvent = (ebfHeader[2] & pktErrMsk) != 0
          self.eventMarker      = (ebfHeader[3] & markerMsk) >> 22
      elif contribId == EBFevent.ID & 0x000Fffff:
        # Count every event to ensure displayed rate makes sense
        self.evtCnt                    += 1
        self._rcTransitions__dgSize     = header[1]
        self._rcTransitions__dgSumSize += header[1]

        status = statuses[0]       #!\todo deal with other statuses
        # Give application quick access to error bit and marker
        self.errorEvent       = (header[5] & errorMsk)  != 0
        self.trgParErrorEvent = (header[5] & trgParMsk)
        self.packetErrorEvent = (header[4] & pktErrMsk) != 0
        self.eventMarker      = (header[5] & markerMsk) >> 22
      else:
        import logging
        logging.error("rcTransitionsBT.eventHandler: Unrecognized contribution encounterd: %08x" % (contribId))

      # Process the datagram
      latContribs = self._rcTransitions__process(status, datagram)

      # Check FSW event delivery to OES status
      if status == 0:
        # Archive the data
        self._rcTransitions__archive(header[0], latContribs)

        # Multicast the data
        self._rcTransitions__publish(datagram)

        # Handle datagrams with TEM contribution errors
        if self.eventMarker != sweepMkr and \
            (self.errorEvent or self.trgParErrorEvent or self.packetErrorEvent):
          self._rcTransitions__archiveErr(datagram)
          # increment internal error counters
          if self.errorEvent:          self._rcTransitions__errEvents      += 1
          if self.trgParErrorEvent:    self._rcTransitions__trgParErrorEvt += 1
          if self.packetErrorEvent:    self._rcTransitions__pktErrorEvt    += 1
      else:
        # Handle datagrams for which FSW choked
        self._rcTransitions__badEvents += 1
        self._rcTransitions__archiveBad(datagram)

      # Make sure the above is done before setting the sweepEvt to prevent
      # things from getting out of sync.
      if self.eventMarker == sweepMkr:  sweepEvt.set()

    # Flush any events left in the systems.  They'll all be incomplete.
    evtCli.flushAll()

    import logging
    logging.debug("rcTransitionsBT.eventHandler: %s terminating" %
              (self.getName()))

---