hTestAppEvt.py

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

__facility__ = "Online"
__abstract__ = "Example TKR test application"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/03/31 02:55:06 $").split(' ')[1]
__version__  = "$Revision: 1.6 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC


import threading
import sys

from   LATTE.runcontrol.rcTransitions import rcTransitions
from   LATTE.runcontrol.ArgumentImpl  import ArgumentImpl

from   sihippo       import *
import logging       as     log
import                      time

import LDF

from support.SimpleGasuExample   import *
from support.MiniGLTExample      import *


def _unsigned(arg):
  """\brief Convert an unsigned int argument to an unsigned long

  This funtion exists to help format unsigned ints greater than 0x7fffffff,
  which in Python 2.4 and up will be displayed as signed strings.
  """
  return arg & (2L * sys.maxint + 1)


class myTKRcontributionIterator(LDF.TKRcontributionIterator):
  def __init__(self, hists):
    LDF.TKRcontributionIterator.__init__(self)
    self.__hists = hists

  def strip(self, tower, layerEnd, hit):
    self.__hists[0].addRow([hit])

  def TOT(self, tower, layerEnd, tot):
    self.__hists[1].addRow([tot])

class myLATcomponentIterator(LDF.LATcomponentIterator):
  def __init__(self, hists):
    LDF.LATcomponentIterator.__init__(self)
    self.__tkrIterator = myTKRcontributionIterator(hists)

  def CALcomponent(self, event, calContribution):
    return 0

  def TKRcomponent(self, event, contribution):
    self.__tkrIterator.iterateStrips(event, contribution)
    self.__tkrIterator.iterateTOTs(contribution)

    return 0


