rcTrgGem.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.11 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC


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

from TrgGem       import TrgGem
from threading    import Event
import logging
import time

class rcTrgGem(TrgGem):
  """\brief rcTrgGem class definition
  This class implements a 'threaded' model for enabling/disabling the trigger
  """
  __SWEEP_TMO        = 3.0            # Sweep timeout in floating point seconds

  def __init__(self):
    """rcTrgGem constructor
    """
    self.__triggersEnabled = Event()
    self.__enableTime      = -99999999999
    self.__disableTime     = -99999999999

    TrgGem.__init__(self)                    # do this last

  def commit(self, gem = None):
    """\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.
    """
    if gem is not None:
      self.GEM(gem)
    self._TrgGem__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.__triggersEnabled.wait(tmo)

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

    \return Trigger enable time
    """
    return self.__enableTime

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

    \return Trigger disable time
    """
    return self.__disableTime

  def getTimeStamp(self):
    """ Returns the VxWorks timestamp for the last time a self-trigger
        was asserted.
    \return Trigger timestamp
    """
    ts = self.GEM().GEMC.regs['cmd_trigger'].getTimeStamp()
    return ts

  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, mask=None):
    """Re-implementation of the enable() function to take advantage
    of threading
    """
    if mask is not None:
      outMask = mask
    elif self.conditions() is not None:
      outMask = self.conditions().value()
    else:
      raise AssertionError, "Attempting to enable a TrgConditionsValue of None"

    if self.__triggersEnabled.isSet(): return        # triggers already enabled

    gemw = self.GEM().GEMW
    gemw.WINDOW_OPEN_MASK = outMask
    self.__triggersEnabled.set()

    self.__enableTime = gemw.regs['window_open_mask'].getTimeStamp()

  def disable(self):
    """Re-implementation of the disable() function to take advantage
    of threading
    """
    self.__triggersEnabled.clear()
    gemw = self.GEM().GEMW
    gemw.WINDOW_OPEN_MASK = 0
    self.__disableTime = gemw.regs['window_open_mask'].getTimeStamp()

  def shut(self, sweepEvent, progress = None):
    """Re-implementation of the shut function to take advantage of the
    fact that in rcTrgGem, trigger engine 15 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.
    """

    gemw = self.GEM().GEMW
    gemsc = self.GEM().GEMSC

    #0) determine whether we are enabled or not
    if gemw.WINDOW_OPEN_MASK != 0:
      enabled = True
    else:
      enabled = False

    #1) disable triggers
    goodSolicit  = self.solicit
    self.solicit = self.__falseSolicit
    self.disable()
    sweepEvent.clear()

    #2) Replace contents of all schedulers with solicited with (Engine) f
    #   Doing it by hand
    scheduler = ( 0xffffffffL )               # Everything's f!
    regList = gemsc.regs.values()
    oldSched = {}    # dictionary keyed on register names
    for reg in regList:
      oldSched[reg.getName()] = reg.get()
      reg.set(scheduler)

    #2.5) Wait until we don't have progress
    if progress is not None:
      while True:
        if progress() == 0:
          break
        time.sleep(.5)
        # print "waiting for progress"

    #3) Change conditions to be solicit only, solicit a trigger
    gemw.WINDOW_OPEN_MASK = TrgGem._TrgGem__SOLICIT_MASK
    self.GEM().downGEMC().CMD_TRIGGER = 1

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

    self.disable()

    #5) Put the original contents of schedulers back
    for reg in regList:
      reg.set(oldSched[reg.getName()])

    #6) Put the trigger conditions back.
    if enabled:
      self.enable()
    self.solicit = goodSolicit
    
    return True


  def __falseSolicit(self):
    pass

---