testTkrHitFilter.py

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

__facility__ = "Online"
__abstract__ = "Test application to test the TKR hit filter"
__author__   = "R. Claus <Claus@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "1/28/2005"
__version__  = "$Revision: 1.4 $"
__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 support.SimpleGasuExample   import *
from support.MiniGLTExample      import *

#  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("Enter value:")

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


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

  def getValue(self, caption, value = None):
    if value is None:
      ans = raw_input("%s: " % (caption))
      if ans == '':  return None
      return int(ans)
    else:
      ans = raw_input("%s[%s]: " % (caption, str(value)))
      if ans == '':  return value
      return int(ans)

#  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.__cmdSynchSem = threading.Semaphore(0)
    self.__cnt         = 1
    self.__lowThresh   = 10
    self.__highThresh  = 100
    self.__towerMask   = 0x0000ffff
    self.__prescale    = 0xffffffffL

  def getName(self):
    return __name__

  def setup(self):
    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

#  Move to schema configuration
#    # reset the TEM since we are going to modify DATA_MASKS
#    tem.CMD_RESET = 1

#    #
#    # Configure TEM

#    # config TEM TKR calstrobe delay for ~ 5usec
#    tem.TKR_TRGSEQ = 0x3C

#    # enable TKR, no diag #  0x1F00 for diag
#    # make sure we also enable CAL CC 1 since it is required for
#    # proper event data taking
#    # enable GTCC 2 and 3
#    tem.DATA_MASKS = 0x0DF3
#    tem.configuration = 0x00010000L # primary
#    #tem.CONFIGURATION = 0x03010000L # redundant

#    ccc = tem.allCCC()
#    # enable output in our GCCCs
#    # broadcast load of GCCC_REG_CONFIGURATION
#    ccc.CONFIGURATION = 0x80000000L

#    #  disable all GCRCs in all GCCCs via broadcast
#    ccc.LAYER_MASK_0 = 0xFFFFFFFFL
#    ccc.LAYER_MASK_1 = 0xFFFFFFFFL

    tcc = tem.allTCC()

    # broadcast load of GTCC_REG_CONFIGURATION
    # enable controller output and set cable length to 1
    # 0xC0000000 is for one layer
    # 0x80000000 is for two layers
    tcc.CONFIGURATION = 0xC0000000L
    x_tcc = tem.downTCC(0)
    # enable all masks
    tcc.INPUT_MASK = 0x0

    # set maximum event timeout
    tcc.EVENT_TIMEOUTS = 0x0

    #
    # 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):
    caption = "Enter number of triggers to take"
    if self.rc is None:
      cnt = self.__arg.getValue(caption, self.__cnt)
    else:
      cnt = self.rc.execGUImethod(self.__arg.getValue, caption, self.__cnt)

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

    caption = "Enter the tracker hit low threshold"
    if self.rc is None:
      lowThresh = self.__arg.getValue(caption, self.__lowThresh)
    else:
      lowThresh = self.rc.execGUImethod(self.__arg.getValue, caption, self.__lowThresh)
    if lowThresh is None:  return -1    # The user pressed 'Cancel'
    self.__lowThresh = lowThresh

    caption = "Enter the tracker hit high threshold"
    if self.rc is None:
      highThresh = self.__arg.getValue(caption, self.__highThresh)
    else:
      highThresh = self.rc.execGUImethod(self.__arg.getValue, caption, self.__highThresh)
    if highThresh is None:  return -1   # The user pressed 'Cancel'
    self.__highThresh = highThresh

    caption = "Enter the tower mask"
    if self.rc is None:
      towerMask = self.__arg.getValue(caption, self.__towerMask)
    else:
      towerMask = self.rc.execGUImethod(self.__arg.getValue, caption, self.__towerMask)
    if towerMask is None:  return -1    # The user pressed 'Cancel'
    self.__towerMask = towerMask

    caption = "Enter the prescale value"
    if self.rc is None:
      prescale = self.__arg.getValue(caption, self.__prescale)
    else:
      prescale = self.rc.execGUImethod(self.__arg.getValue, caption, self.__prescale)
    if prescale is None:  return -1     # The user pressed 'Cancel'
    self.__prescale = prescale

    self.rc.common().getOCS().evtHandlerSetVerbosity(1)
    self.rc.common().getOCS().evtHandlerFilterTkrHits(lowThresh, towerMask, highThresh, prescale)

    # Spawn a thread to synchronize commands with events
    # This must happen after triggers are enabled
    self.__cmdSynchQuit = False

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

  def stopRun(self):
    self.setCompletionStatus(self.COMPL_STATUS_PASSED)
    self.__cmdSynchQuit = True

    # 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 teardown(self):
    # Allow the C++ object to be deleted
    if self.rc 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"

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

    hits = 0
    for contributor in range(16):       # TEM ids
      if evtCli.setCurrentContribution(contributor) != -1:
        #evtCli.evDumpSummary()
        evtCli.evDumpTKR()
        #evtCli.evDumpTEM_Error()
        #evtCli.evDumpDiagnostic()

        hits += len(evtCli.evt.TKRstrips)
        #for strip in evtCli.evt.TKRstrips:
        #  print strip.ui
        print "TEM %d TKRSTRIPS: %d" % (contributor, len(evtCli.evt.TKRstrips))
      else:
        if False:
          print "*******************************************"
          print "*   NO TEM %2d CONTRIBUTION PRESENT        *" % (contributor)
          print "*******************************************"

    print "Total TKR strip hits =", hits

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

    t0  = time.time()

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

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

    trigger.solicit()                   # Issue an internal trigger

    t1 = trigger.getEnableTime()        # get the last trigger enable time from GLT

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

    t2 = trigger.getTimeStamp()         # Get the last trigger timestamp
    # When we get here the triggers should still be enabled.
    # If the glt.MASK needs to be set through any other means
    # then it needs to be restored to its SETUP value here.

    if t1 is None:
      t1 = t0
    if t2 is None:
      t2 = time.time()
    dT = t2 - t1
    if dT == 0.0:  dT = 0.000001
    log.info("%s processed %d events in %.3f seconds = %.1f events/second" % \
             (self.getName(), self.evtCnt, 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()



# Standalone mode:
if __name__ == "__main__":
  from LATTE.runcontrol.RunControlCommon import RunControlCommon

  rcCommon = RunControlCommon()
  rcCommon.initialize()
  rcCommon.setLoggingLevel("INFO")
  rcCommon.connect()
  ua = userApplication(None, 321, rcCommon)
  ua.rcSetup()
  ua.rcStartRun()
  ua.wait()
  ua.rcStopRun()
  ua.rcTeardown()

---