rcTrgMiniGLT.py

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

__facility__ = "Online"
__abstract__ = "GLAST LAT Coincidence based Trigger System Interface classes"
__author__   = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST I&T"
__date__     = "2/14/04"
__version__  = "$Revision: 2.8 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

"""rcTrgMiniGLT:
This class implements a 'threaded' model for enabling/disabling the trigger
"""

from TrgMiniGLT   import TrgMiniGLT
from threading    import Event
import logging

class rcTrgMiniGLT(TrgMiniGLT):
  """\brief rcTrgMiniGLT class definition
  This class implements a 'threaded' model for enabling/disabling the trigger
  """
  __SWEEP_MARKER     = 5               # Arbitrary marker value for recognizing
                                       #   when the event pipeline is flushed
  __SWEEP_TMO        = 3.0             # Sweep timeout in floating point seconds
  def __init__(self):
    """\brief rcTrgGem constructor
    """
    self.__triggersEnabled = Event()

    TrgMiniGLT.__init__(self)                 # do this last
    self.__cacheMask       = None

  def commit(self):
    """\brief public commit function
    This function commits the configuration defined by this
    TrgGem object to the hardware.  It does *all* the registers.
    This function should never be called by anyone other than Run Control.
    """
    self._TrgMiniGLT__commit()

  def waitForMaskEnable(self, tmo = None):
    """Waits until the enableMask() method is called.
    This is usually needed by non-self-triggering scripts where
    the _commandSynch thread needs to wait until RunControl
    actually enables the mask before continuing.

    \param tmo  Optional parameter giving the wait timeout in seconds
    """
    self.GLT().waitForMaskEnable(tmo)

  def getEnableTime(self):
    """ Returns the VxWorks timestamp at the time the triggers are enabled

    \return Trigger enable time
    """
    return self.GLT().getEnableTime()

  def getDisableTime(self):
    """ Returns the VxWorks timestamp at the time the triggers are disabled

    \return Trigger disable time
    """
    return self.GLT().getDisableTime()

  def getTimeStamp(self):
    """ Returns the VxWorks timestamp for the last time a self-trigger
        was asserted.
    \return Trigger timestamp
    """
    return self.GLT().regs['CMD_SELF_TRIGGER'].getTimeStamp()

  def sweepOnShut(self):
    """ Returns whether or not shut() does a sweep event.  Default true.
    \return a boolean
    """
    return True

  ############### Pure virtual function reimplementation

  def enable(self, newMask=None):
    """Re-implementation of the enable() function to take advantage
    of threading and timestamps

    Adds an argument to deal with several weird masking problems
    Only rcTransitions should use the above argument
    """
    if self.conditions() is not None:
      outMask = ~self.conditions().value()          # remember the MiniGLT has ~logic
    else:
      raise AssertionError, "Attempting to enable a TrgConditionsValue of None"

    if newMask is not None:
      self.__cacheMask = newMask

    if self.__cacheMask is not None:
      outMask = self.__cacheMask

    self.GLT().MASK = outMask
    self.GLT().enableMask()

  def disable(self):
    """Re-implementation of the disable() function to take advantage
    of threading and timestamps
    """
    self.GLT().disableMask()

  def shut(self, sweepEvent, progress = None):
    """Re-implementation of the shut function to take advantage of the
    fact that in rcTrgMiniGLT, trigger engine 0 is reserved for the marker.

    \param sweepEvent: A sweep Event() defined by runControl
    \param progress:   An optional function that returns a non-zero value when
                       when events are passing through the system.  If omitted
                       a fixed timeout is used.
    """

    glt = self.GLT()

    #0) disable triggers
    if not glt.triggersDisabled():
      enabled = True
    else:
      enabled = False
    goodSolicit  = self.solicit
    self.solicit = self.__falseSolicit

    self.disable()
    sweepEvent.clear()

    #1) Set up marker logic
    mask           = glt.MASK           # Cache Mask, CalStrobe and Tack
    calStrobe      = glt.CAL_STROBE
    tack           = glt.TACK
    zeroSuppress   = glt.ZERO_SUPPRESS
    fourRange      = glt.FOUR_RANGE_READOUT
    marker         = glt.MARKER

    glt.MASK       = TrgMiniGLT._TrgMiniGLT__SOLICIT_MASK # Enable internal trigger only
    glt.MARKER     = rcTrgMiniGLT.__SWEEP_MARKER          # Signal that we're sweeping
    glt.CAL_STROBE = 0                  # Don't inject charge
    glt.TACK       = 1                  # Force a readout
    glt.ZERO_SUPPRESS       = 1         # Yes to zero suppression
    glt.FOUR_RANGE_READOUT  = 0         # No to four range readout

    #2) enable and solicit
    glt.enableMask()
    self.waitForMaskEnable()
    self.GLT().CMD_SELF_TRIGGER = 1     # Solicit a trigger

    #3) Block until the sweep is detected by rcTransitions then disable triggers
    tmo = rcTrgMiniGLT.__SWEEP_TMO
    while (tmo > 0.0):
      if sweepEvent.isSet():  break
      sweepEvent.wait(0.5)
      if progress is not None:
        if progress() != 0:
          tmo = rcTrgMiniGLT.__SWEEP_TMO
          continue
      tmo -= 0.5
    if tmo <= 0:
      sweepEvent.set()
      logging.fatal("Trigger sweep timed out before all events were drained")
      return False
    self.disable()

    #4) Put the original contents of scheduler 0x40 back, and put the TAM back
    glt.CAL_STROBE         = calStrobe
    glt.TACK               = tack
    glt.MARKER             = marker
    glt.ZERO_SUPPRESS      = zeroSuppress
    glt.FOUR_RANGE_READOUT = fourRange
    glt.MASK               = mask

    #5) Put the trigger conditions back
    if enabled:
      glt.enableMask()
    self.solicit = goodSolicit
    
    return True


  def __falseSolicit(self):
    pass

---