TrgGem.py

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

__facility__ = "Online"
__abstract__ = "GLAST LAT Coincidence based Trigger System Interface classes"
__author__   = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST I&T"
__date__     = "2/14/04"
__version__  = "$Revision: 2.9 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

"""TrgGem: This file implements the hardware register access to the GEM"""

from TrgGemRegisters      import TrgGemRegisters
from TrgGemCounters       import *
from LATTE.database.gGEM  import GGEM

class TrgGem(TrgGemRegisters):
  """\brief Trigger Global Trigger Electronics Module Interface class definition
  This class implements the hardware register access to the GEM
  """
  __SOLICIT_MASK = 0x40

  def __init__(self):
    """\brief TrgGem constructor
    """
    TrgGemRegisters.__init__(self)

    self.__condValue = None
    self.__glt       = None

  def GEM(self, glt = None):
    """\brief GEM function
    \param glt:  a GGEM object
    \return a GGEM object

    This function sets and/or the GGEM hardware implementation used by
    TrgGem.
    """
    if ( glt is not None ):
      if ( not isinstance(glt,GGEM) ):
        raise AssertionError, "the glt object passed is not a GGEM"
      self.__glt = glt
      self.__epuaddr = glt.getEPUaddr()
    return self.__glt

  def __commit(self):
    """\brief Private commit function

    This function commits the configuration defined by this
    TrgGem object to the hardware.  It does *all* the registers.
    """
    gem = self.GEM()

    # set up the counter accesses and reset them
    self.__triggerCounters = TrgGemTriggerCounters(gem)
    self.__tileCounters    = TrgGemTileCounters(gem)
    self.__cnoCounters     = TrgGemCnoCounters(gem)
    self.__cmdCounters     = TrgGemCmdCounters(gem)
    self.__eventCounter    = TrgGemEventCounter(gem)
    self.__ppsTimer        = TrgGemPPSTimer(gem)
    self.__triggerCounters.reset()
    self.__tileCounters.reset()
    self.__cnoCounters.reset()
    self.__cmdCounters.reset()
    self.__eventCounter.reset()

    # Pass the GEM to TrgGemSequence and TrgGemPeriodicCondition objects
    self.sequence()._TrgGemSequence__setGEM(gem)
    self.periodicCondition()._TrgGemPeriodicCondition__setGEM(gem)

    # set all engine destination addresses.
    # Because engines can't have a real HW dependence, this is done by cheating:
    #   replace each instance of the TrgEngineRequest.destination function
    #   with a local private function.
    for engineNo in range(TrgObject.ENGINE_NUMBER_MAX + 1):
      self.engines().engine(engineNo).request().destination = self.__getDestinationFromEPU

    gemw = gem.downGEMW()
    gemw.WINDOW_OPEN_MASK = 0               # all disabled at startup by default

    # print "setting command registers"
    # Command registers (GEMC)
    gemc = gem.downGEMC()
    gemc.CONFIGURATION         = self.configurationRegister()
    # NEVER EVER touch the ADDRESS register.  Ever.  Really.
    gemc.PERIODIC_MODE         = self.periodicModeRegister()
    gemc.PERIODIC_LIMITS       = self.periodicLimitRegister()
    gemc.PERIODIC_RATE         = self.periodicRateRegister()
    # gemc.SEQUENCE              = self.sequenceRegister()   # commented out to set sequence in rcStartRun
    gemc.CR_STATISTICS         = 0    # Always reset statistics
    gemc.EVENT_STATISTICS      = 0    # Always reset statistics

    # print "setting TAM"
    # TAM generator (GEMMG)
    gemmg = gem.downGEMMG()
    if gemmg is None:
      raise RuntimeError, "GEM has no GEMMG"
    regList = gemmg.regs.values()           # get the list of registers
    for reg in regList:
      if reg.size() > 0 and not reg.isDeprecated():
        reg.set(self.templateRegister(reg.id()))

    # print "setting statistics"
    # Statistics registers (GEMST)
    gemst = gem.downGEMST()
    if gemst is None:
      raise RuntimeError, "GEM has no GEMST"
    regList = gemst.regs.values()           # get the list of registers
    for reg in regList:
      if reg.size() > 0 and not reg.isDeprecated():
        reg.set(0)                            # Reset all to zero

    # print "setting scheduler"
    # Scheduler Registers (GEMSC)
    gemsc = gem.downGEMSC()
    if gemsc is None:
      raise RuntimeError, "GEM has no GEMSC"
    regList = gemsc.regs.values()           # get the list of registers
    for reg in regList:
      if reg.size() > 0 and not reg.isDeprecated():
        reg.set(self.lookupTableRegister(reg.id()))

    # print "setting roi"
    # ROI Registers (GEMVG)
    gemvg = gem.downGEMVG()
    if gemvg is None:
      raise RuntimeError, "GEM has no GEMVG"
    regList = gemvg.regs.values()           # get the list of registers
    for reg in regList:
      if reg.size() > 0 and not reg.isDeprecated():
        reg.set(self.roiRegister(reg.id()))

    # print "setting input enables"
    # Input Enable Registers (GEMIE)
    gemie = gem.downGEMIE()
    if gemie is None:
      raise RuntimeError, "GEM has no GEMIE"
    #ST 6/14/05
    #regList = gemie.regs.values()           # get the list of registers
    #for reg in regList:

    # The above two lines have been replaced by the following line to support
    # the older GASUs. This is outlined in JIRA OACD-3 which dictates that to
    # avoid overwriting the TILES_000_013 register, the EXTERNAL register has to
    # be written first. In order for this to happen, a new method attrIter has
    # been added to the Gdb class which allows iterating the attributes in the
    # same order as they are declared in the node's __attrs member. The EXTERNAL
    # register has now been specified as the first register in this list so it
    # is guaranteed to be modified first.
    for reg in gemie.attrIter():
      if reg.size() > 0 and not reg.isDeprecated():
        setting = self.__ieRegister(reg.id())  # private function below
        if setting is not None:
          reg.set(setting)

    # print "setting windowing"
    # Window Registers (GEMW)
    gemw = gem.downGEMW()
    if gemw is None:
      raise RuntimeError, "GEM has no GEMW"
    gemw.WINDOW_WIDTH = self.width()
    gemw.WINDOW_OPEN_MASK = 0               # all disabled at startup by default

  def __getDestinationFromEPU(self):
    return self.__epuaddr

  def __ieRegister(self, registerNumber):
    # routine that maps the input-enable registers to the register functions
    # 18 input enable registers.
    # 0-3 Tower Inputs
    # 4 acdCNO
    # 5-16 ACD veto enables
    # 17 Tower_busy enable
    if 0 <= registerNumber <= 3:
      return self.towerEnableRegister(registerNumber)
    if 4 == registerNumber:
      return self.cnoEnableRegister()
    if 5 <= registerNumber <= 16:
      return self.tileEnableRegister(registerNumber - 5)
    if 17 == registerNumber:
      try:  # special try block to allow Run Control to override register
        return self.towerBusyEnableRegister()
      except NotImplementedError:
        return None
    if 18 == registerNumber:
      return self.externalEnableRegister()
    # shouldn't get here
    raise IndexError, "registerNumber out of range 0..18"

  ############### Pure virtual function implementation
  def version(self):
    cfg = self.GEM().GEMC.CONFIGURATION
    return ( ( cfg >> 16 ) & 0xffff )

  def solicit(self):
    # transmit the GEM's TRIGGER dataless command
    self.GEM().downGEMC().CMD_TRIGGER = 1

  def enable(self, mask=None):
    if mask is not None:
      outMask = mask
    elif self.conditions() is not None:
      outMask = self.conditions().value()
    else:
      raise AssertionError, "Attempting to enable a TrgConditionsValue of None"
    self.GEM().downGEMW().WINDOW_OPEN_MASK = outMask

  def disable(self):
    self.GEM().downGEMW().WINDOW_OPEN_MASK = 0

  def triggerCounters(self):
    return self.__triggerCounters

  def tileCounters(self):
    return self.__tileCounters

  def cnoCounters(self):
    return self.__cnoCounters

  def cmdCounters(self):
    return self.__cmdCounters

  def eventCounter(self):
    return self.__eventCounter

  def ppsTimer(self):
    return self.__ppsTimer

  def shut(self, marker):
    """Implementation of the shut function.
    """
    gemw  = self.GEM().GEMW
    gemmg = self.GEM().GEMMG
    gemsc = self.GEM().GEMSC

    #0) disable triggers
    self.disable()

    #1) Replace engine 0 with a marker engine
    from TrgEngine import TrgInjectMarker
    newEngine = TrgInjectMarker(marker)
    newTAM = self._TrgGemRegisters__parseEngine(newEngine)
    oldTAM = gemmg.ENGINE_0
    gemmg.ENGINE_0 = newTAM

    #2) replace contents of all schedulers with solicited with (Engine) 0
    scheduler = ( 0x00000000L )               # Everything's 0!
    regList = gemsc.regs.values()
    oldSched = {}    # dictionary keyed on register names
    for reg in regList:
      oldSched[reg.getName()] = reg.get()
      reg.set(scheduler)

    #3) Change conditions to be solicit only, solicit a trigger and disable
    gemw.WINDOW_OPEN_MASK = TrgGem.__SOLICIT_MASK
    self.solicit()
    self.disable()

    #4) Put the original contents of scheduler 0x40 back, and put the TAM back
    for reg in regList:
      reg.set(oldSched[reg.getName()])

    gemmg.ENGINE_0 = oldTAM

    #5) Put the trigger conditions back
    self.enable()

---