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

import LATTE.copyright_SLAC

# This class uses
from LATTE.trigger.TrgUsingTiles      import TrgUsingTiles
from LATTE.trigger.NullObjects        import NoInputsEnabled
from LATTE.trigger.rcTrgFunctions     import rcTrgEngines
from LATTE.trigger.TrgEngines         import *
from LATTE.trigger.rcTrgMiniGLT       import rcTrgMiniGLT
from LATTE.trigger.TrgMiniGLT         import MiniGLTTrgConditionsValue

"""\brief Interface for Coincidence based Trigger System"""

class MiniGLTExample(rcTrgMiniGLT):
  """\brief MiniTower example interface to MiniGLT
  """
  def __init__(self):
    """\brief AcdTriggerExample constructor
    """
    rcTrgMiniGLT.__init__(self)
    self.__engines      = MiniGLTTrgEngines()
    self.__conditions   = MiniGLTSolicitedCondition()

  def engines(self):
    """\brief Implementation of engines 'pure virtual' method from TrgAbstract
    """
    return self.__engines

  def conditions(self):
    """\brief Implementation of conditions 'pure virtual' method from TrgAbstract
    """
    return self.__conditions

# implementaions of user-level trigger classes
class MiniGLTTrgEngines(rcTrgEngines):
  def __init__(self):
    rcTrgEngines.__init__(self)
    # There are two engines in the MiniGLT.
    # 0) User defined engine
    # 15) Marker engine

    eng = MiniGLTSolicitedEngine()
    self.replaceEngine(0,eng)

class MiniGLTSolicitedEngine(TrgEngine):
  """This class defines an engine which reads out the detector
     whenever there is a solicited trigger.
     This engine is not prescaled.
  """
  def __init__(self):
    TrgEngine.__init__(self)
    self.__request = ZsupTrgReadout()
  def participate(self,conditionsValue):
    # This function relies on the programmer's knowledge that the
    # conditionsValue is a bitfield.
    cond = MiniGLTSolicitedCondition()
    condValue = cond.value()
    if conditionsValue & condValue:
      return True
    return False
  def prescale(self):
    return 0
  def request(self):
    return self.__request

class MiniGLTSolicitedCondition(MiniGLTTrgConditionsValue):
  """ Define a condition where only the CNO trigger is asserted
  """
  def __init__(self):
    MiniGLTTrgConditionsValue.__init__(self)
  def solicited(self):
    return True

class ZsupTrgReadout(TrgReadout):
  """\brief ZsupTrgReadout 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.
  Zero suppression is turned on.
  """
  def __init__(self):
    """\brief TrgReadout constructor
    """
    TrgReadout.__init__(self)

  def zeroSuppress(self):
    return True

---