gLAT.py

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

## \namespace gLAT
##
## \brief GLAST LAT record definitions.
##
## \b Contents:
##
##  GLAST LAT functional block hierarchy representation in Python. See the following documents for more info:
##  <p><a href="http://www-glast.slac.stanford.edu/IntegrationTest/ONLINE/docs/TEM.pdf">The Tower Electronics Module (TEM) - Programming ICD specification (LAT-TD-00605-D1)</a>
##  <p><a href="http://www-glast.slac.stanford.edu/IntegrationTest/ONLINE/docs/AEM.pdf">ACD Electronics Module (AEM) - Programming ICD specification (LAT-TD-00639-D1)</a>
##  <p><a href="http://www-glast.slac.stanford.edu/IntegrationTest/ONLINE/docs/EBM.pdf">The Event Builder Module - Programming ICD specification (LAT-TD-01546)</a>
##  <p><a href="http://www-glast.slac.stanford.edu/IntegrationTest/ONLINE/docs/GEM.pdf">The GLT Electronics Module - Programming ICD specification (LAT-TD-01545)</a>
##  <p><a href="http://www-glast.slac.stanford.edu/IntegrationTest/ONLINE/docs/CRU.pdf">The Command/Response Unit - Programming ICD specification (LAT-TD-01547)</a>
##  <p><a href="http://www-glast.slac.stanford.edu/IntegrationTest/ONLINE/docs/PDU.pdf">The Power Distribution Unit - Programming ICD specification (LAT-TD-01543)</a>
##
## \b Overview:
##
##  This module provides classes that are used as the building blocks for the
##  LAT hierarchy. All classes inherit from Gnode class and add their own member
##  methods and functions where necessary. Here is a list of classes defined:
##
##    - GLAT: Root node for the hierarchy
##    - GPDU: Power Distribution Unit
##    - GPDUC: PDU Controller
##    - GPEQ: PDU Environmental Monitors
##    - GTWR: Tower
##    - GTEM: Tower Electronics Module
##    - GCCC: Calorimeter Cable Controller
##    - GCRC: Calorimeter Readout Controller
##    - GCFE: Calorimeter Front-end Controller
##    - GTCC: Tracker Cable Controller
##    - GTRC: Tracker Readout Controller
##    - GTFE: Tracker Front-end Controller
##    - GTIC: Trigger Interface Controller
##    - GAEM: ACD Common Controller
##    - GAEQ: ACD Environmental Monitors
##    - GARC: ACD Readout Controller
##    - GAFE: ACD Front-End Controller
##    - GGLT: Global Trigger
##    - GEBM: Event Builder Module
##    - GEBMC: Event Builder Module Controller
##    - GEBMST: Event Builder Module Statistics
##    - GGEM: GLT Electronics Module
##    - GGEMC: GLT Electronics Module Controller
##    - GGEMMG: GLT Electronics Module TAM generator
##    - GGEMST: GLT Electronics Module Statistics
##    - GGEMSC: GLT Electronics Module Scheduler
##    - GGEMVG: GLT Electronics Module ROI generator
##    - GGEMIE: GLT Electronics Module Input enables
##    - GGEMW: GLT Electronics Module Window
##    - GCRU: Command Response Unit

__facility__ = "Online"
__abstract__ = "GLAST LAT functional block hierarchy"
__author__  = "Selim Tuvi <stuvi@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2006/07/17 18:29:10 $").split(' ')[1]
__version__ = "$Revision: 2.19 $"
__release__  = "$Name: R04-12-00 $"
__credits__ = "SLAC"

import LATTE.copyright_SLAC
import gSchemaConfig
import gDb
import gAttr

from gLCB import GLCB
from gCRU import GCRU
from gEBM import GEBM
from gGEM import GGEM
from gAEM import GAEM
from gPDU import GPDU
from gTEM import GTEM
from gSIU import GSIU
from gEPU import GEPU


