latte2latcXML.py

Go to the documentation of this file.

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

__facility__ = "Online"
__abstract__ = "LATTE to LATC XML converter"
__author__  = "Jim Panetta <panetta@slac.stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2006/04/21 14:13:40 $").split(' ')[1]
__version__ = "$Revision: 1.17 $"
__release__  = "$Name: HEAD $"
__credits__ = "SLAC"

import LICOS.copyright_SLAC

import         os, time, sys, types, re
from           ConfigParser import *

from xml.dom         import Node
from Ft.Xml.Domlette import NonvalidatingReader, PrettyPrint, implementation
from Ft.Lib          import Uri
from Ft.Xml          import EMPTY_NAMESPACE


import         Numeric
# import         scipy.stats.stats as stats
import         logging
import         LICOS.util.gOptions as gOptions
from           LICOS.lib.LATconstants import *


tccSide = ['+x','+x','+y','+y','-x','-x','-y','-y','all']
tccDirection = ['lo','hi','hi','lo','hi','lo','lo','hi','hilo']
#Hierarchial list of BCAST components for BCAST document generation purposes

LATC_BCAST_DICT = {'TEM': {'CCC': {'CRC': {'CFE': None}},
                           'TCC': {'TRC': None },
                           'SPT': {'TFE': {'TDC': None}},
                           'TIC': None},
                   'AEM': {'ARC': {'AFE': None}},
                   'GEM': {'TAM': None,
                           'SCH': None,
                           'ROI': None,
                           'TIE': None,
                           'WIN': None,
                           'AOC': None}
                  }

# Default configuration files
LATTE2LATC_CONFIG   = os.path.join(ONLINE_ROOT, "LICOS/tools/LATc/L52LATc.cfg")
LATCREGATTR_CONFIG  = os.path.join(ONLINE_ROOT, "LICOS/tools/LATc/regAttrDef.cfg")

# Default namespace for all XML files used by LATTE.
# This currently has to be None or '' since we do not
# currently qualify tags and attributes with a namespace.
LAT_NAMESPACE = EMPTY_NAMESPACE

##########################################################################################
##
## \class latte2latcXML
##
## \brief Converts LATTE schema into LATC input .xml format.
##
## This application accepts LATTE schema in .xml or
## in the <i> \%CAL_ROOT\% </i> root directory.
##
## The following actions are performed: \n
##    -# Copy the file <i> \%CAL_ROOT%\\setup\\Configurations\\runId.cfg.template </i> to
##       <i> \%ONLINE_ROOT\%\\LATTE\\start\\runId.cfg </i>
##    -# Copy the file <i> \%CAL_ROOT%\\setup\\Configurations\\runControl.cfg.template to </i>
##       <i> \%ONLINE_ROOT\%\\LATTE\\start\\runControl.cfg </i>
##    -# Queries the user for the name of the test unit name (e.g. FM101).
##    -# Creates a subdirectory <i> \%CAL_ROOT\%\<Test_Unit> </i>
##    -# Creates the <i> \%CAL_ROOT\%\\Configurations </i> subdirectory
##    -# Queries the user for the test setup parameters such as test site, test phase, etc.
##    -# Creates the test configuration files in <i> \%CAL_ROOT\%\\Configurations </i> and
##       <i> \%CAL_ROOT\%\<Test_Unit>\\Configurations </i> from the template files in
##       <i> \%CAL_ROOT\%\\setup\\Configurations </i>
##    -# Runs the calDoc utility to generate the calorimeter API documentation files
##
##########################################################################################


class latte2latcXML(object):
  def __init__(self, configMap, regAttrDef, logLevel = logging.WARN, trace = False):
    """
    \brief latte2latcXML constructor.

    \param configMap The name of the configuration file mapping LATTE register names to LATC names.
    \param regAttrDef The name of the configuration file defining broadcast components and their registers.
    \param logLevel Logger level.
    \param trace Module execution trace enable flag
    """

    self.__map = ConfigParser()
    self.__map.read(configMap)
    self.__attrDef = ConfigParser()
    self.__attrDef.read(regAttrDef)

    self.__currentTCCid = -1
    self.__currentTRCid = -1
    self.__latteInputType = 'GLAT object'
    self.__latteInputFile ='NA'
    self.__latteCfgName = ''
    self.__latteCfgVersion = ''

    self.__bcastFlag = False
    self.__log = logging.getLogger()
    self.setLogLevel(logLevel)
    self.setTrace(trace)
    self.__latcInputType = 'GLATC object'
    self.__latcInputFile ='NA'
    self.__latcDOM = {}

    self.__convertDate = time.strftime("%a %b %d, %Y %H:%M:%S GMT", time.gmtime())
    try:
      self.__convertPC = os.environ['COMPUTERNAME']
    except:
      self.__convertPC = "UNKNOWN"
    try:
      self.__convertUser = os.environ['USERNAME']
    except:
      self.__convertUser = "UNKNOWN"

    # masks: allow to mask the snapshot value for LATc
    self.__maskDict = {}
    for register in self.__attrDef.options('MASKS'):
      self.__maskDict[register]=int(self.__attrDef.get('MASKS',register),0)

  def __trace(self,prefix, n = 0):
    """
    \brief latte2latcXML module execution trace routine.

    \param prefix Execution message prefix string.
    \param n Stack level, 0 = top level.
    """
    if self.__traceFlag:
      from traceback import extract_stack
      stack = extract_stack()
