anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file_conversion/sww2pts.py

@@ -0,0 +1,175 @@
+
+import numpy as num
+import os
+
+from anuga.coordinate_transforms.geo_reference import Geo_reference
+
+def sww2pts(name_in, name_out=None,
+            data_points=None,
+            quantity=None,
+            timestep=None,
+            reduction=None,
+            NODATA_value=-9999,
+            verbose=False,
+            origin=None):
+    """Read SWW file and convert to interpolated values at selected points
+
+    The parameter 'quantity' must be the name of an existing quantity or
+    an expression involving existing quantities. The default is 'elevation'.
+
+    if timestep (an index) is given, output quantity at that timestep.
+
+    if reduction is given use that to reduce quantity over all timesteps.
+
+    data_points (Nx2 array) give locations of points where quantity is to 
+    be computed.
+    """
+
+    import sys
+    from anuga.geometry.polygon import inside_polygon, outside_polygon
+    from anuga.abstract_2d_finite_volumes.util import \
+             apply_expression_to_dictionary
+    from anuga.geospatial_data.geospatial_data import Geospatial_data
+
+    if quantity is None:
+        quantity = 'elevation'
+
+    if reduction is None:
+        reduction = max
+
+    basename_in, in_ext = os.path.splitext(name_in)
+    
+    if name_out != None:
+        basename_out, out_ext = os.path.splitext(name_out)
+    else:
+        basename_out = basename_in + '_%s' % quantity
+        out_ext = '.pts'
+        name_out = basename_out + out_ext
+
+    if in_ext != '.sww':
+        raise IOError('Input format for %s must be .sww' % name_in)
+
+    if out_ext != '.pts':
+        raise IOError('Output format for %s must be .pts' % name_out)
+
+
+    # Read sww file
+    if verbose: log.critical('Reading from %s' % name_in)
+    from anuga.file.netcdf import NetCDFFile
+    fid = NetCDFFile(name_in)
+
+    # Get extent and reference
+    x = fid.variables['x'][:]
+    y = fid.variables['y'][:]
+    volumes = fid.variables['volumes'][:]
+
+
+    try: # works with netcdf4
+        number_of_timesteps = len(fid.dimensions['number_of_timesteps'])
+        number_of_points = len(fid.dimensions['number_of_points'])
+    except: #works with scientific.io.netcdf
+        number_of_timesteps = fid.dimensions['number_of_timesteps']
+        number_of_points = fid.dimensions['number_of_points']
+
+        
+    if origin is None:
+        # Get geo_reference
+        # sww files don't have to have a geo_ref
+        try:
+            geo_reference = Geo_reference(NetCDFObject=fid)
+        except AttributeError, e:
+            geo_reference = Geo_reference() # Default georef object
+
+        xllcorner = geo_reference.get_xllcorner()
+        yllcorner = geo_reference.get_yllcorner()
+        zone = geo_reference.get_zone()
+    else:
+        zone = origin[0]
+        xllcorner = origin[1]
+        yllcorner = origin[2]
+
+    # FIXME: Refactor using code from file_function.statistics
+    # Something like print swwstats(swwname)
+    if verbose:
+        x = fid.variables['x'][:]
+        y = fid.variables['y'][:]
+        times = fid.variables['time'][:]
+        log.critical('------------------------------------------------')
+        log.critical('Statistics of SWW file:')
+        log.critical('  Name: %s' % swwfile)
+        log.critical('  Reference:')
+        log.critical('    Lower left corner: [%f, %f]' % (xllcorner, yllcorner))
+        log.critical('    Start time: %f' % fid.starttime[0])
+        log.critical('  Extent:')
+        log.critical('    x [m] in [%f, %f], len(x) == %d'
+                     % (num.min(x), num.max(x), len(x.flat)))
+        log.critical('    y [m] in [%f, %f], len(y) == %d'
+                     % (num.min(y), num.max(y), len(y.flat)))
+        log.critical('    t [s] in [%f, %f], len(t) == %d'
+                     % (min(times), max(times), len(times)))
+        log.critical('  Quantities [SI units]:')
+        for name in ['stage', 'xmomentum', 'ymomentum', 'elevation']:
+            q = fid.variables[name][:].flat
+            log.critical('    %s in [%f, %f]' % (name, min(q), max(q)))
+
+    # Get quantity and reduce if applicable
+    if verbose: log.critical('Processing quantity %s' % quantity)
+
+    # Turn NetCDF objects into numeric arrays
+    quantity_dict = {}
+    for name in fid.variables.keys():
+        quantity_dict[name] = fid.variables[name][:]
+
+    # Convert quantity expression to quantities found in sww file
+    q = apply_expression_to_dictionary(quantity, quantity_dict)
+
+    if len(q.shape) == 2:
+        # q has a time component and needs to be reduced along
+        # the temporal dimension
+        if verbose: log.critical('Reducing quantity %s' % quantity)
+
+        q_reduced = num.zeros(number_of_points, num.float)
+        for k in range(number_of_points):
+            q_reduced[k] = reduction(q[:,k])
+        q = q_reduced
+
+    # Post condition: Now q has dimension: number_of_points
+    assert len(q.shape) == 1
+    assert q.shape[0] == number_of_points
+
+    if verbose:
+        log.critical('Processed values for %s are in [%f, %f]'
+                     % (quantity, min(q), max(q)))
+
+    # Create grid and update xll/yll corner and x,y
+    vertex_points = num.concatenate((x[:, num.newaxis], y[:, num.newaxis]), axis=1)
+    assert len(vertex_points.shape) == 2
+
+    # Interpolate
+    from anuga.fit_interpolate.interpolate import Interpolate
+    interp = Interpolate(vertex_points, volumes, verbose=verbose)
+
+    # Interpolate using quantity values
+    if verbose: log.critical('Interpolating')
+    interpolated_values = interp.interpolate(q, data_points).flatten()
+
+    if verbose:
+        log.critical('Interpolated values are in [%f, %f]'
+                     % (num.min(interpolated_values),
+                        num.max(interpolated_values)))
+
+    # Assign NODATA_value to all points outside bounding polygon
+    # (from interpolation mesh)
+    P = interp.mesh.get_boundary_polygon()
+    outside_indices = outside_polygon(data_points, P, closed=True)
+
+    for i in outside_indices:
+        interpolated_values[i] = NODATA_value
+
+    # Store results
+    G = Geospatial_data(data_points=data_points, attributes=interpolated_values)
+
+    G.export_points_file(name_out, absolute = True)
+
+    fid.close()
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file_conversion/tests/__init__.py