# GLAT class
class GLAT(gDb.Gdb):
  """\brief GLAST LAT node Record

  The GLAT node provides access to parity registers and
  event statistics registers.

  Valid Registers:
  - \c parity_latp_cell_header
  - \c parity_latp_cell_body
  - \c parity_tem_cmd_str
  - \c parity_tem_access_desc
  - \c parity_tem_cmd_payload
  - \c stats_failed_events
  - \c stats_failed_event_sends
  - \c stats_valid_events
  - \c stats_discarded_event_sends
  - \c stats_length_mismatch_count
  - \c stats_events_not_sent

  \deprecated
  - \c \b parity_latp_cell_header     Use 'LCB.parity_latp_cell_header' instead
  - \c \b parity_latp_cell_body       Use 'LCB.parity_latp_cell_body' instead
  - \c \b stats_failed_events         Use 'OCS.stats_failed_events' instead
  - \c \b stats_failed_event_sends    Use 'OCS.stats_failed_event_sends' instead
  - \c \b stats_valid_events          Use 'OCS.stats_valid_events' instead
  - \c \b stats_discarded_event_sends Use 'OCS.stats_discarded_event_sends' instead
  - \c \b stats_length_mismatch_count Use 'OCS.stats_length_mismatch_count' instead
  - \c \b stats_events_not_sent       Use 'OCS.stats_events_not_sent' instead

  Event statistics:

  The following statistics registers are initialized
  at the start of each RunControl run:

  - \c stats_failed_events -- Counts events where
  the eventHandler receives a bad status for the event.

  - \c stats_failed_event_sends -- Counts events where
  the socket send failed with an error other than
  EWOULDBLOCK.

  - \c stats_valid_events -- Counts when a valid event
  has been successfully sent to the client.

  - \c stats_discarded_event_sends -- Counts cases when an
  event send failed due to the fact that the send
  returned an EWOULDBLOCK error.

  - \c stats_length_mismatch_count -- Counts cases when
  the length argument passed to the event handler did
  not match the length provided in the event header.

  - \c stats_events_not_sent -- Counts when the event
  mode is set to DONOT_SEND_EVENTS where the incoming
  events will not be forwarded to the client over the
  socket.

  """
  __attrs = [
    # Registers
    gAttr.GattrRegDepr('parity_latp_cell_header',      0, 4), # Deprecated: use gLCB
    gAttr.GattrRegDepr('parity_latp_cell_body',        1, 4), # Deprecated: use gLCB
    gAttr.GattrReg(    'parity_tem_cmd_str',           2, 4),
    gAttr.GattrReg(    'parity_tem_access_desc',       3, 4),
    gAttr.GattrReg(    'parity_tem_cmd_payload',       4, 4),
    gAttr.GattrRegDepr('stats_failed_events',          8, 4), # Deprecated: use gOCS
    gAttr.GattrRegDepr('stats_failed_event_sends',     9, 4), # Deprecated: use gOCS
    gAttr.GattrRegDepr('stats_valid_events',          10, 4), # Deprecated: use gOCS
    gAttr.GattrRegDepr('stats_discarded_event_sends', 11, 4), # Deprecated: use gOCS
    gAttr.GattrRegDepr('stats_length_mismatch_count', 12, 4), # Deprecated: use gOCS
    gAttr.GattrRegDepr('stats_events_not_sent',       13, 4)  # Deprecated: use gOCS
    ]

  def __init__(self, client):
    """\brief Initialize valid registers as Gattrs.

    Assign default values to members
    """
    self.LCB                         = GLCB(client)
    self.CRU                         = None
    self.AEM                         = None
    self.GEM                         = None
    self.EBM                         = None
    self.PDU                         = gDb.Children(self, GPDU)
    self.TEM                         = gDb.Children(self, GTEM)
    self.SIU                         = gDb.Children(self, GSIU)
    self.EPU                         = gDb.Children(self, GEPU)
    self.__schemaComments            = []
    self.__schemaName                = ''
    self.__configComments            = []
    self.__configName                = ''
    self.__configVersion             = ''
    self.__includeFiles              = []
    self.__declarations              = None
    self.__configurations            = {}
    self.__deadChannels              = None
    self.__noisyChannels             = None
    self.__opaque                    = {}
    self.__serialnos                 = {}
    self.__xbrdExists                = False
    self.__excludes                  = {}
    gDb.Gdb.__init__(self, client, None, 0, self.__attrs)

  def read(self, reg):
    return self.cmdrsp('ggLATread', reg, '!I')

  def load(self, reg, value):
    return self.cmdrsp('ggLATload', reg, value)

  def readSchema(self, name):
    self.CRU                         = None
    self.AEM                         = None
    self.GEM                         = None
    self.EBM                         = None
    self.PDU                         = gDb.Children(self, GPDU)
    self.TEM                         = gDb.Children(self, GTEM)
    self.SIU                         = gDb.Children(self, GSIU)
    self.EPU                         = gDb.Children(self, GEPU)
    return gSchemaConfig.readSchema(self, name)

  def writeSchema(self, fileName):
    gSchemaConfig.writeSchema(self, file(fileName, "w+"), snapshotMode=0)

  def writeConfig(self, fileName, seq=None):
    gSchemaConfig.writeConfig(self, file(fileName, "w+"), seq)

  def takeSnapshot(self, stream, fileName,
                   captureGTIC, captureGAEQ,
                   trigger, configName, configVersion):
    return gSchemaConfig.takeSnapshot(self, stream, fileName,
                               captureGTIC, captureGAEQ,
                               trigger, configName, configVersion)

  def readConfig(self, cfgFileName):
    return gSchemaConfig.readConfig(self, cfgFileName)

  def applyConfig(self, seq=None, gxbrd=None):
    gSchemaConfig.applyConfig(self, seq, gxbrd)

  def getSysReg(self, node, regName):
    """\brief Returns the system register value applied.

    The value of the register applied in the configuration and specified by
    \a node and \a regName is returned.

    \return Register value or None
    """
    return gSchemaConfig.getSysReg(self.__declarations, node, regName)

  def downTEM(self, childId):
    """\brief Navigate to the GTEM indicated by \a childId

    \param  childId The id of the child TEM
    \return         a GTEM object instance
    """
    return self.TEM.down(childId)

  def allTEM(self):
    """\brief Navigate to the GTEM broadcast node.

    \return the GTEM broadcast node instance
    """
    return self.TEM.all()

  def downPDU(self, childId):
    """\brief Navigate to the GPDU indicated by \a childId

    \param  childId The id of the child PDU
    \return         a GPDU object instance
    """
    return self.PDU.down(childId)

  def downAEM(self):
    """\brief Navigate to the GAEM

    \return the GAEM object instance
    """
    return self.AEM

  def downGEM(self):
    """\brief Navigate to the GGEM

    \return the GGEM object instance
    """
    return self.GEM

  def downEBM(self):
    """\brief Navigate to the GEBM

    \return the GEBM object instance
    """
    return self.EBM

  def downLCB(self):
    """\brief Navigate to the GLCB

    \return the GLCB object instance
    """
    return self.LCB

  def downCRU(self):
    """\brief Navigate to the GCRU

    \return the GCRU object instance
    """
    return self.CRU

  def TEMcnt(self):
    """\brief Return the TEM count

    \return Current TEM count
    """
    return len(self.TEM)

  def existsTEM(self, temId):
    """\brief Check if the GTEM instance with the id \a temId exists
    in the schema.

    \param  temId TEM id
    \return       1 if it exists, 0 if it doesn't.
    """
    return self.TEM.exists(temId)

  def existsPDU(self, pduId):
    """\brief Check if the GPDU instance with the id \a pduId exists
    in the schema.

    \param  pduId PDU id
    \return       1 if it exists, 0 if it doesn't.
    """
    return self.PDU.exists(pduId)

  def existsAEM(self):
    """\brief Check if the GAEM instance exists in the schema.

    \return 1 if it exists, 0 if it doesn't.
    """
    return self.AEM != None

  def existsGEM(self):
    """\brief Check if the GGEM instance exists in the schema.

    \return 1 if it exists, 0 if it doesn't.
    """
    return self.GEM != None

  def existsEBM(self):
    """\brief Check if the GEBM instance exists in the schema.

    \return 1 if it exists, 0 if it doesn't.
    """
    return self.EBM != None

  def existsCRU(self):
    """\brief Check if the GCRU instance exists in the schema.

    \return 1 if it exists, 0 if it doesn't.
    """
    return self.CRU != None

  def existsLCB(self):
    """\brief Check if the GLCB instance exists in the schema.

    \return 1 if it exists, 0 if it doesn't.
    """
    return self.LCB != None

  def getConfigurations(self):
    """\brief Get list of configurations.

    Return a list of configuration tuples where
    each tuple contains the configDOM, configName and configRelease.

    \return Configuration tuple list.
    """
    return self.__configurations

  def getDeclarations(self):
    """\brief Get list of declarations.

    Return a list of declarations

    \return Declarations.
    """
    return self.__declarations

  def getRules(self):
    """\brief Retrieves the rule dictionary as defined by the
    current schema/configuration.

    \return Dictionary containing Grule objects (or its descendants).
    """
    return self.__declarations['rules']

  def getAllOpaque(self):
    """\brief Return all opaque data.

    \return All opaque data regardless of the node they are
            associated with.
    """
    return self.__opaque

  def getAllSerialNos(self):
    """\brief Return all opaque data.

    \return All serial number data regardless of the node
            they are associated with.
    """
    return self.__serialnos

  def getAllExcludeFlags(self):
    """\brief Return all exclude data.

    \return All exclude data regardless of the node
            they are associated with.
    """
    return self.__excludes

  ##private:

  def __removeTEM(self, temId):
    self.TEM.remove(temId)

  def __addTEM(self, temId):
    return self.TEM.add(temId)

  def __removeSIU(self, temId):
    self.SIU.remove(temId)

  def __addSIU(self, temId):
    return self.SIU.add(temId)

  def __removeEPU(self, temId):
    self.EPU.remove(temId)

  def __addEPU(self, temId):
    return self.EPU.add(temId)

  def __removePDU(self, pduId):
    self.PDU.remove(pduId)

  def __addPDU(self, pduId):
    return self.PDU.add(pduId)

  def __removeAEM(self):
    self.AEM = None

  def __addAEM(self):
    self.AEM = GAEM(self.client(), self)
    return self.AEM

  def __removeEBM(self):
    self.EBM = None

  def __addEBM(self):
    self.EBM = GEBM(self.client(), self)
    return self.EBM

  def __removeGEM(self):
    self.GEM = None

  def __addGEM(self):
    self.GEM = GGEM(self.client(), self)
    return self.GEM

  def __removeCRU(self):
    self.CRU = None

  def __addCRU(self):
    self.CRU = GCRU(self.client(), self)
    return self.CRU

  def xbrdExists(self):
    """\brief Check if a GXBRD node was encountered during readSchema.

    \return Boolean indicating whether a GXBRD node was encountered or not
    """
    return self.__xbrdExists

---