#      return stack[-n-2][2]
      print prefix + stack[-n-2][2]

  def setLogLevel(self, logLevel):
    """
    \brief logger level setting method.

    \param logLevel Log Level(DEBUG/WARN/INFO...).
    """
    self.__log.setLevel(logLevel)

  def setTrace(self, state):
    """
    \brief Module execution trace enable/disable setting.

    \param state Trace state (True/False).
    """
    self.__traceFlag = state

  def readLatteXML(self, file):
    """
    \brief LATTE schema/config xml parser (returns LATTE gLat object).

    \param file LATTE schema/config xml file name.
    """
    file_uri = Uri.OsPathToUri(file, attemptAbsolute=1)
    latteDOC = NonvalidatingReader.parseUri(file_uri)

    gLat = self.getGLAT(latteDOC.documentElement)
    self.__latteInputType = 'Schema File'
    self.__latteInputFile = file
    return gLat

  def readLatcXML(self, file):
    """
    \brief LATC config xml parser (returns gLatc object).

    \param file LATC config xml file name.
    """
    file_uri = Uri.OsPathToUri(file, attemptAbsolute=1)
    latcDOC = NonvalidatingReader.parseUri(file_uri)

    self.__latcInputType = 'broadcast config File'
    self.__latcInputFile = file
    return latcDOC

  def __seedLists(self):
    """! Seed the list of lists, keyed on the broadcast section.
         Some lists aren't used for a particular mode of operation
    """
    aDef = self.__attrDef
    cMap = self.__map
    self.__lb = {}
    self.__lb['BCAST'] = []
    self.__bcastSections = cMap.get('SETUP','bcast').split(',')
    self.__bcastSections = [ self.__bcastSections[i].strip() for i in range(len(self.__bcastSections)) ]

    self.__nbcastSections = cMap.get('SETUP','nobcast').split(',')
    self.__nbcastSections = [ self.__nbcastSections[i].strip() for i in range(len(self.__nbcastSections)) ]

    for section in self.__bcastSections:
      lbName = cMap.get('nodes', section)

      # in place strip of register lists
      regList = aDef.get(section, 'regList').split(',')
      regList = [ regList[i].strip() for i in range(len(regList)) ]
      latcRegList = aDef.get(section, 'latcregList').split(',')
      #latcRegList = [ latcRegList[i].strip().lower() for i in range(len(latcRegList)) ]
      latcRegList = [ latcRegList[i].strip() for i in range(len(latcRegList)) ]

      self.__lb[lbName] = {}
      regs = []
      for option in cMap.options(section):
        #regs.append(cMap.get(section,option).lower())
        regs.append(cMap.get(section,option))
      self.__lb[lbName]['regs'] = regs
      self.__lb[lbName]['stats'] = {}
      self.__lb['BCAST'].append(lbName)

    for section in self.__nbcastSections:
      lbName = cMap.get('nodes', section)
      self.__lb[lbName] = {}
      regs = []
      for option in cMap.options(section):
        #regs.append(cMap.get(section,option).lower())
        regs.append(cMap.get(section,option))
      self.__lb[lbName]['regs'] = regs
      self.__lb[lbName]['stats'] = {}

    self.__lb['SPT'] = {}
    self.__lb['SPT']['regs'] = ['low', 'high']
    self.__lb['SPT']['stats'] = {}
    self.__lb['TDC'] = {}
    self.__lb['TDC']['regs'] = ['tfe_dac']
    self.__lb['TDC']['stats'] = {}
    self.__lb['TFE']['regs'].remove('tfe_dac')
    self.__lb['BCAST'].append('SPT')
    self.__lb['BCAST'].append('TDC')

    
  def computeNodeModes(self, gLatc):
    """! \brief Computes broadcast nodes from a starting glatc block
    """
    self.__trace('entering ')

    self.__seedLists()
    for child in self.__getChildNodes(gLatc):
      self.__buildNodeStats(child)

    for key in self.__lb.keys():
      if key == 'BCAST': continue
      maxRate = 0
      maxSettings = None
      total = 0
      for settings,rate in self.__lb[key]['stats'].items():
        total += rate
        if rate > maxRate:
          maxRate = rate
          maxSettings = settings
      if key == 'SPT':  # special logic for broadcasting Splits
        maxLow = 0
        maxHigh = 0
        lowSet = None
        hiSet  = None
        lowSpot = self.__lb[key]['regs'].index('low')
        hiSpot  = self.__lb[key]['regs'].index('high')
        for settings, rate in self.__lb[key]['stats'].items():
          if rate > maxLow and settings[lowSpot] is not None:
            maxLow = rate
            lowSet = settings[lowSpot]
          if rate > maxHigh and settings[hiSpot] is not None:
            maxHigh = rate
            hiSet   = settings[hiSpot]
        maxSettings = (lowSet, hiSet)

      self.__lb[key]['max'] = maxSettings


  def __buildNodeStats(self, node, indent=""):
    nodeInBcast = node.nodeName.upper() in self.__lb.keys()
    if nodeInBcast:
      nodeSettings = []
      regs   = self.__lb[node.nodeName.upper()]['regs']
      stats  = self.__lb[node.nodeName.upper()]['stats']
      for reg in regs:
        nodeSettings.append(None)

    for child in self.__getChildNodes(node):
      self.__buildNodeStats(child, indent+"  ")
      if nodeInBcast:
        try:
          cDataNode = self.__getChildNodes(child)[0]
          if cDataNode.nodeType == Node.TEXT_NODE:
            nodeSettings[regs.index(child.nodeName)] = self.__getChildNodes(child)[0].data
        except:
          print child.nodeName, self.__getChildNodes(child)
          print regs
          raise

    if nodeInBcast:
      tns = tuple(nodeSettings)  # needs to be hashable
      if tns in stats.keys():
        stats[tns] += 1
      else:
        stats[tns]  = 1

  def buildLatcBcast(self):
    latcDOM = self.getLatcDOM('bcast')

    self.addBcastNode(latcDOM, latcDOM.documentElement, LATC_BCAST_DICT)
    # fiddle with the node to get AOC right
    latcDOM = self.convertAOCNode(latcDOM)
    return latcDOM

  def convertAOCNode(self,bcastNode):
    # move GEM.AOC.periodic_rate to GEM.periodic_rate
    # move GEM.AOC.configuration to GEM.configuration
    # move GEM.WIN.window_open_mask to GEM.AOC.window_open_mask
    womNode = None
    for c1 in self.__getChildNodes(bcastNode):
      for c2 in self.__getChildNodes(c1):
        if c2.nodeName=='GEM':
          for c3 in self.__getChildNodes(c2):
            if c3.nodeName=='WIN':
              for c4 in self.__getChildNodes(c3):
                print "WIN node:",c4.nodeName
                if c4.nodeName=='window_open_mask':
                  womNode = c4
                  c3.removeChild(c4)
          for c3 in self.__getChildNodes(c2):
            if c3.nodeName=='AOC':
              for c4 in self.__getChildNodes(c3):
                if c4.nodeName=='periodic_rate' or c4.nodeName=='configuration':
                  c3.removeChild(c4)
                  c2.appendChild(c4)
              if womNode is not None:
                c3.appendChild(womNode)
    return bcastNode
    
  def addBcastNode( self, doc, parent, nodeDict):
    nodeList = nodeDict.items()

    for n in nodeList:
      nodeName = n[0]
      node = createElement(doc,nodeName)
      nodeInBcast = node.nodeName.upper() in self.__lb['BCAST']

      if nodeInBcast and nodeName <> 'TDC':
        setAttribute(node, 'ID', 'BCAST')
      newNode = parent.appendChild(node)
      lbNode = self.__lb[nodeName]
      for i in range(len(lbNode['regs'])):
        childNodeName = lbNode['regs'][i]
        childNodeValue = lbNode['max'][i]
        childNode = createElement(doc, childNodeName)
        try:
          childNode.appendChild(doc.createTextNode(childNodeValue))
        except:
          print childNodeValue, type(childNodeValue), childNode
          raise
        newNode.appendChild(childNode)
      newNodeDict = n[1]
      # print newNodeDict
      if newNodeDict is not None:
        self.addBcastNode(doc, newNode, newNodeDict)
        pass

  def purgeBcast(self, gLatcRaw, gLatcBcast):

    raw = gLatcRaw.documentElement
    bcast = gLatcBcast.documentElement

    self.purgeBcastNodes( raw, bcast)

    return gLatcRaw

  def purgeBcastNodes(self, raw, bcast):

    for childRaw in self.__getChildNodes(raw):
      childBcast = self.__findBcastChild(childRaw.nodeName, bcast)
      if childRaw.nodeName.upper() in self.__lb.keys():
        self.purgeBcastNodes( childRaw, childBcast)
        #print childBcast, childRaw, self.__isNodeContentsBcast(childRaw, childBcast)
        if self.__isNodeContentsBcast(childRaw, childBcast):
          # print 'Removing', childRaw
          self.__killDataChildren(childRaw)

  def __findBcastChild(self, name, bcastNode):
    for child in self.__getChildNodes(bcastNode):
      if child.nodeName.lower() == name.lower():
        return child
    return None

  def __isNodeContentsBcast(self, node, bcast):
    allChildren = True
    for child in self.__getChildNodes(node):
      bcastChild = self.__findBcastChild(child.nodeName,bcast)
      if bcastChild is not None and len(self.__getChildNodes(child)) > 0:
        try:
          cDataNode = self.__getChildNodes(child)[0]
          cbcDataNode = self.__getChildNodes(bcastChild)[0]
        except:
          print child
          raise
        if cDataNode.nodeType == Node.TEXT_NODE:
          if not cDataNode.data == cbcDataNode.data:
            allChildren = False
      else:
        print "\nfound no bcast:", node, bcast, child, len(self.__getChildNodes(child))
        allChildren = False
    return allChildren

  def __killDataChildren(self, node):
    for child in self.__getChildNodes(node):
      cDataNode = self.__getChildNodes(child)[0]
      if cDataNode.nodeType == Node.TEXT_NODE:
        node.removeChild(child)
    if not(node.hasChildNodes()):
      par = node.parentNode
      par.removeChild(node)


  def writeLatcXML(self, id, file = 'latc.xml',path=None):
    """
    \brief Write a LATC .xml file given a LATC document in miniDOM format.

    \param latcDOM LATC document in miniDOM format
    \param file LATC .xml output file name or open file object.
    """
    # special modifications to LATc from snapshot values
    doc = self.__latcDOM[id].documentElement
    # LHM convert the TDC.tfe_dac to fields
    self.convertTfeDacToFields(doc,self.__latcDOM[id])
    
    if type(file) == str:
      fileName = file
      if path is not None:
        fileName = os.path.join(path,file)
      f = open(fileName, 'w')
    else:              # already opened file
      f = file
    f.write('<?xml version="1.0" ?>\n')
    PrettyPrint(doc,f)

    if id=='bcast':
      # need to revert to the original form...
      self.convertTfeFieldsToDac(doc,self.__latcDOM[id])
      
  def convertTfeDacToFields(self,node,doc):
    if str(node.nodeName)=='tfe_dac':
      # if child is text element (no fields) remove it and add fields
      children = self.__getChildNodes(node)
      if len(children)==1 and children[0].nodeType == Node.TEXT_NODE:
        child=children[0]
        value = self.intValue(str(child.nodeValue))
        # take the value and fieldify it. Fields are 'threshold' and 'injection'
        # calibration is bits 13-7, threshold is 6-0
        threshold=0x0
        calibration=0x0
        for bit in range(7):
          calShift = 13-bit
          thrShift = 6-bit
          if value&(0x1<<calShift):
            calibration |= 0x1<<bit
          if value&(0x1<<thrShift):
            threshold   |= 0x1<<bit          
            #print "threshold, calibration:",hex(value),threshold,calibration
        node.removeChild(child)
        thrNode = createElement(doc, 'threshold')
        thrNode.appendChild(doc.createTextNode("0x%x"%(threshold)))
        calNode = createElement(doc, 'injection')
        calNode.appendChild(doc.createTextNode("0x%x"%(calibration)))
        node.appendChild(thrNode)
        node.appendChild(calNode)
    else:
      for child in self.__getChildNodes(node):
        self.convertTfeDacToFields(child,doc)
        
  def convertTfeFieldsToDac(self,node,doc):
    if str(node.nodeName)=='tfe_dac':
      # if child is text element (no fields) remove it and add fields
      children = self.__getChildNodes(node)
      if len(children)==2: # we have threshold and injection
        payload = 0x0
        for child in children:
          value = self.intValue(str(self.__getChildNodes(child)[0].data))
          if str(child.nodeName)=='threshold':
            offset=0
            value1=value
          elif str(child.nodeName)=='injection':
            offset=7
            value2=value
          else:
            raise
          node.removeChild(child)
          for bit in range(7):
            if value&(0x1<<bit):
              payloadbit=(6-bit)+offset
              payload|=0x1<<payloadbit
        node.appendChild(doc.createTextNode("0x%x"%(payload)))
        #print "reconverting, ",value1,value2,payload
    else:
      for child in self.__getChildNodes(node):
        self.convertTfeFieldsToDac(child,doc)
        
  # returns an integer value from a string
  def intValue(self,strValue):
    # quick helper function to deal with hex literals
    # first see if it seems to be a reasonable format.
    if type(strValue)==type(0): # it's already an integer
      return strValue
    strValue = strValue.strip().lower()
    intPattern = re.compile('^(0x)?[0-9,a-f]+$')
    intMatch = intPattern.search(strValue)
    if intMatch:
      if strValue[0:2]=='0x':
        intValue = int(strValue,16)
      else:
        intValue = int(strValue)
      return intValue

  def getLatcDOM(self, id='base'):
    """!\brief Return the DOM corresponding to \a id creating it if necessary.

    \param id The id that identifies the LATc DOM

    \return LATc DOM
    """
    if id in self.__latcDOM:
      return self.__latcDOM[id]
    else:
      latcDOM = implementation.createDocument(None,None,None)
      docElem = createElement(latcDOM,"LATC_XML")
      setAttribute(docElem, 'convertDate',self.__convertDate)
      setAttribute(docElem, 'convertUser',self.__convertUser)
      setAttribute(docElem, 'convertPC',self.__convertPC)
      setAttribute(docElem, 'latteInputType',self.__latteInputType)
      setAttribute(docElem, 'latteInputFile',self.__latteInputFile)
      setAttribute(docElem, 'latteCfgName',self.__latteCfgName)
      setAttribute(docElem, 'latteCfgVersion',self.__latteCfgVersion)
      latcDOM.appendChild(docElem)
      self.__latcDOM[id] = latcDOM
      return latcDOM


  def makeLatcDOC(self, gLat, gLatDict = None, bcastFlag = False):
    """
    \brief Generate a LATC .xml formatted document inMemory.

    \param gLat gLat document object.
    \param gLatDict Dictionary of LATTE to LATC register mappings.
    \param bcastFlag Flag indicating whether to check for BCast settings for appropriate components and registers
    """
    # Pull sections out of the map:
    if gLatDict is None:
      gLatItems = self.__map.items('nodes')
      gLatDict = {}
      for ( lat, latc ) in gLatItems:
        gLatDict[lat.upper()] = latc
    latcDOM = self.getLatcDOM()

    for n in self.__getChildNodes(gLat):
      if n.tagName.upper() in gLatDict:
        self.__addChildren(latcDOM, n, latcDOM.documentElement, gLatDict, bcastFlag)

    return latcDOM

  def __addChildren( self, doc, gLatNode, latcNode, gLatDict, bcastFlag):
    """
    \brief Generate a LATC .xml formatted document inMemory.

    \param doc doc LATC document object.
    \param gLatNode Current gLat node object.
    \param latcNode Current LATC node object.
    \param gLatDict Dictionary of LATTE to LATC register mappings.
    \param bcastFlag Flag indicating whether to check for BCast settings for appropriate components and registers
    """
    newNode = latcNode
    #Check for gLat node to LATC conversion candidate
    if gLatNode.tagName.upper() in gLatDict:
      #generate new LATC node from gLat node
      newNode = createElement(doc, gLatDict[gLatNode.tagName.upper()])
      if gLatNode.attributes is not None:
        #Copy node attributes
        for i in range(len(gLatNode.attributes)):
          cNode = cloneAttrNode(doc,gLatNode.attributes.values()[i])
          #cNode = gLatNode.attributes.values()[i].cloneNode(True)
          #if GTCC node, save ID for SPT node generation
          if gLatNode.tagName.upper() == 'GTCC' and cNode.nodeName == 'ID':
            try:
              self.__currentTCCid = int(cNode.nodeValue)
            except:
              #set BCAST identifier
              self.__currentTCCid = 8
          #if GTRC node, save ID for SPT node generation
          if gLatNode.tagName.upper() == 'GTRC' and cNode.nodeName == 'ID':
            try:
              self.__currentTRCid = int(cNode.nodeValue)
            except:
              #set BCAST identifier
              self.__currentTRCid = 24
          setAttributeNode(newNode, cNode)
      newNode = latcNode.appendChild(newNode)
    #acquire appropriate gLat to LATC register mapping dictionary for current component
    localDict = gLatDict
    if gLatNode.tagName.upper() in self.__map.sections():
      localDict = {}
      localItems = self.__map.items(gLatNode.tagName)
      for ( lat, latc ) in localItems:
        localDict[lat.upper()] = latc

    #select BCAST data for this component if appropriate
    if bcastFlag and gLatNode.tagName in self.__bcastSections:
      bcastSection = gLatNode.tagName
    else:
      bcastSection = None
    #If GTRC node, perform special processing (SPT node generation, etc).
    if gLatNode.tagName.upper() == 'GTRC':
      self.__handleGTRCnode(doc, gLatNode, latcNode.parentNode, newNode, gLatDict, localDict, bcastFlag, bcastSection)
    else:
      #process child nodes
      for n in self.__getChildNodes(gLatNode):
        cNodes = self.__getChildNodes(n)
        #Determine if child node is a register setting or another element to decompose
        if len(cNodes) == 1 and cNodes[0].nodeType == Node.TEXT_NODE:
          #register setting
          #For GTFE DAC registers, create psuedo GTDC childnode and put DAC register under it
          if gLatNode.tagName.upper() == 'GTFE' and n.tagName.upper() == 'DAC':
            tdcNode = createElement(doc, 'TDC')
            tdcNode = newNode.appendChild(tdcNode)
            self.__addNode(doc, n,tdcNode,localDict,bcastSection)
          else:
            self.__addNode(doc, n,newNode,localDict,bcastSection)
          pass
        else:
          #decompose element
          self.__addChildren(doc, n, newNode, gLatDict,bcastFlag)
    
  def __handleGTRCnode(self, doc, gLatNode, platcNode, latcNode, gLatDict, localDict, bcastFlag, bcastSection):
    """
    \brief Generate a LATC .xml formatted document inMemory.

    \param doc doc LATC document object.
    \param gLatNode Current gLat node object.
    \param latcNode Current LATC node object.
    \param gLatDict Dictionary of LATTE to LATC register mappings.
    \param bcastFlag Flag indicating whether to check for BCast settings for appropriate components and registers
    """
    #get GTFE count for this GTRC (controller) by looking at CSR register field
    for n in self.__getChildNodes(gLatNode):
      if n.tagName.upper() == 'CSR':
        csr = long(self.__getChildNodes(n)[0].nodeValue,16)
        feCount = (csr >> 7) & 0x1f
    #create pseudo component SPT
    # if one already exists, use it
    # need the node's ID
    if self.__currentTCCid < 8:
      sptId = '%s%d' %(tccSide[self.__currentTCCid],self.__currentTRCid)
    else:
      sptId = 'BCAST'
    newNode = self.findSptChild(platcNode,sptId)
    if newNode is None:
      newNode = createElement(doc, 'SPT')
      cNode = cloneAttrNode(doc,gLatNode.attributes.values()[0])
      #cNode = gLatNode.attributes.values()[0].cloneNode(True)
      #set SPT node's ID
      cNode.value = sptId
      setAttributeNode(newNode, cNode)
      #newNode = platcNode.appendChild(newNode)
      platcNode.appendChild(newNode)
    #Check whether Hi FE controller (note BCAST GTRC can specify both)
    if 'hi' in tccDirection[self.__currentTCCid]:
      #add 'hi" pseudo register to SPT pseudo component
      deafNode = createElement(doc, 'high')
      deafValue = '%d' %(24-feCount)
      sptRange = range(24-feCount,24)
      deafNode.appendChild(doc.createTextNode(deafValue))
      newNode.appendChild(deafNode)
    #Check whether Lo FE controller (note BCAST GTRC can specify both)
    if 'lo' in tccDirection[self.__currentTCCid]:
      #add 'lo" pseudo register to SPT pseudo component
      deafNode = createElement(doc, 'low')
      # workaround for LATC_parser not understanding minus signs.
      if feCount>0:
        deafValue = '%d' %(feCount-1)
      else:
        deafValue = '0xffff'
      sptRange = range(feCount)
      deafNode.appendChild(doc.createTextNode(deafValue))
      newNode.appendChild(deafNode)

    #process GTFE and its child nodes under SPT Node
    for n in self.__getChildNodes(gLatNode):
      cNodes = self.__getChildNodes(n)
      if len(cNodes) == 1 and cNodes[0].nodeType == Node.TEXT_NODE:
        self.__addNode(doc, n,latcNode,localDict, bcastSection)
      else:
        if n.attributes is not None:
          for i in range(len(n.attributes)):
            if n.attributes.values()[i].nodeName == 'ID':
              try:
                if n.attributes.values()[i].nodeValue == 'BCAST' or int(n.attributes.values()[i].nodeValue) in sptRange:
                  self.__addChildren(doc, n, newNode, gLatDict, bcastFlag)
                else:
                  pass
              except:
                pass

  def findSptChild(self,pNode,sptId):
    for child in self.__getChildNodes(pNode):
      if child.tagName.upper() == 'SPT':
        if hasAttribute(child, 'ID') and getAttribute(child, 'ID') == sptId:
          return child
  
  def __addNode(self, doc, gLatNode, latcNode, localDict, bcastSection = None):
    """
    \brief Generate a LATC .xml formatted document inMemory.

    \param doc doc LATC document object.
    \param gLatNode Current gLat node object.
    \param latcNode Current LATC node object.
    \param localDict Dictionary of LATTE to LATC register mappings for current component.
    \param bcastSection BCAST data for this component (None if not a BCAST component)
    """
    tag = gLatNode.tagName.upper()
    cNode = self.__getChildNodes(gLatNode)[0]
    if tag in localDict:
      #If BCAST register and setting equals BCAST value then skip delta setting node
      newNode = createElement(doc, localDict[tag])
      newValue = cNode.nodeValue
      if localDict[tag] in self.__maskDict:
        oldValue = newValue
        newValue = int(newValue,0)&self.__maskDict[localDict[tag]]
        newValue = "0x%x"%(newValue)
      # LHM special change CRC.config to 0xa500
      # LHM removed this for now
      #if tag=='CONFIG':
      if False:
        newValue = self.intValue(newValue) | 0xa500
        newValue = "0x%x"%(newValue)
      newText = doc.createTextNode(newValue)
      newNode.appendChild(newText)
      latcNode.appendChild(newNode)

  def getGLAT(self, node):
    """
    \brief get start of gLat node pointer from inMemory .xml document.

    \param node gLat node pointer.
    """
    gLat = None
    for n in self.__getChildNodes(node):
      if n.tagName.upper() == 'GLAT':
        gLat = n
      #
      if n.tagName.upper() == 'CONFIGURATION':
        if n.attributes is not None:
          for i in range(len(n.attributes)):
            cNode = n.attributes.values()[i]
            if  cNode.nodeName.upper() == 'NAME':
              self.__latteCfgName = cNode.nodeValue
            if  cNode.nodeName.upper() == 'VERSION':
              self.__latteCfgVersion = cNode.nodeValue
    self.__latteInputType = 'Schema Object'
    return gLat

  def getLATC(self, node):
    """!\brief get start of LATC hierarchy from in memory .xml
    """
    return node.documentElement


  def __getChildNodes(self, node):
    """
    \brief get list of child node pointers.

    \param node parent node.
    """
    childNodes = []
    try:
      for n in node.childNodes:
        if (n.nodeType == Node.TEXT_NODE and \
           (n.data[0] == '\n' or n.data[0].strip() == '')) \
          or n.nodeType == Node.COMMENT_NODE:
          pass
        else:
          childNodes.append(n)
    except:
      pass
    return childNodes

  def splitLatcXML(self, latcDOM):
    """!\brief Given a LATc DOM split it into multiple DOMs.

    The split is based on the nodes which have declared registers.
    When the split is made the hierarchy of each split node is preserved.

    \param latcDOM LATc DOM that will be split
    """
    for child in self.__getChildNodes(latcDOM):
      if child.nodeType == Node.ELEMENT_NODE:
        if child.tagName in self.__lb:
          if not self.isEmptyNode(child):
            branch = self.calculateBranch(child)
            self.addSplitNode(child, branch)
        self.splitLatcXML(child)

  def isEmptyNode(self, node):
    """!\brief Check if there are any registers declared under \a node

    \param node Node that is being checked

    \return True if the node does not declare any registers, False otherwise
    """
    childTagNames = [str(child.tagName) for child in self.__getChildNodes(node)]
    for childTagName in childTagNames:
      if childTagName in self.__lb[str(node.tagName)]['regs']:
        return False
    return True

  def addSplitNode(self, splitNode, branch):
    """!\brief Adds a copy of \a splitNode and its registers,
               creating the parents listed in \a branch if necessary.

    \param splitNode
    \param branch    List of parent nodes that need to exist before adding
                     a copy of \a splitNode
    """
    splitDom = self.getLatcDOM(str(splitNode.tagName))
    xNode = splitDom.documentElement
    for pNode in branch:
      spNode = self.findNode(pNode, xNode)
      if spNode is not None:
        xNode = spNode
      else:
        node = createElement(splitDom, pNode.tagName)
        setAttribute(node, 'ID', str(getAttribute(pNode, 'ID')))
        newNode = xNode.appendChild(node)
        xNode = newNode
    node = createElement(splitDom, splitNode.tagName)
    if node.tagName <> 'TDC':
      setAttribute(node, 'ID', str(getAttribute(splitNode, 'ID')))
    xNode.appendChild(node)
    for child in self.__getChildNodes(splitNode):
      tagName = str(child.tagName)
      if tagName in self.__lb[str(splitNode.tagName)]['regs']:
        cNode = createElement(splitDom, tagName)
        node.appendChild(cNode)
        cNode.appendChild(splitDom.createTextNode(child.firstChild.data))
    #PrettyPrint(splitDom, sys.stdout)

  def findNode(self, node, xNode):
    """!\brief Find a LATc node based on its tagName and ID attribute value.

    Go through the children of \a xNode and find if any of them matches
    the tagname and the ID attribute of \a node

    \param node Node to be matched
    \param xNode Parent node of the children searched

    \return Matching child node or None if not found
    """
    for child in self.__getChildNodes(xNode):
      if child.tagName == node.tagName:
        if hasAttribute(child, 'ID') and getAttribute(child, 'ID') == getAttribute(node, 'ID'):
          return child
    return None

  def calculateBranch(self, node):
    """!\brief Calculate a list of parents leading to \a node in the DOM tree.

    Go through the parents of \a node and construct the branch in the form
    of a list (not including \a node itself).

    \param node Node whose parent list is being requested

    \return A list of parents along the branch leading to \a node
    """
    branch = []
    while node.parentNode.tagName != 'LATC_XML':
      branch = [node.parentNode] + branch
      node = node.parentNode
    return branch

  def getDomList(self):
    """!\brief Return a list of DOMs created during processing.

    \return List of DOM ids
    """
    return self.__latcDOM.keys()


