test_evt_cal.py

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

"""Test script for measuring event taking throughput.
"""
__facility__ = "Online"
__abstract__ = "Test script for CAL"
__author__   = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST I&T/Online"
__date__     = ("$Date: 2005/05/17 23:37:10 $").split(' ')[1]
__version__  = "$Revision: 2.16 $"
__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.client.gEvtCli    import EvtCli
from LATTE.database.gLAT     import GLAT
from LATTE.database.gXBR     import GXBRD
from LATTE.database.gGLT     import GGLT
from LATTE.database.gPlumber import Plumber


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

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.tests.apps.support.SimpleGasuExample import *


tem = None


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 = ZsupTrgInjectChargeReadout()
  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 ZsupTrgInjectChargeReadout(TrgInjectChargeReadout):
  """\brief ZsupTrgReadout 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.
  """
  def __init__(self):
    """\brief TrgReadout constructor
    """
    TrgInjectChargeReadout.__init__(self)

  def zeroSuppress(self):
    return True

# 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    

  # reset the TEM since we are going to modify DATA_MASKS
  #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()

  #glt.disableMask()
  trigger.disable()

  # clear TEM stats reg
  tem.COMMAND_RESPONSE = 0

  # clear TEM status reg
  tem.STATUS = 0

  # enable CAL, disable TKR, no diag #  0x10FF for diag
  #tem.DATA_MASKS = 0x10FF

  # TEM config reg # set TEM timeout
  #tem.CONFIGURATION = 0
  #tem.CAL_TRGSEQ = 0x40

  #status = gTEMread( __GT, temId, TEM_REG_CONFIGURATION, &payload);
  #printf("tem config reg = 0x%08x\n", payload);

  # enable output in our GCCCs
  # broadcast load of GCCC_REG_CONFIGURATION

  #bcast_ccc = tem.allCCC()
  #bcast_ccc.CONFIGURATION = 0x80000000L

  #  disable all GCRCs in all GCCCs via broadcast # GCCC_REG_LAYER_MASK_0, GCCC_REG_LAYER_MASK_1
  #bcast_ccc.LAYER_MASK_0 = 0xFFFFFFFFL
  #bcast_ccc.LAYER_MASK_1 = 0xFFFFFFFFL
  #ccc2 = tem.downCCC(2) # O$GCCC_02
  #ccc2.LAYER_MASK_1 = 0x3BFD3FFFL

  # large timeouts for all GCCCs
  # broadcast load of GCCC_REG_EVENT_TIMEOUTS
  #bcast_ccc.EVENT_TIMEOUTS = 0x0
  #status = gGCCCread( __GT, temId, 1, GCCC_REG_EVENT_TIMEOUTS, &payload);
  #printf("gccc register event timeouts = 0x%08x\n", payload);


#  glt.INTERNAL_TRG = 0

#  glt.DESTINATION = 5
#  glt.MARKER = 0
#  glt.ZERO_SUPPRESS = 1
#  glt.FOUR_RANGE_READOUT = 0
#  glt.TACK = 1
#  glt.CAL_STROBE = 0

  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==1:
      ec.setCurrentContribution(ec.TEM0)
      if ec.getContributionStatus() == 0:
        ec.evDumpCAL_LogAccepts()
        ec.evDumpCAL_Logs()
    #~ #print ""
    #~ #ec.evDumpTKR()
    #~ ec.evDumpTEM_Error()
    #~ ec.evDumpDiagnostic()
    #~ sum = ec.evt.summary
    #~ ec.evDumpSummary()
    if cnt % 100 == 0: print cnt
    ces = 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()

# Benchmark results
# 9/7/04
#   server    : gitot
#   teststand : COLUMBA
#   event size: 80 bytes
#     test():                    1327 events/second
#     test(parse=0):             1491 events/second
#     test(lowlevel=1, parse=0): 1823 events/second
#   server    : localhost
#   teststand : COLUMBA
#   event size: 80 bytes
#     test():                    1272 events/second
#     test(parse=0):             2735 events/second
#     test(lowlevel=1, parse=0): 4384 events/second
# 9/30/04
#   server    : gitot / GASU based with TEM0 attached.
#   teststand : COLUMBA
#   event size: 432 bytes
#     test():                     440 events/second -- Note the slow performance is due to
#                                                   -- increased event size and no zero-suppression
#     test(parse=0):             1221 events/second
#     test(lowlevel=1, parse=0): 1400 events/second
#   server    : gitot / GASU based with TEM0 attached (Zero-Suppression on).
#   teststand : COLUMBA
#   event size: 304 bytes
#     test():                    1035 events/second
#     test(parse=0):             1285 events/second
#     test(lowlevel=1, parse=0): 1485 events/second
# 10/19/04
#   server    : gitot / LCBD / GASU based with TEM0 attached (Zero-Suppression on).
#   teststand : COLUMBA
#   event size: 304 bytes
#     test():                     945 events/second
#     test(parse=0):             1153 events/second
#     test(lowlevel=1, parse=0): 1344 events/second
# 10/22/04
#   server    : gitot / LCBD / XBRD based with TEM0 attached (Zero-Suppression on).
#   teststand : COLUMBA
#   event size: 80 bytes
#     test():                    1084 events/second
#     test(parse=0):             1327 events/second
#     test(lowlevel=1, parse=0): 1576 events/second
# 01/19/05
#   server    : gitot / LCBD / GASU based with TEM0 attached (Zero-Suppression on).
#               phase3 (schema driven configuration)
#   teststand : COLUMBA
#   event size: 304 bytes
#     test():                    1023 events/second
#     test(parse=0):             1301 events/second
#     test(lowlevel=1, parse=0): 1503 events/second
# 05/17/05
#   server    : gitot / LCBD / GASU based with TEM0 attached (Zero-Suppression on).
#               schema: calGasuSchemaPri.xml
#   teststand : COLUMBA
#   event size: 304 bytes
#     test():                    1023 events/second
#     test(parse=0):             1321 events/second
#     test(lowlevel=1, parse=0): 1602 events/second

---