SimpleGasuExample.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.4 $"
__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.TrgConditionsValue import TrgConditionsValue

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

class SimpleGasuExample(TrgUsingTiles):
  """\brief SimpleGASU example interface to GEM
  """
  def __init__(self):
    """\brief SimpleGasuExample constructor
    """
    TrgUsingTiles.__init__(self)
    self.__inputEnables             = SGETrgInputEnables()
    self.__engines                  = SGETrgEngines()
    self.__conditions               = SolicitedCondition()

  # 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):
    """Use ACD as a trigger source.
    """
    return True

# implementaions of user-level trigger classes

class SGETrgInputEnables(NoInputsEnabled):
  """Class SGETrgInputEnables:
     Empty Input enables.
  """
  def __init__(self):
    NoInputsEnabled.__init__(self)
  def towerBusy(self):
    # Use NotImplementedError exception to force TrgGemRegisters to 
    # enable all tower_busy signals by default
    raise NotImplementedError
    pass


# class MiniTowerEnabled(TrgTowerEnables):
#   """ One tower enabled
#   """
#   def __init__(self):
#     TrgTowerEnables.__init__(self)
#     self.__towers = [MiniTower()] + [NullTower()] * 15
#   def tower(self,towerNumber):
#     return self.__towers[towerNumber]
#
# class MiniTower(TrgTower):
#   """ One tower enabled, tracker and calorimeter
#   """
#   def __init__(self):
#     TrgTower.__init__(self)
#     self.__cal = MiniTowerCal()
#     self.__tkr = MiniTowerTkr()
#   def calorimeter(self):
#     return self.__cal
#   def tracker(self):
#     return self.__tkr
#
# class MiniTowerCal(TrgCalorimeter):
#   def __init__(self):
#     TrgCalorimeter.__init__(self)
#   def useHighEnergy(self):
#     return True
#   def useLowEnergy(self):
#     return True
#
# class MiniTowerTkr(TrgTracker):
#   def __init__(self):
#     TrgTracker.__init__(self)
#   def use(self):
#     return True
#

# class AllConditions(TrgConditionsValue):
#   def __init__(self):
#     TrgConditionsValue.__init__(self)
#   def roi(self):
#     return True
#   def calLow(self):
#     return True
#   def calHigh(self):
#     return True
#   def tkr(self):
#     return True
#   def periodic(self):
#     return True
#   def solicited(self):
#     return True
#   def cno(self):
#     return True

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

class SolicitedEngine(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 = SolicitedCondition()
    if conditionsValue & cond.value():
      return True
    return False
  def prescale(self):
    return 0
  def request(self):
    return self.__request

class SolicitedCondition(TrgConditionsValue):
  """ Define a condition where only the solicited trigger is asserted
  """
  def __init__(self):
    TrgConditionsValue.__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

# class PeriodicEngine(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 = PeriodicCondition()
#     if conditionsValue == cond.value():
#       return True
#     return False
#   def prescale(self):
#     return 0
#   def request(self):
#     return self.__request
#
# class PeriodicCondition(TrgConditionsValue):
#   """ Define a condition where only the solicited trigger is asserted
#   """
#   def __init__(self):
#     TrgConditionsValue.__init__(self)
#   def periodic(self):
#     return True
#

---