def getAttribute(node, attr):
  return node.getAttributeNS(LAT_NAMESPACE, attr)

def hasAttribute(node, attr):
  return node.hasAttributeNS(LAT_NAMESPACE, attr)

def setAttribute(node, attr, value):
  return node.setAttributeNS(LAT_NAMESPACE, attr, value)

def setAttributeNode(node, attr):
  return node.setAttributeNodeNS(attr)

def cloneAttrNode(node,attrNode):
  cNode = node.createAttributeNS(LAT_NAMESPACE,attrNode.nodeName)
  #print dir(cNode)
  #cNode.setValue(attrNode.nodeValue)
  #cNode.appendChild(node.createTextNode(attrNode.nodeValue))
  cNode.nodeValue = attrNode.nodeValue
  return cNode

def createElement(node, elem):
  return node.createElementNS(LAT_NAMESPACE, elem)

def appendChild(node, elem):
  return node.appendChildNS(LAT_NAMESPACE, elem)

def usage(msg):
  print """
Error %s
Usage:  python latte2latcXML.py --i <input snapshot> --o <output stub> [--b <bcast override>] [--s]
""" % msg


if __name__ == '__main__':

  forceBcast = False
  logging.basicConfig()
  options = gOptions.Options(['i','o'],['b'],['s'])
  try:
    options.parse()
  except Exception, msg:
    usage(msg)
    sys.exit()

  latteXML     = options.i
  #latcXML      = options.o
  # try splitting a root directory off the output
  (latcXMLdir,latcXML) = os.path.split(options.o)
  if latcXMLdir == '':
    latcXMLdir = None
  if options.b is not None:
    forceBcast = True
    bcastLatcXML = options.b
  else:
    bcastLatcXML = "bcast_"+latcXML

  configMap = LATTE2LATC_CONFIG
  regAttrDef = LATCREGATTR_CONFIG

  # print "reading LATTE xml"
  converter = latte2latcXML(configMap,regAttrDef)
  gLat = converter.readLatteXML(latteXML)

  gLatcRaw = converter.makeLatcDOC(gLat,bcastFlag=False)

  converter.computeNodeModes(converter.getLATC(gLatcRaw))

  if forceBcast:
    bcast = converter.readLatcXML(bcastLatcXML)
  else:
    bcast = converter.buildLatcBcast()
    if latcXMLdir is not None:
      bcastLatcXML = os.path.join(latcXMLdir,bcastLatcXML)
    bcastLatcXML = open(bcastLatcXML, 'w')
    converter.writeLatcXML(id='bcast', file=bcastLatcXML, path = latcXMLdir)
    bcastLatcXML.close()
    
  purged = converter.purgeBcast(gLatcRaw, bcast)

#  gLatcRaw = converter.readXML('x.xml')
#  converter._latte2latcXML__latcDOM['base'] = gLatcRaw

#  converter._latte2latcXML__seedLists()

  if options.s is not None:
    converter.splitLatcXML(gLatcRaw.documentElement)
    for domId in converter.getDomList():
      if domId not in ('bcast','base','AOC','WIN'):
        (fname, ext) = os.path.splitext(latcXML)
        converter.writeLatcXML(domId, "%s_%s%s" % (fname, domId, ext), path=latcXMLdir)
  else:
    converter.writeLatcXML(id='base', file=latcXML, path=latcXMLdir)

---