source: nappy/tags/nappy_pre_refactor_feb2008/nappy/naFile2010.py @ 3313

#   Copyright (C) 2004 CCLRC & NERC( Natural Environment Research Council ).
#   This software may be distributed under the terms of the
#   Q Public License, version 1.0 or later. http://ndg.nerc.ac.uk/public_docs/QPublic_license.txt

"""
naFile2010.py
=============

Container module for NAFile2010 class.

"""

# Imports from python standard library

# Imports from local package
from textParser import *
import naFile
import listManipulator

class NAFile2010(naFile.NAFile):
    """
    Class to read, write and interact with NASA Ames files conforming to the
    File Format Index (FFI) 2010.
    """

    def readHeader(self):
        """
        Reads FFI-specifc header section.
        """        
        self._normalizedX="no"
        self._readCommonHeader()
        self.DX=readItemsFromLine(self.file.readline(), self.NIV, float)
        self.DX.reverse()  # Reverse because C-type array is least-changing first
        self.NX=readItemsFromLine(self.file.readline(), self.NIV-1, int)
        self.NX.reverse()  # Reverse because C-type array is least-changing first
        self.NXDEF=readItemsFromLine(self.file.readline(), self.NIV-1, int)
        self.NXDEF.reverse()  # Reverse because C-type array is least-changing first
        self.X=[]
        for i in range(self.NIV-1):
            self.X.append(readItemsFromUnknownLines(self.file, self.NXDEF[i], float))
        # Unbounded Independent variable should be first so insert empty list at start
        self.X.reverse()                   # Bug fix - Ag Stephens - 21/06/05
        self.X.insert(0, [])
        self.XNAME=readItemsFromLines(self._readLines(self.NIV), self.NIV, str)
        self.XNAME.reverse()  # Reverse because C-type array is least-changing first
        self._readVariablesHeaderSection()
        self._readAuxVariablesHeaderSection()
        self._readComments()

    def writeHeader(self):
        """
        Writes FFI-specifc header section.
        """        
        self._writeCommonHeader()
        self.DX.reverse()
        self.header.write(("%s "*self.NIV+"\n") % tuple(self.DX))
        self.NX.reverse()
        self.header.write(("%s "*(self.NIV-1)+"\n") % tuple(self.NX))
        self.NXDEF.reverse()
        self.header.write(("%s "*(self.NIV-1)+"\n") % tuple(self.NXDEF))
        self.NXDEF.reverse()
        X_lines=[]
        for i in range(self.NIV-1):
            X_lines.append(((self.floatFormat+self.spacer)*self.NXDEF[i]+"\n") % tuple(self.X[i+1][0:self.NXDEF[i]]))
        X_lines.reverse()
        for line in X_lines:
            self.header.write(line.lstrip())
        self.XNAME.reverse()
        self.header.write("%s\n"*self.NIV % tuple(self.XNAME))
        self._writeVariablesHeaderSection()
        self._writeAuxVariablesHeaderSection()
        self._writeComments()         
        lines=self._fixHeaderLength(self.header)
        self.file.writelines(lines)

    def _setupArrays(self):
        """
        Sets up FFI-specific arrays to fill with data (lists of lists).
        """
        self.V=[]
        self.A=[]
        # Create an array size to request using read routines
        self.arraySize=1
        for i in self.NX:
                self.arraySize=self.arraySize*i
        for n in range(self.NV):
            self.V.append([])
        for a in range(self.NAUXV):
            self.A.append([])
            
    def _readData1(self, datalines, ivar_count):
        """
        Reads first line/section of current block of data.
        """        
        # Start with independent and Auxilliary vars
        (x2_and_a, rtlines)=readItemsFromUnknownLines(datalines, 1+self.NAUXV, float)
        (x, aux)=(x2_and_a[0], x2_and_a[1:])
        self.X[0].append(x)
        count=0
        for a in range(self.NAUXV):
            self.A[a].append(aux[count])
            count=count+1
        return rtlines

    def _readData2(self, datalines, ivar_count):
        """
        Reads second line/section (if used) of current block of data.
        """
        # Now get the dependent variables
        for n in range(self.NV):
            (v, rtlines)=readItemsFromUnknownLines(datalines, self.arraySize, float)
            self.V[n].append([])
            listManipulator.recursiveListPopulator(self.V[n][ivar_count], v, self.NX)
            datalines=rtlines
        return rtlines

    def writeData(self):
        """
        Writes the data section of the file.
        This method can be called directly by the user.
        """        
        # Set up unbounded IV loop
        self.NX.reverse()
        for m in range(len(self.X[0])):
            # Write Independent variable mark and auxiliary variables
            var_string=(self.floatFormat+self.spacer) % self.X[0][m]
            for a in range(self.NAUXV):
                var_string=var_string+((self.floatFormat+self.spacer) % self.A[a][m])
            self.file.write("%s\n" % var_string.rstrip())
            # Write Variables
            for n in range(self.NV):
                outlines=listManipulator.recursiveListWriter(self.V[n][m], self.NX, spacer=self.spacer, floatFormat=self.floatFormat)
                for line in outlines:
                    self.file.write(line)

    def _normalizeIndVars(self):
        """
        Normalizes the values in the unbounded independent variable for FFIs
        that store an abbreviated version of this axis.
        """
        for i in range(self.NIV-1):
            if self.NXDEF[i]==self.NX[i]:
                pass
            else:
                del self.X[i+1][1:]
                count=0
                while len(self.X[i+1])<self.NX[i]:
                    nextx=self.X[i+1][count]+self.DX[i+1]
                    self.X[i+1].append(nextx)
                    count=count+1
        self._normalizedX="yes"