@@ -0,0 +1,8 @@
+"""Make directory available as a Python package
+"""
+
+pass
+
+
+
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file_conversion/tests/test_2pts.py

@@ -0,0 +1,249 @@
+# external modules
+import unittest
+import tempfile
+import shutil
+import numpy as num
+
+# ANUGA modules
+from anuga.shallow_water.shallow_water_domain import Domain 
+from anuga.coordinate_transforms.geo_reference import Geo_reference
+from anuga.file.sww import Write_sww, SWW_file
+from anuga.abstract_2d_finite_volumes.generic_boundary_conditions \
+                            import Transmissive_boundary
+from anuga.config import netcdf_mode_r, netcdf_mode_w, netcdf_mode_a, \
+                            netcdf_float
+from anuga.geospatial_data.geospatial_data import Geospatial_data
+
+# local modules
+from anuga.file_conversion.sdf2pts import sdf2pts
+from anuga.file_conversion.sww2pts import sww2pts
+
+
+class Test_2Pts(unittest.TestCase):
+    """ Test files that convert to pts format. """
+    
+    def test_hecras_cross_sections2pts(self):
+        """Test conversion from HECRAS cross sections in ascii format
+        to native NetCDF pts format
+        """
+
+        import time, os
+        from anuga.file.netcdf import NetCDFFile
+
+        #Write test asc file
+        root = 'hecrastest'
+
+        filename = root+'.sdf'
+        fid = open(filename, 'w')
+        fid.write("""
+# RAS export file created on Mon 15Aug2005 11:42
+# by HEC-RAS Version 3.1.1
+
+BEGIN HEADER:
+  UNITS: METRIC
+  DTM TYPE: TIN
+  DTM: v:\1\cit\perth_topo\river_tin
+  STREAM LAYER: c:\\x_local\hecras\21_02_03\up_canning_cent3d.shp
+  CROSS-SECTION LAYER: c:\\x_local\hecras\21_02_03\up_can_xs3d.shp
+  MAP PROJECTION: UTM
+  PROJECTION ZONE: 50
+  DATUM: AGD66
+  VERTICAL DATUM:
+  NUMBER OF REACHES:  19
+  NUMBER OF CROSS-SECTIONS:  2
+END HEADER:
+
+
+BEGIN CROSS-SECTIONS:
+
+  CROSS-SECTION:
+    STREAM ID:Southern-Wungong
+    REACH ID:Southern-Wungong
+    STATION:21410
+    CUT LINE:
+      407546.08 , 6437277.542
+      407329.32 , 6437489.482
+      407283.11 , 6437541.232
+    SURFACE LINE:
+     407546.08,   6437277.54,   52.14
+     407538.88,   6437284.58,   51.07
+     407531.68,   6437291.62,   50.56
+     407524.48,   6437298.66,   49.58
+     407517.28,   6437305.70,   49.09
+     407510.08,   6437312.74,   48.76
+  END:
+
+  CROSS-SECTION:
+    STREAM ID:Swan River
+    REACH ID:Swan Mouth
+    STATION:840.*
+    CUT LINE:
+      381178.0855 , 6452559.0685
+      380485.4755 , 6453169.272
+    SURFACE LINE:
+     381178.09,   6452559.07,   4.17
+     381169.49,   6452566.64,   4.26
+     381157.78,   6452576.96,   4.34
+     381155.97,   6452578.56,   4.35
+     381143.72,   6452589.35,   4.43
+     381136.69,   6452595.54,   4.58
+     381114.74,   6452614.88,   4.41
+     381075.53,   6452649.43,   4.17
+     381071.47,   6452653.00,   3.99
+     381063.46,   6452660.06,   3.67
+     381054.41,   6452668.03,   3.67
+  END:
+END CROSS-SECTIONS:
+""")
+
+        fid.close()
+
+
+        #Convert to NetCDF pts
+        sdf2pts(root+'.sdf')
+
+        #Check contents
+        #Get NetCDF
+        fid = NetCDFFile(root+'.pts', netcdf_mode_r)
+
+        # Get the variables
+        #print fid.variables.keys()
+        points = fid.variables['points']
+        elevation = fid.variables['elevation']
+
+        #Check values
+        ref_points = [[407546.08, 6437277.54],
+                      [407538.88, 6437284.58],
+                      [407531.68, 6437291.62],
+                      [407524.48, 6437298.66],
+                      [407517.28, 6437305.70],
+                      [407510.08, 6437312.74]]
+
+        ref_points += [[381178.09, 6452559.07],
+                       [381169.49, 6452566.64],
+                       [381157.78, 6452576.96],
+                       [381155.97, 6452578.56],
+                       [381143.72, 6452589.35],
+                       [381136.69, 6452595.54],
+                       [381114.74, 6452614.88],
+                       [381075.53, 6452649.43],
+                       [381071.47, 6452653.00],
+                       [381063.46, 6452660.06],
+                       [381054.41, 6452668.03]]
+
+
+        ref_elevation = [52.14, 51.07, 50.56, 49.58, 49.09, 48.76]
+        ref_elevation += [4.17, 4.26, 4.34, 4.35, 4.43, 4.58, 4.41, 4.17, 3.99, 3.67, 3.67]
+
+        #print points[:]
+        #print ref_points
+        assert num.allclose(points, ref_points)
+
+        #print attributes[:]
+        #print ref_elevation
+        assert num.allclose(elevation, ref_elevation)
+
+        #Cleanup
+        fid.close()
+
+
+        os.remove(root + '.sdf')
+        os.remove(root + '.pts')
+
+
+
+
+    def test_sww2pts_centroids(self):
+        """Test that sww information can be converted correctly to pts data at specified coordinates
+        - in this case, the centroids.
+        """
+
+        import time, os
+        from anuga.file.netcdf import NetCDFFile
+        # Used for points that lie outside mesh
+        NODATA_value = 1758323
+
+        # Setup
+        from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular
+
+        # Create shallow water domain
+        domain = Domain(*rectangular(2, 2))
+
+        B = Transmissive_boundary(domain)
+        domain.set_boundary( {'left': B, 'right': B, 'top': B, 'bottom': B})
+
+        domain.set_name('datatest')
+
+        ptsfile = domain.get_name() + '_elevation.pts'
+        swwfile = domain.get_name() + '.sww'
+
+        domain.set_datadir('.')
+        domain.format = 'sww'
+        domain.set_quantity('elevation', lambda x,y: -x-y)
+
+        domain.geo_reference = Geo_reference(56,308500,6189000)
+
+        sww = SWW_file(domain)
+        sww.store_connectivity()
+        sww.store_timestep()
+
+        #self.domain.tight_slope_limiters = 1
+        domain.evolve_to_end(finaltime = 0.01)
+        sww.store_timestep()
+
+        # Check contents in NetCDF
+        fid = NetCDFFile(sww.filename, netcdf_mode_r)
+
+        # Get the variables
+        x = fid.variables['x'][:]
+        y = fid.variables['y'][:]
+        elevation = fid.variables['elevation'][:]
+        time = fid.variables['time'][:]
+        stage = fid.variables['stage'][:]
+
+        volumes = fid.variables['volumes'][:]
+
+
+        # Invoke interpolation for vertex points       
+        points = num.concatenate( (x[:,num.newaxis],y[:,num.newaxis]), axis=1 )
+        points = num.ascontiguousarray(points)
+        sww2pts(domain.get_name() + '.sww',
+                quantity = 'elevation',
+                data_points = points,
+                NODATA_value = NODATA_value)
+        ref_point_values = elevation
+        point_values = Geospatial_data(ptsfile).get_attributes()
+        #print 'P', point_values
+        #print 'Ref', ref_point_values        
+        assert num.allclose(point_values, ref_point_values)        
+
+
+
+        # Invoke interpolation for centroids
+        points = domain.get_centroid_coordinates()
+        #print points
+        sww2pts(domain.get_name() + '.sww',
+                quantity = 'elevation',
+                data_points = points,
+                NODATA_value = NODATA_value)
+        ref_point_values = [-0.5, -0.5, -1, -1, -1, -1, -1.5, -1.5]   #At centroids
+
+        
+        point_values = Geospatial_data(ptsfile).get_attributes()
+        #print 'P', point_values
+        #print 'Ref', ref_point_values        
+        assert num.allclose(point_values, ref_point_values)        
+
+        fid.close()
+
+        #Cleanup
+        os.remove(sww.filename)
+        os.remove(ptsfile)
+
+
+#-------------------------------------------------------------
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(Test_2Pts, 'test_sww')
+    runner = unittest.TextTestRunner() #verbosity=2)
+    runner.run(suite)    

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file_conversion/tests/test_csv2sts.py

