testAppAcdScalers.py

#!/usr/local/bin/python
#
#                               Copyright 2004
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "Example CAL test application"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2006/07/20 20:53:34 $").split(' ')[1]
__version__  = "$Revision: 1.7 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

import threading
import logging        as     log
from   LATTE.runcontrol.rcTransitions  import rcTransitions
from   LATTE.runcontrol.ArgumentImpl   import ArgumentImpl
import time

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
from LATTE.trigger.TrgConditionsValue import *

import LDF
import LDFdumper as LD

TRUE  = (0 < 1)
FALSE = not TRUE

ASC_CONTRIBUTION = 0x101f2010

#  This class puts up a GUI for inputting a value of some sort.  It is used by
#  the userApplication example to get the number of self triggers to take.
class userArgument(ArgumentImpl):
  "GUI for getting the user to input some sort of value."
  def __init__(self, parent = None, name = None, modal = 0, fl = 0):
    ArgumentImpl.__init__(self, parent, name, modal, fl)
    self.__value = 0
    self.setCaption("Hello world!")

  def OKButtonClicked(self):
    self.__value = int(self.ArgumentList.text().latin1())
    self.close()

  def CancelButtonClicked(self):
    self.__value = None
    self.close()

  def getValue(self, caption):
    self.setCaption(caption)
    self.show()
    self.exec_loop()
    return self.__value

class userArgText(object):
  "Text user interface for getting the user to input some sort of value"
  def __init__(self):
    pass

  def getValue(self, caption):
    return int(raw_input("%s: " % (caption)))


#  Example application implementation.
#  Note that the name of the class must be userApplication.
#  Look at rcTransitions for names of other transition methods that can be used.
class userApplication(rcTransitions):
  "Implmentation class for a user application"
  def __init__(self, rc, userId, debug):
    rcTransitions.__init__(self, rc, userId, debug)
    log.debug("userApplication.__init__()")
    self.__eventSem    = threading.Semaphore(0)
    self.__cmdSynchSem = threading.Semaphore(0)

    self.__lci         = LDF.LATcomponentIterator()
    self.__lconti      = LDBI_LATcontributionIterator_(self.__lci)
    self.__ldbi        = LDF.LATdataBufferIterator(self.__lconti)

  def getName(self):
    return __name__

  def setup(self):
    log.debug("userApplication.setup()")

    if self.rc is None:
      self.__arg = userArgText()
    else:
      self.__arg = self.rc.createGUI(userArgument, self.rc, 'test1', 1)

    # Two choices for the trigger, GEM and MiniGLT
    if self.lat.existsGEM():
      self.trigger( SimpleGasuExample() )
    else:
      self.trigger( MiniGLTExample() )

    self.rc.common().getOCS().evtHandlerSendAcdScalers(1,0)

    # A state transition can be rejected by not returning None
    return None

  def startRun(self):
    log.debug("userApplication.startRun()")

    caption = "Enter number of triggers to take"
    if self.rc is None:
      cnt = self.__arg.getValue(caption)
    else:
      cnt = self.rc.execGUImethod(self.__arg.getValue, caption)

    # The user pressed 'Cancel'
    if cnt is None:  return -1
    self.__cnt = cnt

    # Spawn a thread to synchronize commands with events
    self.__cmdSynchQuit = FALSE

    # A state transition can be rejected by not returning None
    return None

  def stopRun(self):
    log.debug("userApplication.stopRun()")

    self.setCompletionStatus(rcTransitions.COMPL_STATUS_PASSED)
    self.__cmdSynchQuit = TRUE
    self.__eventSem.release()

    # The STOP_RUN transition can not be rejected

  def resume(self):
    log.debug("userApplication.resume()")

    # Issue self trigger to make up for the one that was lost during PAUSE
    self.trigger().solicit()

    return None

  def stop(self):
    log.debug("userApplication.stop()")

    return self.stopRun()

  def teardown(self):
    log.debug("userApplication.teardown()")
    # Allow the C++ object to be deleted
    if self.gui is not None and self.__arg is not None:
      self.__arg.deleteLater()

  def process(self, (status, buffer)):
    "Method called back for each data event taken"
    #log.debug("userApplication.process()")

    evtCli = self.evtCli

    if status != 0:
      if evtCli.isGGLTStatus():
        log.error("GGLT_STATUS=%d %s" % (evtCli.getGGLTStatus(), evtCli.getGGLTStatusStr()))
      elif not evtCli.checkOnlineStatus(status, self.evtCli.PLAYBACK_ERROR):
        log.error("EVENT ERROR= 0x%x %s" % (status, evtCli.getOnlineStatusStr()))
      self.__eventSem.release()
      return
    try:
      # In the future this event may contain additional data
      if evtCli.isSweepEvent():
        print "SWEEP!!!"
        return
    except:
      # Event summary word inaccessible, handle the bad event here
      log.exception("")
      return

    count = self.__ldbi.iterate(buffer, len(buffer))

    self.__eventSem.release()


  #def __commandSynch(self, count):
  def commandSynch(self):
    "Method called by the command synchronization task"
    import time
    trigger  = self.trigger()
    eventSem = self.__eventSem

    # Drain the semaphore release count
    # Handles the case when the stop run release collided with a trigger release
    while eventSem.acquire(0):  pass

    t0  = time.time()

    # Compensate for the extra CMD_SELF_TRIGGER below
    cnt   = 0
    count = self.__cnt

    # Wait for START_RUN to enable triggers
    trigger.waitForMaskEnable()

    while cnt < count and not self.__cmdSynchQuit:
      cnt += 1
      print "solicit"
      trigger.solicit()                 # Issue an internal trigger
      time.sleep(10)

    # Get out of waiting when in suite or standalone mode
    self.sync()

    # execute the GUI functions for stopRun, just in case
    if not self.__cmdSynchQuit and not self.isRunFromSuite():
      if self.rc is not None:
        self.rc.doStop()

  def wait(self):
    self.__cmdSynchSem.acquire()

  def sync(self):
    if __name__ == "__main__" or self.isRunFromSuite():
      self.__cmdSynchSem.release()


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 = MarkerTrgReadout()
  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 MarkerTrgReadout(TrgReadout):
  """\brief MarkerTrgReadout 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.
  Marker is set to 1
  """
  def __init__(self):
    """\brief TrgReadout constructor
    """
    TrgReadout.__init__(self)

  def zeroSuppress(self):    return True
  def marker(self):          return 1


