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

import LATTE.copyright_SLAC

from TrgMiniGLTRegisters import TrgMiniGLTRegisters
from TrgConditionsValue  import TrgConditionsValue
from TrgObject           import TrgObject

"""TrgMiniGLT: This file implements the hardware register access to the MiniGLT"""

class TrgMiniGLT(TrgMiniGLTRegisters):
  """\brief Mini GLT Hardware abstraction implementation
  """

  __SWEEP_MARKER = 5
  __SOLICIT_MASK = ~0x01

  def __init__(self):
    """\brief TrgMiniGLT constructor
    """
    TrgMiniGLTRegisters.__init__(self)
    self.__glt       = None

  def __commit(self):
    """\brief commit function
    This function commits the configuration defined by this
    TrgMiniGLT object to the hardware.  It does *all* the registers.
    """
    glt = self.GLT()

    # set all engine destination addresses.
    # Because engines can't have a real HW dependence, this is done by cheating:
    #   replace each instance of the TrgEngineRequest.destination function
    #   with a local private function.
    for engineNo in range(TrgObject.ENGINE_NUMBER_MAX + 1):
      self.engines().engine(engineNo).request().destination = self.__getDestinationFromEPU

    glt.PARITY               = self.parity()
    glt.TAG                  = self.tag()
    glt.EVENT_NUMBER         = self.eventNumber()
    glt.DESTINATION          = self.destination()
    glt.MARKER               = self.marker()
    glt.TACK                 = self.tack()
    glt.ZERO_SUPPRESS        = self.zeroSuppress()
    glt.FOUR_RANGE_READOUT   = self.fourRangeReadout()
    glt.CAL_STROBE           = self.calStrobe()

    glt.MASK                 = ~0              # everything disabled by default

  def GLT(self, glt = None):
    """\brief GLT function
    \params glt:  a GGLT object
    This function sets the GLT hardware implementation used by
    TrgGem.
    """
    if glt is not None:
      self.__glt = glt
      self.__epuaddr = glt.getEPUaddr()
    return self.__glt

  def __getDestinationFromEPU(self):
    return self.__epuaddr

  ############### Pure virtual function implementation
  def solicit(self):
    # transmit the GEM's TRIGGER dataless command
    self.GLT().CMD_SELF_TRIGGER = 1

  def enable(self, mask=None):
    if mask is not None:
      outMask = mask
    elif self.__condValue is not None:
      outMask = ~self.conditions().value()          # remember the MiniGLT has ~logic
    else:
      raise AssertionError, "Attempting to enable a TrgConditionsValue of None"
      
    self.GLT().MASK = outMask
    self.GLT().enableMask()

  def disable(self):
    self.GLT().disableMask()

  def shut(self, marker):
    """Implementation of the shut function.
    """

    #0) disable triggers
    self.disable()

    #1) Set up marker logic
    glt = self.GLT()

    mask           = glt.MASK           # Cache Mask, CalStrobe and Tack
    calStrobe      = glt.CAL_STROBE
    tack           = glt.TACK

    glt.MASK       = TrgMiniGLT.__SOLICIT_MASK # Enable internal trigger only
    glt.MARKER     = marker             # Signal that we're sweeping
    glt.CAL_STROBE = 0                  # Don't inject charge
    glt.TACK       = 0                  # Don't force a readout
    glt.enableMask()
    self.solicit()                      # Solicit a trigger
    glt.disableMask()

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

    #5) Put the trigger conditions back
    glt.enableMask()


class MiniGLTTrgConditionsValue(TrgConditionsValue):
  """This class overrides the value() method of TrgConditionsValue
     as the MiniGLT has a different bitmap for the MASK register.
     It also provides the external() function.

     Use this class instead of TrgConditionsValue for MiniGLT operations.
  """
  def __init__(self):
    TrgConditionsValue.__init__(self)

  def value(self):
    val = 0
    val |= ( self.solicited()   & 0x1 )  << 0
    val |= ( self.external()    & 0x1 )  << 1
    val |= ( self.calLow()      & 0x1 )  << 2
    val |= ( self.calHigh()     & 0x1 )  << 3
    val |= ( self.tkr()         & 0x1 )  << 4
    return val

  def external(self):
    return False

---