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

import LATTE.copyright_SLAC

# This class uses
from TrgUsingTiles      import TrgUsingTiles
from TrgMiniGLT         import MiniGLTTrgConditionsValue
from rcTrgMiniGLT       import rcTrgMiniGLT
from rcTrgFunctions     import rcTrgEngines
from TrgEngines         import TrgEngine
from TrgEngines         import TrgReadout
from NullObjects        import NoInputsEnabled
from TrgConditionsValue import TrgConditionsValue

class rcGEMDefaultTrigger(TrgUsingTiles):
  """\brief rcGEMDefaultTrigger
  """
  def __init__(self):
    """\brief rcGEMDefaultTrigger constructor
    """
    TrgUsingTiles.__init__(self)
    self.__inputEnables             = NoInputsEnabled()
    self.__engines                  = rcGEMTrgEngines()
    self.__conditions               = rcSolicitedCondition()

  # Pure Virtual function implementation
  def conditions(self):
    return self.__conditions

  def coincidences(self):
    """\brief Implementation of coincdences 'pure virtual' method from TrgUsingTiles
    """
    # it just so happens that the roi is exactly the same as the coincidences object
    return self.roi()

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

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

  def useAcdAsTrigger(self):
    """Don't use ACD as a trigger source.
    """
    return False

  def sweepOnShut(self):
    return False

  def shut(self, sweepEvent=None, progress=None):
    pass

class rcMiniGLTDefaultTrigger(rcTrgMiniGLT):
  """\brief rcMiniGLTDefaultTrigger
  """
  def __init__(self):
    rcTrgMiniGLT.__init__(self)
    self.__engines      = rcMiniGLTTrgEngines()
    self.__conditions   = rcMiniGLTSolicitedCondition()

  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

  def sweepOnShut(self):
    return False

  def shut(self, sweepEvent=None, progress=None):
    pass

# implementaions of user-level trigger classes

class rcGEMTrgEngines(rcTrgEngines):
  """Class rcGEMTrgEngines:
     Initialize the trigger engines list class.
  """
  def __init__(self):
    rcTrgEngines.__init__(self)
    eng1 = rcSolicitedEngine()
    self.replaceEngine(0,eng1)

class rcSolicitedEngine(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 = TrgReadout()
  def participate(self,conditionsValue):
    # This function relies on the programmer's knowledge that the
    # conditionsValue is a bitfield.
    cond = rcSolicitedCondition()
    if conditionsValue & cond.value():
      return True
    return False
  def prescale(self):
    return 0
  def request(self):
    return self.__request

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

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

class rcMiniGLTSolicitedEngine(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 = TrgReadout()
  def participate(self,conditionsValue):
    # This function relies on the programmer's knowledge that the
    # conditionsValue is a bitfield.
    cond = rcMiniGLTSolicitedCondition()
    condValue = cond.value()
    if conditionsValue & condValue:
      return True
    return False
  def prescale(self):
    return 0
  def request(self):
    return self.__request

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

---