test_evt_tkr.py

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

"""Test script for taking TKR events
"""
__facility__ = "Online"
__abstract__ = "Test script for TKR"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = ("$Date: 2005/05/17 23:42:18 $").split(' ')[1]
__version__  = "$Revision: 1.8 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from LATTE.client.gOptions import Options
from LATTE.client.gCmdCli  import CmdCli
from LATTE.database.gLAT   import GLAT
from LATTE.database.gXBR   import GXBRD
from LATTE.client.gEvtCli  import EvtCli
from LATTE.database.gGLT   import GGLT
from LATTE.database.gPlumber import Plumber

from LATTE.tests.apps.support.MiniGLTExample import *
from LATTE.tests.apps.support.SimpleGasuExample import *

import gc
import os
import time
import logging as log

lat = None
tem = None

# redefine SolicitedEngine
class ZsupSolicitedEngine(TrgEngine):
  """This class defines an engine which reads out the detector
     whenever there is a solicited trigger.  Zero suppression is on.
     This engine is not prescaled.
  """
  def __init__(self):
    TrgEngine.__init__(self)
    self.__request = ZsupTrgReadout()
  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

def test(cmd=None, debug=0, count=10000, disconnectOnExit=1, parse=1, lowlevel=0):
  global tem, glt
  gc.disable()

  log.getLogger().setLevel(log.DEBUG)

  options = Options(['server', 'schema'],
                    ['fswmsglevel', 'evtdebug'],
                    ['initforce', 'ocsverbose', 'nocommander'])
  try:
    options.parse()
  except Exception, msg:
    options.usage(str(msg))
    return

  if options.fswmsglevel is not None:
    msglevel = int(options.fswmsglevel)
  else:
    msglevel = 3
  verbose = (options.ocsverbose != None)
  force = (options.initforce != None)
  commander = not(options.nocommander != None)

  if cmd == None:
    cmd = CmdCli()
    cmd.connect(options.server)

  if options.evtdebug is not None:
    debug = options.evtdebug
  ec = EvtCli(debug)
  ec.connect(options.server, force)

  lat = GLAT(cmd)
  lat.readSchema(options.schema)

  xbrd = GXBRD(cmd)
  xbrd = xbrd.readSchema(options.schema)

  plumber = Plumber(lat, xbrd)
  plumber.initialize(msglevel, verbose, force, commander)

  lat.applyConfig()

  # Get a TEM instance
  if lat.TEMcnt() == 1:
    tem = lat.TEM[lat.TEM.keys()[0]]
  elif lat.TEMcnt() > 1:
    tem = lat.TEM.all()
  else:
    log.fatal("No TEM(s) found in the schema")
    if disconnectOnExit:
      cmd.disconnect()
    ec.disconnect()
    return -1
    
  try:
    lat.LCB.setEvtEnable(True)
  except Exception, e:
    log.error(e)
    raise    

  # TEM needs to be reset before DATA_MASKS can be set
  #tem.CMD_RESET = 1

  if lat.GEM is not None:
    trigger = SimpleGasuExample()

    trigger.engines().replaceEngine(0,ZsupSolicitedEngine())
    trigger.GEM(lat.GEM)
  else:
    glt = GGLT(cmd)
    glt.initialize()
    trigger = MiniGLTExample()
    trigger.GLT(glt)
  trigger.commit()

  trigger.disable()

  #
  # Configure TEM
  #
  # TEM config reg # set TEM timeout
  #tem.CONFIGURATION = 0

  #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

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

  # enable TKR, disable CAL, no diag #  0x1FF3 for diag
  # only enable GTCC 3
  #tem.DATA_MASKS = 0x0FF3

  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 = 0x03F

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

  trigger.enable()

  cnt=0
  ces=0
  start = time.time()
  for i in range(count):
    cnt=cnt+1
    trigger.solicit()
    if lowlevel==1:
      (header, ec.dat) = ec.read()
    else:
      ec.readEvent()
    if parse:
      ec.setCurrentContribution(ec.TEM0)
      if ec.getContributionStatus() == 0:
        ec.evDumpTKR()
    if cnt % 100 == 0: print cnt
    ces += len(ec.dat)
    #sleep(0.000300)
  end = time.time()
  et = end-start
  if et == 0: et = 0.000001
  print "Finished in %f seconds (%d events/second), average event size is %d" %(et,(cnt/et),(ces/cnt))
  if disconnectOnExit:
    cmd.disconnect()
  ec.disconnect()

#if __name__ == '__main__':
#  test()

# 10/22/04
#   server    : gitot / LCBD / XBRD based with TEM0 attached (Zero-Suppression on).
#   teststand : COLUMBA
#   event size: 96 bytes
#     test():                     939 events/second
#     test(parse=0):             1338 events/second
#     test(lowlevel=1, parse=0): 1580 events/second
# 05/17/05
#   server    : gitot / LCBD / GASU based with TEM0 attached (Zero-Suppression on).
#   teststand : COLUMBA
#   event size: 176 bytes
#     test():                     909 events/second
#     test(parse=0):             1366 events/second
#     test(lowlevel=1, parse=0): 1664 events/second

---