TrgGemCounters.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 Object class"
__author__   = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST I&T"
__date__     = "2/14/04"
__version__  = "$Revision: 2.2 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from TrgObject          import TrgObject
from TrgTriggerCounters import TrgTriggerCounters
from TrgTriggerCounters import TrgTriggerStats

from TrgTileCounters    import TrgTileCounters
from TrgTileCounters    import TrgTileStats

from TrgCnoCounters     import TrgCnoCounters
from TrgCnoCounters     import TrgCnoStats

from TrgCmdCounters     import TrgCmdCounters
from TrgCmdCounters     import TrgCmdStats

from TrgEventCounter    import TrgEventCounter

from TrgPPSTimer        import TrgPPSTimer

"""TrgGemCounters: Trigger GEM counter hardware implementation class"""


class TrgGemTriggerCounters(TrgTriggerCounters):
  """\brief TrgGemTriggerCounters class
  
  This class implements the HW abstraction corresponding to
  figure 66-69 of the GEM document: LAT-01545 Section 2.6.1 and 2.6.2
  
  """
  def __init__(self,glt):
    """\brief TrgGemTriggerCounters constructor
    """
    TrgTriggerCounters.__init__(self)
    self.__stats = TrgGemTriggerStats(glt)
    if glt is not None:
      self.__cmd = glt.downGEMST()
    else:
      self.__cmd = None
    
  def stats(self):
    """\brief stats() member function
    Returns an object that accesses the trigger statistics
    \return a TrgGemTriggerStats object
    """
    return self.__stats
  
  def reset(self):
    """\brief reset() member function
    Reset the statistics registers
    """
    # writing to the register resets it.
    self.__cmd.LIVETIME      = 0
    self.__cmd.PRESCALED = 0
    self.__cmd.DISCARDED = 0
    self.__cmd.SENT      = 0
    
class TrgGemTriggerStats(TrgTriggerStats):
  """\brief TrgGemTriggerStats
  This class implements the HW abstraction corresponding to
  figure 66-69 of the GEM document: LAT-01545 Section 2.6.1 and 2.6.2
  
  Note:  Reading the livetime register latches all 4 registers.
         Rereading the livetime register unlatches the registers.
  """
  def __init__(self,glt):
    """\brief TrgGemTriggerStats constructor
    """
    TrgTriggerStats.__init__(self)
    if glt is not None:
      self.__cmd = glt.downGEMST()
    else:
      self.__cmd = None
    
  def livetime(self):
    return self.__cmd.LIVETIME & 0x0fff
    
  def prescaled(self):
    return self.__cmd.PRESCALED & 0x0fff
    
  def discarded(self):
    return self.__cmd.DISCARDED & 0x0fff
    
  def sent(self):
    return self.__cmd.SENT & 0x0fff
  
# ###########
  