class LDBI_LATcontributionIterator_(LDF.LDBI_LATcontributionIterator):
  """\brief LDBI_LATcontributionIterator implementation

  Reimplements virtual UDF contribution handler from LATcontributionIterator
  This implementation checks if the contribution ID corresponds to a
  ACD Software Counter contribution, and parses it out into summary,
  cno and tile pieces.  If the contribution ID does not match the
  expected ID, an error message is given, and the parser returns -1, an
  error.
  """
  def __init__(self, lci):
    LDF.LDBI_LATcontributionIterator.__init__(self, lci)
  def UDF(self, contrib, nextContrib):
    if contrib.identity().value() == ASC_CONTRIBUTION:
      print "Hey!  I saw an ASC_CONTRIBUTION"
      import Numeric
      buffer = Numeric.fromstring(contrib.rawData(), 'i')

      CNOstart = 16
      GECstart = CNOstart + 24

      JJsummary      = buffer[0:CNOstart]
      JJcnoCounts    = buffer[CNOstart:GECstart]
      JJascHists     = buffer[GECstart:]
      print "JJsummary: ", JJsummary
      # Now something needs to be done with these.

    else:
      msg = "Unexpected LATcontribution id 0x%08x seen in event" % contrib.identity().value()
      log.error(msg)
      return -1

    return 0


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               = FullCondition()

  # 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)


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

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 = MarkerTrgReadout()
  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 FullCondition(TrgConditionsValue):
  """ Define a condition where only the solicited trigger is asserted
  """
  def __init__(self):
    TrgConditionsValue.__init__(self)
  def solicited(self):   return True
  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 cno(self):         return True
  def external(self):    return True

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

---