test_evt_filters.py

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

"""Test of callbacks in OES
"""
__facility__ = "Online"
__abstract__ = "Test script for event taking modes in FSW"
__author__   = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = ("$Date: 2005/03/17 22:17:12 $").split(' ')[1]
__created__  = "040908"
__version__  = "$Revision: 1.7 $"
__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.gOCS   import GOCS
from LATTE.client.gEvtCli  import EvtCli
from LATTE.database.gXBR   import GXBRD
from LATTE.database.gPlumber import Plumber
from LATTE.tools.taskEngine import TaskEngine

from time import sleep
import time
import os
import gc
import math
import logging as log
import threading

from LATTE.tests.apps.support.SimpleGasuExample import *
from LATTE.trigger.rcTrgFunctions import rcTrgInjectMarker


aem     = None
trigger = None
ocs     = None
task    = None
ec      = None

def test(cmd=None, debug=0, count=10, disconnectOnExit=1):
  global aem, trigger, ec, ocs, task
  gc.disable()
  
  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)
  
  task = TaskEngine("TestEngine")
  task.start()
  
  if cmd == None:
    cmd = CmdCli()
    cmd.connect(options.server)
    
  if options.evtdebug is not None:
    debug = options.evtdebug
  ec = EvtCli(debug)
  ec.setTimeoutEnabled(True)
  ec.connect(options.server, force)
  ec.socket().settimeout(1)
  
  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()
  
  try:
    lat.LCB.setEvtEnable(True)
  except Exception, e:
    log.error(e)
    raise
    
  ocs = GOCS(cmd)
  ocs.evtHandlerSetVerbosity(0xf)

  trigger = SimpleGasuExample()
  trigger.GEM(lat.GEM)
  trigger.commit()
  trigger.enable()

  cnt=0
  start = time.time()
  
  nTest = 1
  
  testEHSendAll(nTest, count);             nTest += 1
  testEHSendErrors(nTest, count);          nTest += 1
  testEHSendNothing(nTest, count);         nTest += 1
  testEHSendPrescale(nTest, count, 0);     nTest += 1
  testEHSendPrescale(nTest, count, 2);     nTest += 1
  testEHSendPrescale(nTest, count, 0);     nTest += 1
  testEHFilterTkrHits(nTest, count, 0x1);  nTest += 1
  testEHSendAcd(nTest, count, 5, 0);       nTest += 1
  testEHSendAcd(nTest, count, 5, 2);       nTest += 1
  testEHSendAcd(nTest, count, 5, 0);       nTest += 1
  testEHSendAll(nTest, count);             nTest += 1
  
  trigger.disable()
  ec.disconnect()
  task.shutdown()

  if disconnectOnExit == 1:
    cmd.disconnect()

def countEvents(count, printSize=False):
  lastEvt = -1
  nSeen = 0
  for i in range(count):
    trigger.solicit()
    try:
      ec.readEvent()
      summary = ec.evt.summary
      # Construct event number
      evtNumber = (summary.evNumber << 2) | (summary.tag)
      nSeen += 1
      lastEvt = evtNumber
      if printSize:
        print "N: %d, Event number %x size = %X, summary=%x" % \
           (nSeen, evtNumber, len(ec.dat), summary.ui)
    except IOError, e:
      pass
      # print e
  return nSeen

def testEHSendErrors(test, count):
  print "test %d:  Take %d events, using evtHandlerSendErrorsOnly" % (test, count)
  trigger.disable()
  ocs.evtHandlerSendErrorsOnly()
  trigger.commit()
  trigger.enable()
  cnt = countEvents(count)
  print "evtHandlerSendErrorsOnly: Sent %d events, saw %d" % (count, cnt)
  if (cnt != 0):
    print "      FAILED"
  else:
    print "      PASSED"

def testEHSendNothing(test, count):
  print "test %d:  Take %d events, using evtHandlerSendNothing" % (test, count)
  trigger.disable()
  ocs.evtHandlerSendNothing()
  trigger.commit()
  trigger.enable()
  cnt = countEvents(count)
  print "evtHandlerSendNothing: Sent %d events, saw %d" % (count, cnt)
  if (cnt != 0):
    print "      FAILED"
  else:
    print "      PASSED"

def testEHSendPrescale(test, count, prescale):
  effPre = prescale+1
  print "test %d:  Take %d events, using evtHandlerSendPrescaled(%d)" % (test, count*effPre, prescale)
  trigger.disable()
  ocs.evtHandlerSendPrescaled(prescale)
  trigger.commit()
  trigger.enable()
  cnt = countEvents(count*effPre)
  print "evtHandlerSendPrescaled(%d): Sent %d events, saw %d" % (prescale, count*effPre, cnt)
  if (cnt != count):
    print "      FAILED, expected %d" % count
  else:
    print "      PASSED"

def testEHFilterTkrHits(test, count, prescale):
  effPre = prescale+1
  print "test %d:  Take %d events, using evtHandlerFilterTkrHits(%d)" % (test, count*effPre, prescale)
  trigger.disable()
  ocs.evtHandlerFilterTkrHits(lowThreshold = 10, highThreshold = 0xffffffffL, prescale=prescale)
  trigger.commit()
  trigger.enable()
  cnt = countEvents(count*effPre)
  print "testEHFilterTkrHits(%d): Sent %d events, saw %d" % (prescale, count*effPre, cnt)
  if (cnt != count):
    print "      FAILED, expected %d" % count
  else:
    print "      PASSED"

def testEHSendAcd(test, count, marker, prescale):
  effPre = prescale+1
  print "test %d:  Take %d events, using evtHandlerSendAcdScalers(%d,%d)" % \
        (test, count*effPre, marker, prescale)
        
  trigger.disable()
  ocs.evtHandlerSendAcdScalers(marker, prescale)
  trigger.commit()
  trigger.enable()
  
  cnt = countEvents(count*effPre)
  evt = threading.Event()
  task.spawn(trigger.shut, evt)
  time.sleep(0.1)
  evt.set()
  
  ec.readEvent()
  datalen = len(ec.dat)
      
  print "evtHandlerSendAcdScalers(%d,%d): Sent %d events, saw %d" % \
        (marker, prescale,count*effPre, cnt)
  if (cnt != count):
    print "      FAILED, expected %d" % count
  elif (datalen < 0x4000):
    print "      FAILED, ASC event size = 0x%X, < 0x4000" % datalen
  else:
    print "      PASSED"
  time.sleep(1)  # let shut() above finish...

def testEHSendAll(test, count):
  print "test %d:  Take %d events, using evtHandlerSendAll:" % (test, count)
  trigger.disable()
  ocs.evtHandlerSendAll()
  trigger.commit()
  trigger.enable()
  cnt = countEvents(count)
  print "evtHandlerSendAll: Sent %d events, saw %d" % (count, cnt)
  if (cnt != count):
    print "      FAILED"
  else:
    print "      PASSED"
  

if __name__ == '__main__':
  test()

---