AcdHWMultiplexer.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 data export routines"
__author__   = "J. Panetta <panetta@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2004/11/08 21:03:12 $").split(' ')[1]
__version__  = "$Revision: 2.2 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import                           time
from Numeric                     import array, zeros

from LATTE.tools.taskEngine      import TaskEngine
from LATTE.database.gLAT         import *
from LATTE.trigger.TrgObject     import TrgObject
from thread                      import allocate_lock

class AcdHWMultiplexer(object):
  """\brief AcdHWMultiplexer class

  A class to multiplex the two ACD hardware scalers defined in
  section 2.6.2 of the GEM document, LAT-TD-01545 into up to 108
  separate counters.

  """
  __DEFAULT_DWELL_TIME             = 1    # Default to 1 second

  def __init__(self, GEM):
    """\brief AcdHWMultiplexer constructor

    \param GEM  a GEM object
    """
    self.__gemst = GEM.downGEMST()
    self.__gemie = GEM.downGEMIE()

    self.__dwell = None
    self.__tList = None
    self.__stats = None

    self.__accumEngine = TaskEngine("AcdHWMultiplexer")
    self.__accumEngine.start()

    self.__statsLock  = allocate_lock()

    self.__setupDone  = False
    self.__stopAccum  = False
    self.__abortAccum = False

    self.__sortIEregs()

  def start(self):
    """\brief Method for starting the accumulation of ACD hardware scalers

    Start the integration of the hardware counters.
    At the start of integration, the counters are all reset to zero (0).
    """
    # invalidate setup to reset stats, etc.
    self.__setupDone = False
    # spawn the accumulate engine
    self.__accumEngine.spawn(self.__accumulate)

  def stop(self):
    """\brief Method for stopping the accumulation of ACD hardware scalers

    Stop the integration of the hardware counters.
    The stop occurs at the end of the current cycle, and
    the counts from the current cycle are integrated into the count
    statistics
    """
    self.__stopAccum = True

  def resume(self):
    """\brief Method for resuming the accumulation of ACD hardware scalers after a stop

    Resume the integration of the hardware counters after a stop()
    call.  At resume of integration, the internal counters are not reset, but
    continue from their previous values.
    """
    # spawn the accumulate engine
    self.__stopAccum = False
    self.__accumEngine.spawn(self.__accumulate)

  def abort(self):
    """\brief Method for aborting the accumulation of ACD hardware scalers

    Abort the integration of the hardware counters.  The cycle
    stops immediately, and the set of counts from the current cycle
    is discarded.
    """
    self.__abortAccum = True

  def shutdown(self):
    """\brief Method for shutting down the Multiplexer.

    Shut down the thread the multiplexer is running in.  Should be
    called during endRun.
    """
    self.__accumEngine.shutdown()

  def dwell(self, d=None):
    """\brief Method to set the dwell time for scaler integration

    Set the dwell time (in seconds) for integration.
    Total time in a cycle through the scalers will be dwell * nTiles.
    Minimum dwell time is 0.1 seconds.  Default is 1 second.
    \param   dwell  Dwell time in seconds, default = 1 second
    """
    if d is not None:
      if d < 0.1:
        d = 0.1
      self.__dwell = d
      self.__setupDone = False      # invalidate setup, need to recompute stuff
    return self.__dwell

  def tileList(self, tList=None):
    """\brief Method to set which tiles are integrated

    Defines the list of tiles which are being integrated.
    Ex: range(108); [0,2,4,6]

    \param   tList  The list of tiles to be integrated.
    \return  The list of tiles that are being integrated
    """
    if tList is not None:
      self.__tList = tList
      self.__setupDone = False      # invalidate setup, need to recompute stuff
    return self.__tList

  def stats(self):
    """\brief Method to access the counter statistics

    Provides the user with the a list containing the counter statistics.
    This list corresponds to the tiles in tileList.

    \return The list of the tile statistics.
    """
    # Prevent multithread access to self.__stats with a lock
    self.__statsLock.acquire()
    s = self.__stats.tolist()
    self.__statsLock.release()
    return s


# private:
  def __setup(self):
    """Set up the system
    """
    # Make sure we're able to run.
    self.__stopAccum  = False
    self.__abortAccum = False
    self.__setupDone  = True

    # error checking
    if self.__tList is None:
      msg = "No list of tiles defined for the multiplexer."
      raise Exception, msg

    # No dwell time specified?
    if self.__dwell is None:
      self.__dwell = AcdHWMultiplexer.__DEFAULT_DWELL_TIME

    # Check integrity of tile list
    for tile in self.__tList:
      if tile < TrgObject.TILE_NUMBER_MIN or \
         tile > TrgObject.TILE_NUMBER_MAX:
        msg = "Tile number %d is out of range [%d, %d]" % \
        ( tile, TrgObject.TILE_NUMBER_MIN, TrgObject.TILE_NUMBER_MAX )
        raise IndexError, msg

    # set up internal array structure
    self.__tListInt = array( self.__tList )

    # create our internal and external stats arrays
    self.__statsInt = zeros( self.__tListInt.shape )
    self.__stats    = zeros( self.__tListInt.shape )

  def __accumulate(self):
    """ This is where the work is really done.
    """
    if not self.__setupDone:
      self.__setup()

    sweepSize = len(self.__tListInt)

    while ( not self.__stopAccum ):
      for tileSet in range(0,sweepSize,2):
        # Check for abort here
        if self.__abortAccum:
          print "abort"
          return

        tile_0 = self.__tListInt[tileSet]
        if tileSet+1 < sweepSize:
          tile_1 = self.__tListInt[tileSet+1]
        else:
          tile_1 = None

        # cache input enables
        regList  = self.__gemie.regs.values()
        self.__regCache = zeros( (len(regList)) )
        for reg in regList:
          if reg.size() > 0:
            self.__regCache[reg.id()] = reg.get()

        # set up counters
        self.__gemst.TILE_0 = tile_0
        if tile_1 is not None:
          self.__gemst.TILE_1 = tile_1

        # enable the proper tiles
        self.__setIE(tile_0)
        if tile_1 is not None:
          self.__setIE(tile_1)

        self.__gemst.TILE_COUNTERS = 0
        # Accumulate
        time.sleep(self.__dwell)
        count = self.__gemst.TILE_COUNTERS

        # reset the input enables
        self.__resetIE(tile_0)
        if tile_1 is not None:
          self.__resetIE(tile_1)

        # pull counters
        self.__statsInt[tileSet] = ( count >>  0 ) & 0xffff
        if tile_1 is not None:
          self.__statsInt[tileSet+1] = ( count >> 16 ) & 0xffff

      # Send internal stats into external stats
      # Prevent multithread access to self.__stats with a lock
      self.__statsLock.acquire()
      self.__stats += self.__statsInt
      self.__statsLock.release()
    print "stopped"

  def __setIE(self,tile):
    # set the corresponding bits in the IE on for a tile

    reg,bit = divmod(tile,9)
    value   = ( 1 << bit ) + ( 1 << bit+9 )  # two nine bit fields
    self.__gemieDict[reg+5].set( self.__gemieDict[reg+5].get() | value )         # tile enables start at 5

  def __resetIE(self,tile):
    # reset the changed input enables to their cached values
    reg,bit = divmod(tile,9)
    self.__gemieDict[reg+5].set( self.__regCache[reg+5] )

  def __sortIEregs(self):
    # create a lookup table based on register number
    regList  = self.__gemie.regs.values()
    self.__gemieDict = {}
    for reg in regList:
      if reg.size() > 0:
        self.__gemieDict[reg.id()] = reg

---