class TrgGemTileCounters(TrgTileCounters):
  """ \brief TrgGemTileCounters
  
  This class implements the HW abstraction corresponding to
  the tile counter detailed in the GEM document: 
  LAT-01545 Section 2.6
  """
  def __init__(self,glt):
    """\brief TrgGemTileCounters constructor
    """
    TrgTileCounters.__init__(self)
    self.__stats = TrgGemTileStats(glt)
    if glt is not None:
      self.__cmd = glt.downGEMST()
    else:
      self.__cmd = None

  def stats(self):
    return self.__stats

  def reset(self):
    """\brief reset() member function
    
    Reset the tile counter register
    """
    self.__cmd.TILE_COUNTERS = 0

  def assignA(self,tileNumber):
    """\brief assignA() member function
    
    Assign the 'A' tile counter to watch a particular tile
    Immediately after counter assignment, both counters are reset.
    """
    if tileNumber < TrgObject.TILE_NUMBER_MIN or \
       tileNumber > TrgObject.TILE_NUMBER_MAX:
      raise IndexError, "tileNumber is out of range"

    self.__cmd.TILE_0 = ( tileNumber )
    self.reset()

  def assignB(self, tileNumber):
    """\brief assignB() member function
    
    Assign the 'B' tile counter to watch a particular tile
    Immediately after counter assignment, both counters are reset.
    """
    if tileNumber < TrgObject.TILE_NUMBER_MIN or \
       tileNumber > TrgObject.TILE_NUMBER_MAX:
      raise IndexError, "tileNumber is out of range"

    self.__cmd.TILE_1 = ( tileNumber )
    self.reset()

  def assignAB(self, a, b):
    """\brief assignAB() member function
    
    Assign both the 'A' and the'B' tile counters to watch two tiles
    Immediately after counter assignment, both counters are reset.
    """
    if a < TrgObject.TILE_NUMBER_MIN or \
       a > TrgObject.TILE_NUMBER_MAX:
      raise IndexError, "tileNumber is out of range"
    if b < TrgObject.TILE_NUMBER_MIN or \
       b > TrgObject.TILE_NUMBER_MAX:
      raise IndexError, "tileNumber is out of range"

    self.__cmd.TILE_0 = ( a & 0x7f )
    self.__cmd.TILE_1 = ( b & 0x7f )
    self.reset()
    
class TrgGemTileStats(TrgTileStats):
  """\brief TrgGemTileStats
  
  This class implements the HW abstraction corresponding to
  figure 64 of the GEM document: LAT-01545 Section 2.5
  """
  def __init__(self,glt):
    """\brief TrgGemTileStats constructor
    """
    TrgTileStats.__init__(self)
    if glt is not None:
      self.__cmd = glt.downGEMST()
    else:
      self.__cmd = None
      
  def A(self):
    return self.__cmd.TILE_COUNTERS & 0xffff
    
  def B(self):
    return ( self.__cmd.TILE_COUNTERS >> 16 ) & 0xffff
  
# ###########
  
class TrgGemCnoCounters(TrgCnoCounters):
  """ \brief TrgGemCnoCounters
  
  This class implements the HW abstraction corresponding to
  the Cno counter detailed in the GEM document: 
  LAT-01545 Section 2.6
  """
  def __init__(self,glt):
    """\brief TrgGemCnoCounters constructor
    """
    TrgCnoCounters.__init__(self)
    self.__stats = TrgGemCnoStats(glt)
    if glt is not None:
      self.__cmd = glt.downGEMST()
    else:
      self.__cmd = None

  def stats(self):
    return self.__stats

  def reset(self):
    """\brief reset() member function
    
    Reset the Cno counter register
    """
    self.__cmd.CNO_COUNTERS = 0

  def assignA(self,CnoNumber):
    """\brief assignA() member function
    
    Assign the 'A' Cno counter to watch a particular Cno
    Immediately after counter assignment, both counters are reset.
    """
    if CnoNumber < TrgObject.CNO_NUMBER_MIN or \
       CnoNumber > TrgObject.CNO_NUMBER_MAX:
      raise IndexError, "CnoNumber is out of range"

    self.__cmd.CNO_0 = ( CnoNumber )
    self.reset()

  def assignB(self, CnoNumber):
    """\brief assignB() member function
    
    Assign the 'B' Cno counter to watch a particular Cno
    Immediately after counter assignment, both counters are reset.
    """
    if CnoNumber < TrgObject.CNO_NUMBER_MIN or \
       CnoNumber > TrgObject.CNO_NUMBER_MAX:
      raise IndexError, "CnoNumber is out of range"

    self.__cmd.CNO_1 = ( CnoNumber )
    self.reset()

  def assignAB(self, a, b):
    """\brief assignAB() member function
    
    Assign both the 'A' and the'B' Cno counters to watch two Cnos
    Immediately after counter assignment, both counters are reset.
    """
    if a < TrgObject.CNO_NUMBER_MIN or \
       a > TrgObject.CNO_NUMBER_MAX:
      raise IndexError, "CnoNumber is out of range"
    if b < TrgObject.CNO_NUMBER_MIN or \
       b > TrgObject.CNO_NUMBER_MAX:
      raise IndexError, "CnoNumber is out of range"

    self.__cmd.CNO_0 = ( a & 0xf )
    self.__cmd.CNO_1 = ( b & 0xf )
    self.reset()
    
