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

import LATTE.copyright_SLAC


from TrgObject import TrgObject


"""TrgEngines: Interface for the Trigger Engine classes"""


class TrgEngines(TrgObject):
  """\brief Trigger Engines class definition
  A Trigger Engine defines what the Trigger System does when it 
  detects a triggerable condition within the LAT
  """
  def __init__(self):
    """\brief TrgEngines constructor
    """
    pass

  def engine(self, engineNumber):
    """\brief Engine 'pure virtual' method
    Reference into a list of engines.
    \param engineNumber  An integer
    \return A TrgEngine object
    """
    raise NotImplementedError
    pass


class TrgEngine(TrgObject):
  """\brief Trigger Engine class definition
  The user inherits from this class to customize their own Trigger Engines. 
  The user must satisfy the member function 'request', which returns an 
  object of type TrgEngineRequest.
  The user must satisfy the member function 'prescale', which returns an 
  integer.
  """
  def __init__(self):
    """\brief TrgEngine constructor
    """
    pass

  def prescale(self):
    """\brief prescale 'pure virtual' method

    \return An integer
    """
    raise NotImplementedError
    pass

  def request(self):
    """\brief request 'pure virtual' method
    Return the TrgEngineRequest object corresponding to this engine.
    \return A TrgEngineRequest object
    """
    raise NotImplementedError
    pass
    
  def participate(self,conditionsValue):
    """\brief participate 'pure virtual' method
    Determines whether or not this engine participates when a particular
    conditionsValue is satisfied in the GEM.
    \param conditionsValue  An integer
    \return A boolean
    """
    raise NotImplementedError
    pass


class TrgEngineRequest(TrgObject):
  """\brief Trigger Engine Request class definition
  The TrgEngineRequest class is used to specify the parameterization 
  of the Trigger Message associated with a given engine.
  
  See below for concrete examples.
  """
  def __init__(self):
    """\brief TrgEngineRequest constructor
    """
    pass

    
  def fourRange(self):
    """\brief fourRange 'virtual' method
    Return TRUE if the four-range-readout is enabled, else FALSE.
    \return A boolean
    """
    return False

  def zeroSuppress(self):
    """\brief zeroSuppress 'virtual' method
    Return TRUE if the zero-suppression is enabled, else FALSE.
    \return A boolean
    """
    return False

  def destination(self):
    """\brief destination method
     
    \return An integer
    """
    raise NotImplementedError
    pass

  def marker(self, markerValue = 0):
    """\brief marker  method

    \param markerValue  A marker value
    \return An integer
    """
    return 0

  def sequence(self):
    """\brief sequence 'pure virtual' method

    \return An integer
    """
    raise NotImplementedError
    pass

class TrgInjectCharge(TrgEngineRequest):
  """\brief TrgInjectCharge class definition
  
  Directs a module to send to its Front-End Electronics a command sequence 
  which is composed only of the CALSTROBE command. This command will not 
  trigger a readout of the module's Front-End Electronics.  
  """
  def __init__(self):
    """\brief TrgInjectCharge constructor
    """
    TrgEngineRequest.__init__(self)
    
  def sequence(self):
    """\brief sequence() method
    See TrgEngineRequest base class
    """
    return 2

class TrgReadout(TrgEngineRequest):
  """\brief TrgReadout class definition
  
  Directs a module to send to its Front-End Electronics a command sequence 
  which is composed only of the TACK command. This command will trigger 
  a readout of the module's Front-End Electronics.
  """
  def __init__(self):
    """\brief TrgReadout constructor
    """
    TrgEngineRequest.__init__(self)
    
  def sequence(self):
    """\brief sequence() method
    See TrgEngineRequest base class
    """
    return 1

class TrgInjectChargeReadout(TrgEngineRequest):
  """\brief Trigger Inject Charge Readout class definition
  
  Directs a module to send to its Front-End Electronics a command sequence 
  which is composed of a CALSTROBE followed by a TACK command. 
  This sequence will trigger a readout of the module's Front-End Electronics.
  """
  def __init__(self):
    """\brief TrgInjectChargeReadout constructor
    """
    TrgEngineRequest.__init__(self)
    
  def sequence(self):
    """\brief sequence() method
    See TrgEngineRequest base class
    """
    return 3
    
class TrgInjectMarker(TrgEngineRequest):
  """\brief Trigger Inject Marker class definition
  Directs a module to send to its Front-End Electronics a command sequence 
  which is composed of only a TACK command. This sequence will trigger 
  a readout of the module's Front-End Electronics.
  """
  def __init__(self, marker):
    """\brief TrgInjectMarker constructor
    """
    TrgEngineRequest.__init__(self)
    self.__marker = marker
    
  def sequence(self):
    """\brief sequence() method
    See TrgEngineRequest base class
    """
    return 1
    
  def marker(self):
    """\brief marker() method
    See TrgEngineRequest base class
    """
    return self.__marker

---