#  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 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, gui, userId, debug):
    rcTransitions.__init__(self, gui, userId, debug)
    print "userApplication.__init__()"
    self.__eventSem    = threading.Semaphore(0)
    self.__cmdSynchSem = threading.Semaphore(0)

    self.gui.execGUImethod(self.__initHippo)

    self.__lci         = myLATcomponentIterator(self.__hists)
    self.__ldbi        = LDF.LATdataBufferIterator(self.__lci)


  def getName(self):
    return "hTestAppEvt"

  def setup(self):
    print "userApplication.setup()"

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

    # Get a TEM instance
    if self.lat.TEMcnt() == 1:
      tem = self.lat.TEM[self.lat.TEM.keys()[0]]
    elif self.lat.TEMcnt() > 1:
      tem = self.lat.TEM.all()
    else:
      log.fatal("No TEM(s) found in the schema")
      return -1

    tcc = tem.allTCC()

    #
    # Configure GTRCs
    #

    # our board is connected CC = 2, RC = 0 and CC = 3, RC = 0
    # reset GTRC # required before all triggers

    trc = tcc.allTRC()

    trc.CMD_RESET = 1

    # number of GTFE to readout left
    nGTFEsLeft  = 7
    nGTFEsRight = 0

    # max hits per GTRC # 31 max
    maxHits = 31

    enMask  = 0x6

    dLO = (enMask << 28) | ((nGTFEsRight << 7)& 0xF80) | (maxHits & 0x7F);
    print "dLO=", dLO, hex(dLO)

    # cable controller 2, readout controller 0
    tcc = tem.downTCC(2)
    trc = tcc.downTRC(1)

    trc.CSR = dLO

    dLO = (enMask << 28) | ((nGTFEsLeft << 7)& 0xF80) | (maxHits & 0x7F);
    print "dLO=", dLO, hex(dLO)

    # cable controller 3, readout controller 0
    tcc = tem.downTCC(3)
    trc = tcc.downTRC(1)

    trc.CSR = dLO

    #
    # Configure GTFEs
    #

    tfe = trc.allTFE()
    tfe.TRIG_MASK = 0x0
    tfe.DATA_MASK = 0x0
    tfe.CALIB_MASK = 0x0
    tfe.DAC = 0x00001902
    # configure front ends # all listen to left
    tfe.MODE = 0
    #tfe = trc.downTFE(0)

    # configure default DACs for threshold and calibration
    # Calibration DAC Range and Resolution
    # Low Range (B6=0):  DAC output voltage in mV = 1.57 + 1.53*DAC_Value
    # High Range (B6=1): DAC output voltage in mV = 15.0 + 14.6*DAC_Value
    # Discriminator Threshold DAC Range and Resolution
    # Low Range (B6=0):  DAC output voltage in mV = 4.5 + 4.5*DAC_Value
    # High Range (B6=1): DAC output voltage in mV = 12.9 + 12.9*DAC_Value


    # calRng = 1
    # thrRng = 0
    # calDAC = 60
    # thrDAC = 10

    tfe.DAC = 0x00001952  # based on the above Rng and DAC values

    # enable GTFE for data taking # all channels
    tfe.TRIG_MASK = 0xffffffffffffffff
    tfe.DATA_MASK = 0xffffffffffffffff

    # Cal strobe channels 4 and 48 only
    tfe.CALIB_MASK = 0x0001000000000010

    #~ #Mask of the following Registers
    #~ tfe = trc.downTFE(13)
    #~ tfe.DATA_MASK = 0x0L
    #~ tfe.CALIB_MASK = 0x0L
    #~ tfe.TRIG_MASK = 0x0L

    #~ tfe = trc.downTFE(14)
    #~ tfe.DATA_MASK = 0x0L
    #~ tfe.CALIB_MASK = 0x0L
    #~ tfe.TRIG_MASK = 0x0L

    #~ tfe = trc.downTFE(19)
    #~ #tfe.DATA_MASK = 0x0L
    #~ tfe.CALIB_MASK = 0x0L
    #~ tfe.TRIG_MASK = 0x0L

    #~ tfe = trc.downTFE(20)
    #~ #tfe.DATA_MASK = 0x0L
    #~ tfe.CALIB_MASK = 0x0L
    #~ tfe.TRIG_MASK = 0x0L

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

    # 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.gui is None:
      cnt = self.__arg.getValue(caption)
    else:
      cnt = self.gui.execGUImethod(self.__arg.getValue, caption)
      # Allow the C++ object to be deleted
      self.__arg.deleteLater()

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

    self.gui.execGUImethod(self.__initPlots)
    self.__cmdSynchQuit = False

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

  def stopRun(self):
    self.setCompletionStatus(self.COMPL_STATUS_SUCCESS)
    self.__cmdSynchQuit = True
    self.__eventSem.release()

    # The STOP_RUN transition can not be rejected

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

    return None

  def stop (self):
    return self.stopRun()

  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(): return
    except:
      # Event summary word inaccessible, handle the bad event here
      log.exception("")
      return

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

    self.__hists[2].addRow([evtCli.getEvtSize()])  #event.length()])

    # Get next event triggered
    self.__eventSem.release()


  def commandSynch(self):
    "Method called by the command synchronization task"
    trigger  = self.trigger()
    eventSem = self.__eventSem
    t0  = time.time()
    cnt = 0
    count = self.__cnt

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

    while cnt < count and not self.__cmdSynchQuit:
      cnt = cnt + 1
      trigger.solicit()                 # Issue an internal trigger
      eventSem.acquire()                # Wait for the event to be processed
      time.sleep(.001)

    wc = WindowController.instance()
    canvas = wc.currentCanvas()
    canvas.setIntervalEnabled ( 0 )
    dT = time.time() - t0
    if dT == 0.0:  dT = 0.000001
    print "%s processed %d events in %.3f seconds = %.1f events/second" % \
          (self.getName(), cnt, dT, self.evtCnt/dT)

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

  def __initHippo(self):
    self.__label  = [0, 0, 0]
    self.__label[0] = ['Strip Hits']
    self.__label[1] = ['TOTs']
    self.__label[2] = ['Event Size']
    ntc = NTupleController.instance()
    self.__hists  = [0, 0, 0]
    self.__hists[0] = ntc.createNTuple(1)
    self.__hists[1] = ntc.createNTuple(1)
    self.__hists[2] = ntc.createNTuple(1)
    self.__hists[0].setTitle('TKR Event Strip Readout')
    self.__hists[1].setTitle('TKR Event TOT Readout')
    self.__hists[2].setTitle('Event length')
    self.__hists[0].setLabels(self.__label[0])
    self.__hists[1].setLabels(self.__label[1])
    self.__hists[2].setLabels(self.__label[2])
    if __name__ == "__main__":
##       app = HDApp()
##       canvas = app.canvas()
      app = QApplication ( sys.argv )
      canvas = CanvasWindow()
      canvas.show()
    else:
      wc = WindowController.instance()
      canvas = wc.currentCanvas()
##  already done by main applicaton:    canvas.show()
##     ntuple_list = [0.0]
##     self.__nt.addRow(ntuple_list)
##    self.__nt2.addRow(ntuple_list)