class TrgGemCnoStats(TrgCnoStats):
  """\brief TrgGemCnoStats
  
  This class implements the HW abstraction corresponding to
  figure 64 of the GEM document: LAT-01545 Section 2.5
  """
  def __init__(self,glt):
    """\brief TrgGemCnoStats constructor
    """
    TrgCnoStats.__init__(self)
    if glt is not None:
      self.__cmd = glt.downGEMST()
    else:
      self.__cmd = None
      
  def A(self):
    return self.__cmd.CNO_COUNTERS & 0xffff
    
  def B(self):
    return ( self.__cmd.CNO_COUNTERS >> 16 ) & 0xffff
  
# ###########
  
class TrgGemCmdCounters(TrgCmdCounters):
  """\brief TrgGemCmdCounters
  
  This class implements the HW abstraction corresponding to
  figure 62 of the GEM document: LAT-01545 Section 2.3.4
  """
  def __init__(self,glt):
    """\brief TrgGemCmdCounters constructor
    """
    TrgCmdCounters.__init__(self)
    self.__stats = TrgGemCmdStats(glt)
    if glt is not None:
      self.__cmd = glt.downGEMC()
    else:
      self.__cmd = None

  def stats(self):
    return self.__stats

  def reset(self):
    """\brief reset() member function
    
    Reset the command/response statistics register
    """
    self.__cmd.CR_STATISTICS = 0
    
class TrgGemCmdStats(TrgCmdStats):
  """\brief TrgGemCmdStats
  
  This class implements the HW abstraction corresponding to
  figure 62 of the GEM document: LAT-01545 Section 2.3.4
  """
  def __init__(self,glt):
    """\brief TrgGemCmdStats constructor
    """
    TrgCmdStats.__init__(self)
    if glt is not None:
      self.__cmd = glt.downGEMC()
    else:
      self.__cmd = None

  def command(self):
    return ( self.__cmd.CR_STATISTICS >> 16 ) & 0xffff
    
  def response(self):
    return ( self.__cmd.CR_STATISTICS       ) & 0xffff

# ###########
  
class TrgGemEventCounter(TrgEventCounter):
  """\brief TrgGemEventCounter
  
  This class implements the HW abstraction corresponding to
  figure 63 of the GEM document: LAT-01545 Section 2.3.6
  """
  def __init__(self,glt):
    """\brief TrgGemEventCounter constructor
    """
    TrgEventCounter.__init__(self)
    if glt is not None:
      self.__cmd = glt.downGEMC()
    else:
      self.__cmd = None
    
  def stats(self):
    return ( self.__cmd.EVENT_STATISTICS ) & 0xffff
    
  def reset(self):
    """\brief reset() member function
    
    Reset the event statistics register
    """
    self.__cmd.EVENT_STATISTICS = 0

class TrgGemPPSTimer(TrgPPSTimer):
  """\brief TrgGemPPSTimer class definition
  This class HW abstraction corresponding to
  figure 75 of the GEM document: LAT-01545 Section 2.6.4
  """
  def __init__(self,glt):
    """\brief TrgGemPPSTimer constructor
    """
    TrgPPSTimer.__init__(self)
    if glt is not None:
      self.__cmd = glt.downGEMST()
    else:
      self.__cmd = None

  def seconds(self):
    return ( self.__cmd.ONE_PPS >> 25 ) & 0x7f
    
  def timebase(self):
    return ( self.__cmd.ONE_PPS       ) & 0x1ffffff

---