@@ -0,0 +1,118 @@
+#external modules
+import os
+import sys
+import unittest
+import numpy as num
+from anuga.file.netcdf import NetCDFFile
+from anuga.utilities.system_tools import get_pathname_from_package
+
+
+
+# ANUGA modules
+from anuga.config import netcdf_float32, netcdf_float64
+from anuga.file.csv_file import load_csv_as_dict
+
+# Local modules
+from anuga.file_conversion.csv2sts import csv2sts
+
+# some test file we want to generate
+testfile_csv = 'small___.csv'
+sts_out = 'sts_out.sts'
+
+lat = 10
+lon = 20
+
+
+
+class Test_csv2sts(unittest.TestCase):
+    """
+        Test csv to NetCDFFile conversion functionality.
+    """
+    def setUp(self):
+        """ Setup for all tests. """
+        self.verbose = True
+        fid = open(testfile_csv, 'w')
+        fid.write("""time stage
+0 4
+1 150.66667
+2 150.83334
+3 151.
+4 151.16667
+5 -34.
+6 -34.16667
+7 -34.33333
+8 -34.5
+9 -1.
+10 -5.
+11 -9.
+12 -13.
+""")
+        fid.close()
+                  
+    def tearDown(self):
+        """ Cleanup for all tests. """     
+        os.remove(testfile_csv)
+
+    def test_missing_input_file(self):
+        """
+        Test that a missing csv file raises the correct exception.
+        """
+        got_except = False
+        
+        try:
+            csv2sts('somename_not_here.csv', sts_out, 10, 20)
+        except IOError, e:
+            got_except = True
+        except:
+            assert False, 'Missing file raised wrong exception.'
+
+        assert got_except is True, 'Missing file did not raise an exception.'
+
+    def test_csv2sts_output(self):
+        """
+        Test that a csv file is correctly rendered to .sts (NetCDF) format.
+        """
+        csv2sts(testfile_csv, sts_out, latitude = lat, longitude = lon)
+        self._check_generated_sts()
+        
+    def test_run_via_commandline(self):
+        """
+        Make sure that the python file functions as a command-line tool.
+        """
+
+        # Look for script in same dir as this unit test.
+        path = os.path.dirname( os.path.realpath( __file__ ) )
+
+        path = get_pathname_from_package( 'anuga.file_conversion' )
+        
+        cmd = 'python ' + os.path.join( path, 'csv2sts.py') + ' --latitude ' 
+        cmd += '%s --lon %s %s %s' % (str(lat), str(lon), testfile_csv, sts_out)
+        
+        os.system(cmd)
+        self._check_generated_sts()
+
+
+    def _check_generated_sts(self):
+        """ check that we can read data out of the file """
+        sts = NetCDFFile(sts_out,'r')
+        
+        data, names = load_csv_as_dict(testfile_csv, delimiter=' ', d_type = num.float64)
+        
+        assert sts.latitude == lat, 'latitude does not match'
+        assert sts.longitude == lon, 'longitude does not match'
+        
+        assert len(sts.variables) == len(data), 'num variables does not match'
+        
+        # make sure data is returned in exactly the expected format
+        for key, values in data.items():
+            assert list(sts.variables[key][:]) == values, \
+                                        'stored data does not match'
+
+        if not sys.platform == 'win32':
+            # Windows cannot delete the file for some reason.
+            os.remove(sts_out)           
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(Test_csv2sts,'test')
+    runner = unittest.TextTestRunner()
+    runner.run(suite)

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file_conversion/tests/test_dem2array.py