## see new way below
##     hist = Display('Histogram',self.__nt,'Strip Hits')
##     hist2 = Display('Histogram',self.__nt2,'Event

  def __initPlots(self):
    wc = WindowController.instance()
    canvas = wc.currentCanvas()
    canvas.clear()
    self.__hists[0].clear()
    self.__hists[1].clear()
    self.__hists[2].clear()
    dc = DisplayController.instance()
    hist1 = dc.createDisplay ( 'Histogram', self.__hists[0], self.__label[0] )
    hist2 = dc.createDisplay ( 'Histogram', self.__hists[1], self.__label[1] )
    hist3 = dc.createDisplay ( 'Histogram', self.__hists[2], self.__label[2] )
    canvas.addDisplay(hist1)
    canvas.addDisplay(hist2)
    canvas.addDisplay(hist3)
    self.__hists[0].setIntervalCount ( 2000 )
    self.__hists[1].setIntervalCount ( 1000 )
    self.__hists[2].setIntervalCount ( 400 )
    canvas.setIntervalEnabled ( 0 )
    canvas.show()
    canvas.setIntervalEnabled ( 1 )

#Standalone mode:
if __name__ == "__main__":
  import sys
  from qt import *
  from sihippo import *

  ua = userApplication(None, 321, 0)
  ua.rcSetup('../repos/simpleTemSchema.xml')
  ua.rcStartRun()
  ua.wait()
  ua.rcStopRun()
  ua.rcTeardown()
  raw_input("Press any key to end")

# History:
#     $Log: hTestAppEvt.py,v $
#     Revision 1.6  2005/03/31 02:55:06  stuvi
#     Fixed TRCs according to Selim's teststand.
#
#     Revision 1.5  2005/03/30 06:04:33  stuvi
#     Removed configuration settings which should normally come from the schema.
#
#     Revision 1.4  2005/03/21 17:58:11  claus
#     Modified to use the first TEM found in the schema, if only one is there, or
#     broadcast to all TEMs if there are multiple.
#
#     Revision 1.3  2004/10/22 20:32:48  stuvi
#     Fixed log.exception()
#
#     Revision 1.2  2004/08/18 18:00:15  stuvi
#     Updated for LATTE 4.
#     All hippo functions go through the Qt GUI bridge now.
#
#     Revision 1.1  2004/08/07 02:14:33  stuvi
#     no message
#
#     Revision 1.8  2004/07/15 22:58:35  stuvi
#     Added waitForMaskEnable
#
#     Revision 1.7  2004/05/03 21:19:46  stuvi
#     Moved non-Runcontrol scripts to the support directory and modified imports accordingly.
#
#     Revision 1.6  2004/04/17 02:22:17  stuvi
#     Various Hippo related fixes
#     Added teardown() to delete the C++ object for the userArgument
#
#     Revision 1.5  2004/04/08 03:16:44  stuvi
#     Added canvas clearing.
#
#     Revision 1.4  2004/04/08 01:48:42  claus
#     Reworked to work with LDF.
#
#     Revision 1.3  2004/04/07 22:20:51  stuvi
#     no message
#
#     Revision 1.2  2004/03/10 22:24:50  panetta
#     Upgraded trigger interface.
#     Removed dependencies on self.glt.
#
#     Revision 1.1  2004/01/30 04:39:53  claus
#     Test application to histogram data from EBF events.
#     This is not yet working.
#
#     Revision 1.9  2003/01/12 19:45:41  pfkeb
#     Move interval counting to ntuple
#
#     Revision 1.8  2003/01/08 00:22:21  pfkeb
#     New interface to NTupleController
#
#     Revision 1.7  2003/01/06 23:57:21  claus
#     Merged Ric's changes with Paul's
#
#     Revision 1.6  2003/01/05 00:18:50  pfkeb
#     Make use of new HippoDraw features
#
#     Revision 1.5  2002/12/23 19:00:25  pfkeb
#     Add HippoDraw to RunControl
#
#     Revision 1.4  2002/12/19 19:59:52  claus
#     Mods for Hippo
#
#     Revision 1.3  2002/12/11 21:18:07  stuvi
#     Changed glt register assignments to bit field assignments
#
#     Revision 1.2  2002/12/10 02:42:03  stuvi
#     Put the event size plotting outside the tracker strip look
#
#     Revision 1.1  2002/12/10 00:59:16  stuvi
#     Runcontrol example that uses Hippo. Currently it doesn't work in GUI mode.
#
#     Revision 1.4  2002/12/02 17:17:09  claus
#     Added provision to allow application to run stand-alone
#
#     Revision 1.3  2002/11/28 02:02:04  claus
#     Shuffled constructor arguments
#
#     Revision 1.2  2002/11/27 23:49:27  claus
#     Initialize semaphore with zero count
#
#     Revision 1.1  2002/11/27 05:02:48  claus
#     Initial version of Run Control
#

---