source: nappy/trunk/nappy/na_file/na_file_1010.py @ 3519

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/nappy/trunk/nappy/na_file/na_file_1010.py@3519
Revision 3519, 4.1 KB checked in by ckilburn, 12 years ago (diff)

Annotation

Line 
1#   Copyright (C) 2004 CCLRC & NERC( Natural Environment Research Council ).
2#   This software may be distributed under the terms of the
3#   Q Public License, version 1.0 or later. http://ndg.nerc.ac.uk/public_docs/QPublic_license.txt
4
5"""
6naFile1010.py
7=============
8
9Container module for NAFile1010 class.
10
11"""
12
13# 08/05/04 updated by selatham for bug fixes and new write methods
14
15# Imports from python standard library
16
17# Imports from local package
18import nappy.utils.text_parser
19import nappy.na_file.na_file_1001
20import nappy.utils.common_utils
21wrapLine = nappy.utils.common_utils.annotateLine
22wrapLines = nappy.utils.common_utils.annotateLines
23
24class NAFile1010(nappy.na_file.na_file.NAFile):
25    """
26    Class to read, write and interact with NASA Ames files conforming to the
27    File Format Index (FFI) 1010.
28    """
29
30    def readHeader(self):
31        """
32        Reads FFI-specifc header section.
33        """       
34        self._readCommonHeader()
35        self.DX = nappy.utils.text_parser.readItemsFromLine(self.file.readline(), self.NIV, float)
36        self.XNAME = nappy.utils.text_parser.readItemsFromLines(self._readLines(self.NIV), self.NIV, str)
37        self._readVariablesHeaderSection()
38        self._readAuxVariablesHeaderSection()
39        self._readComments()
40
41    def writeHeader(self):                                                             
42        """                                                                                     
43        Writes FFI-specifc header section.                                     
44        """                                                                                     
45        self._writeCommonHeader()                                               
46        self.header.write(wrapLine("DX", self.annotation, self.delimiter, ("%s " * self.NIV + "\n") % tuple(self.DX)))
47        self.header.write(wrapLines("XNAME", self.annotation, self.delimiter, ("%s\n") * self.NIV % tuple(self.XNAME)))
48        self._writeVariablesHeaderSection()                                     
49        self._writeAuxVariablesHeaderSection()                                 
50        self._writeComments()                                                   
51        self._fixHeaderLength()
52        self.file.write(self.header.read())
53
54    def _setupArrays(self):
55        """
56        Sets up FFI-specific arrays to fill with data (lists of lists).
57        """       
58        self.X = []
59        self.V = []
60        self.A = []
61
62        for n in range(self.NV):
63            self.V.append([])
64        for a in range(self.NAUXV):
65            self.A.append([])
66
67    def _readData1(self, datalines, ivar_count): 
68        """
69        Reads first line/section of current block of data.
70        """
71        # Start with independent and Auxilliary vars
72        (x2_and_a, rtlines) = nappy.utils.text_parser.readItemsFromUnknownLines(datalines, 1 + self.NAUXV, float)
73        (x, aux) = (x2_and_a[0], x2_and_a[1:])
74        self.X.append(x)
75
76        count = 0
77        for a in range(self.NAUXV):
78            self.A[a].append(aux[count])
79            count = count + 1
80        return rtlines
81   
82    def _readData2(self, datalines, ivar_count):
83        """
84        Reads second line/section (if used) of current block of data.
85        """       
86        # Now get the dependent variables
87        (v, rtlines) = nappy.utils.text_parser.readItemsFromUnknownLines(datalines, self.NV, float)             
88                                       
89        count = 0
90        for n in range(self.NV):                               
91            self.V[n].append(v[count])                                                 
92            count = count + 1
93
94        return rtlines
95
96    def writeData(self):                                                                       
97         """                                                                                   
98         Writes the data section of the file.                                           
99         This method can be called directly by the user.                       
100         """                                                                                   
101         for m in range(len(self.X)):                                                   
102             # Write Independent variable mark and auxiliary variables         
103             var_string = self.format % self.X[m]   
104                                       
105             for a in range(self.NAUXV):                                               
106                 var_string = var_string + (self.format % self.A[a][m])
107       
108             self.file.write(wrapLine("Data", self.annotation, self.delimiter, "%s\n" % var_string.rstrip(" ,")))       
109                       
110             # Write dependant variables                                               
111             var_string = ""                                                           
112             for n in range(self.NV):                                                   
113                  var_string = var_string + (self.format % self.V[n][m])       
114       
115             self.file.write(wrapLine("Data", self.annotation, self.delimiter, "%s\n" % var_string.rstrip(' ,')))                                       
Note: See TracBrowser for help on using the repository browser.