@@ -0,0 +1,121 @@
+import sys
+import unittest
+import numpy as num
+import copy
+import os
+
+# ANUGA modules
+from anuga.config import netcdf_mode_r, netcdf_mode_w, netcdf_mode_a, \
+                            netcdf_float
+
+from anuga.file.netcdf import NetCDFFile
+
+from anuga.file_conversion.dem2array import dem2array
+from anuga.file_conversion.asc2dem import asc2dem
+
+
+class Test_dem2array(unittest.TestCase):
+    """ A suite of tests to test file conversion functions.
+        These tests are quite coarse-grained: converting a file
+        and checking that its headers and some of its contents
+        are correct.
+    """ 
+ 
+    def test_dem2array(self):
+        """Test conversion from dem to array
+        """
+
+        import time, os
+
+
+        #Write test asc file
+        root = 'dem2arraytest_1'
+
+        filename = root+'.asc'
+        fid = open(filename, 'w')
+        fid.write("""ncols         11
+nrows         12
+xllcorner     2000
+yllcorner     3000
+cellsize      3
+NODATA_value  -9999
+""")
+        #Create linear function
+        ref_points = []
+        ref_elevation = []
+        x0 = 2000
+        y = 3000
+        cellsize = 3.0
+        xvec = x0 + cellsize*num.arange(11)
+        yvec = y + cellsize*(num.arange(12))
+        z = -1
+        for i in range(12):
+            y = y - cellsize
+            for j in range(11):
+                x = x0 + xvec[j]
+                z += 1
+                ref_points.append ([x,y])
+                ref_elevation.append(z)
+                fid.write('%f ' %z)
+            fid.write('\n')
+
+        fid.close()
+
+        #print 'sending pts', ref_points
+        #print 'sending elev', ref_elevation
+        
+        Z_ex = num.array(ref_elevation,num.float).reshape(12,11)
+
+        #Write prj file with metadata
+        metafilename = root+'.prj'
+        fid = open(metafilename, 'w')
+
+
+        fid.write("""Projection UTM
+Zone 56
+Datum WGS84
+Zunits NO
+Units METERS
+Spheroid WGS84
+Xshift 0.0000000000
+Yshift 10000000.0000000000
+Parameters
+""")
+        fid.close()
+
+        #Convert to NetCDF dem
+        
+        asc2dem(filename)
+
+
+        x,y, Z = dem2array(root+'.dem')
+        
+#         print Z
+#         print Z_ex
+#         print x
+#         print xvec
+#         print y
+#         print yvec        
+        
+        assert num.allclose(Z,Z_ex)
+        assert num.allclose(x,xvec)
+        assert num.allclose(y,yvec)
+
+               
+        #assert num.allclose(x,)
+
+        try:
+            os.remove(root + '.dem')
+            os.remove(root + '.asc')
+            os.remove(root + '.prj')
+        except:
+            # Expect error on windows
+            pass
+
+
+#-------------------------------------------------------------
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(Test_dem2array,'test')
+    runner = unittest.TextTestRunner()
+    runner.run(suite)