rcTrgFunctions.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 Trigger Input Enable Interface classes"
__author__   = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST I&T"
__date__     = "2/14/04"
__version__  = "$Revision: 2.3 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from TrgObject             import TrgObject
from TrgConditionsValue    import TrgConditionsValue
from TrgEngines            import *
from NullObjects           import NullEngine
from TrgInputEnables       import TrgTileEnables
from TrgInputEnables       import TrgTowerBusyEnables
from TrgCoincidences       import TrgCoincidence


"""rcTrgFunctions: Run control Interfaces for Trigger modules"""

class rcTrgEngines(TrgEngines):
  """\brief rcTrgEngines Class
  
  Setup a LATTE based trigger engine system.
  All sixteen (16) engines are defined.  [0..14] are NullEngine, the last
  is a reserved engine that transmits the sweep marker on transitions.
  """
  def __init__(self):
    """\brief rcTrgEngines constructor
    """
    TrgEngines.__init__(self)
    self.__engines = []
    for i in range(TrgObject.ENGINE_NUMBER_MAX):
      self.__engines.append( NullEngine() )
    self.__engines.append( SweepMarkerEngine() )
    
  def replaceEngine(self,engineNumber,engine):
    """\brief replaceEngine() method
    
    Replace one of the engines.
    \param engineNumber: The engine number to replace [0..13]
    \param engine:  The replacement engine
    """
    if engineNumber == 0xf:
      raise IndexError, "Sorry, can't replace engine number 15"
    if engineNumber == 0xe:
      raise IndexError, "Sorry, can't replace engine number 14"
    self.__engines[engineNumber] = engine
    
  def engine(self, engineNumber):
    """\brief engine() method
    
    Return one of the engines
    \param engineNumber: The engine to return
    """
    if engineNumber < TrgObject.ENGINE_NUMBER_MIN or \
       engineNumber > TrgObject.ENGINE_NUMBER_MAX:
      raise IndexError, "engineNumber is out of range"
    return self.__engines[engineNumber]

class SweepMarkerEngine(TrgEngine):
  """\brief SweepMarkerEngine class
  
     This class defines an engine which injects a sweep marker signal.  
     This engine is not prescaled.
  """
  SWEEP_MARKER = 5
  def __init__(self):
    """\brief SweepMarkerEngine constructor
    """
    TrgEngine.__init__(self)
    self.__request = rcTrgInjectMarker(SweepMarkerEngine.SWEEP_MARKER)
    
  def participate(self,conditionsValue):
    """\brief participate() method
    
    This function always returns False as this engine never 
    participates except when RunControl wants it to.
    """
    return False
    
  def prescale(self):
    """\brief prescale() method
    
    Returns 0.  This engine isn't prescaled
    """
    return 0
    
  def request(self):
    """\brief request() method
    
    Returns a TrgInjectMarker object
    """
    return self.__request
    
class rcTrgInjectMarker(TrgInjectMarker):
  def __init__(self, marker):
    TrgInjectMarker.__init__(self, marker)
  def zeroSuppress(self):
    return True
  def sequence(self):
    return 1
    

class rcTrgTileEnables(TrgTileEnables):
  """\brief rcTrgTileEnables class
  
  Class to abstract the additions of tiles to the input enable list.
  All tiles *not* in the enable list are specifically disabled
  """
  def __init__(self):
    """\brief rcTrgTileEnables constructor
    """
    TrgTileEnables.__init__(self)
    self.__tileA = []
    self.__tileB = []

  def tile(self, tileNumber):
    rc = 0
    if tileNumber in self.__tileA :
      rc |= 0x1
    if tileNumber in self.__tileB :
      rc |= 0x2
    return rc

  def addTile(self, tileNumber, side):
    if side & 0x1:
      self.__tileA.append(tileNumber)
    if side & 0x2:
      self.__tileB.append(tileNumber)

class rcTrgCoincidence(TrgCoincidence):
  """\brief rcTrgCoincidence class
  
  Class to provide a function to add tiles to coincidence sets.
  Also does checking to see if tiles are in the allowed tile set
  """
  def __init__(self):
    TrgCoincidence.__init__(self)
    self.__pairList = {}
    from TrgGemRegisterGeometry import AcdTileNumbering as TN
    self.__badTiles = ( TN['NA0'], TN['NA1'], TN['NA2'], TN['NA3'], TN['NA4'], 
                        TN['NA5'], TN['NA6'], TN['NA7'], TN['NA8'], TN['NA9'], TN['NA10'] )
    
  def addPair(self, tile1, tile2):
    """\brief addPair(tile1, tile2)
    
    \param tile1 an integer
    \param tile2 an integer
    
    Add a tile pair, tile1,tile2 to a coincidence list.
    Note, the set of tile1 objects must be unique.
    """
    self.__checkTile(tile1)
    self.__checkTile(tile2)
    self.__pairList[tile1] = tile2
      
  def inCoincidence(self,tileNumber):
    self.__bounds(tileNumber)
    if self.__pairList.has_key(tileNumber):
      return self.__pairList[tileNumber]
    else:
      return -1  # Tile not in coincidence List

  def __checkTile(self, tile):
    self.__bounds(tile)
    # self.__badlist(tile)
    
  def __bounds(self,tile):
    if tile < TrgObject.TILE_NUMBER_MIN or \
       tile > TrgObject.TILE_NUMBER_MAX:
      msg = "Tile number %d is out of range" % tile
      raise IndexError, msg
      
  def __badlist(self, tile):
    if tile in self.__badTiles:
      msg = "Tile number %d is a non-assigned tile" % tile
      raise IndexError, msg

class rcTrgTowerBusyEnables(TrgTowerBusyEnables):
  """\brief rcTrgTowerBusyEnables class
  
  Class to abstract the additions of towers to the tower-busy enable list.
  All towers *not* in the enable list are specifically disabled
  """
  def __init__(self):
    """\brief rcTrgTowerBusyEnables constructor
    """
    TrgTowerBusyEnables.__init__(self)
    self.__enab = 0x0

  def tower(self, towerNumber):
    if self.__enab & ( 1 << towerNumber):
      return True
    return False

  def addTower(self, towerNumber):
    self.__enab |= ( 1 << towerNumber);

---