anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file/netcdf.py

@@ -0,0 +1,266 @@
+""" This module is responsible for loading and saving NetCDF NC files
+"""
+
+import numpy as num
+
+from anuga.coordinate_transforms.redfearn import \
+     convert_from_latlon_to_utm
+from anuga.config import minimum_storable_height as \
+     default_minimum_storable_height
+from anuga.config import netcdf_mode_r, netcdf_mode_w
+from anuga.config import netcdf_float, netcdf_int
+from anuga.utilities.numerical_tools import ensure_numeric,  mean
+
+import anuga.utilities.log as log
+
+
+# Definitions of various NetCDF dimension names, etc.
+lon_name = 'LON'
+lat_name = 'LAT'
+time_name = 'TIME'
+precision = netcdf_float # So if we want to change the precision its done here
+
+
+
+def NetCDFFile(file_name, netcdf_mode=netcdf_mode_r):
+    """Wrapper to isolate changes of the netcdf libray.
+
+    In theory we should be able to change over to NetCDF4 via this
+    wrapper, by ensuring the interface to the NetCDF library isthe same as the
+    the old Scientific.IO.NetCDF library.
+
+    There is a difference between extracting dimensions. We have used the following
+    to cover netcdf4 and scientific python
+
+    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']
+    
+    """
+   
+    using_scientific = using_netcdf4 = False
+    
+    try:
+        from Scientific.IO.NetCDF import NetCDFFile
+        using_scientific = True
+    except: 
+        from netCDF4 import Dataset
+        using_netcdf4 = True
+
+    assert using_scientific or using_netcdf4
+
+    if using_scientific:
+        return NetCDFFile(file_name, netcdf_mode)
+
+    if using_netcdf4:
+        if netcdf_mode == 'wl' :
+            return Dataset(file_name, 'w', format='NETCDF3_64BIT')
+        else:
+            return Dataset(file_name, netcdf_mode, format='NETCDF3_64BIT')
+
+
+
+#    from netCDF4 import Dataset
+#    return Dataset(file_name, netcdf_mode, format='NETCDF3_64BIT')
+
+    #return Dataset(file_name, netcdf_mode, format='NETCDF3_CLASSIC')
+
+
+    # COMMENT SR; Can't use scipy.io.netcdf as we can't append to
+    # a file as of 2013/03/26
+    #from scipy.io.netcdf import netcdf_file
+    #return netcdf_file(file_name, netcdf_mode, version=2)
+
+
+
+
+class Write_nc:
+    """Write an nc file.
+
+    Note, this should be checked to meet cdc netcdf conventions for gridded
+    data. http://www.cdc.noaa.gov/cdc/conventions/cdc_netcdf_standard.shtml
+    """
+
+    def __init__(self,
+                 quantity_name,
+                 file_name,
+                 time_step_count,
+                 time_step,
+                 lon,
+                 lat):
+        """Instantiate a Write_nc instance (NetCDF file writer).
+
+        time_step_count is the number of time steps.
+        time_step is the time step size
+
+        pre-condition: quantity_name must be 'HA', 'UA'or 'VA'.
+        """
+
+        self.quantity_name = quantity_name
+        quantity_units = {'HA':'CENTIMETERS',
+                          'UA':'CENTIMETERS/SECOND',
+                          'VA':'CENTIMETERS/SECOND'}
+
+        multiplier_dic = {'HA':100.0,   # To convert from m to cm
+                          'UA':100.0,   #             and m/s to cm/sec
+                          'VA':-100.0}  # MUX files have positive x in the
+                                        # Southern direction.  This corrects
+                                        # for it, when writing nc files.
+
+        self.quantity_multiplier =  multiplier_dic[self.quantity_name]
+
+        #self.file_name = file_name
+        self.time_step_count = time_step_count
+        self.time_step = time_step
+
+        # NetCDF file definition
+        self.outfile = NetCDFFile(file_name, netcdf_mode_w)
+        outfile = self.outfile
+
+        #Create new file
+        nc_lon_lat_header(outfile, lon, lat)
+
+        # TIME
+        outfile.createDimension(time_name, None)
+        outfile.createVariable(time_name, precision, (time_name,))
+
+        #QUANTITY
+        outfile.createVariable(self.quantity_name, precision,
+                               (time_name, lat_name, lon_name))
+        outfile.variables[self.quantity_name].missing_value = -1.e+034
+        outfile.variables[self.quantity_name].units = \
+                                 quantity_units[self.quantity_name]
+        outfile.variables[lon_name][:]= ensure_numeric(lon)
+        outfile.variables[lat_name][:]= ensure_numeric(lat)
+
+        #Assume no one will be wanting to read this, while we are writing
+        #outfile.close()
+
+    def store_timestep(self, quantity_slice):
+        """Write a time slice of quantity info
+
+        quantity_slice is the data to be stored at this time step
+        """
+
+        # Get the variables
+        time = self.outfile.variables[time_name]
+        quantity = self.outfile.variables[self.quantity_name]
+
+        # get index oflice to write
+        i = len(time)
+
+        #Store time
+        time[i] = i * self.time_step    #self.domain.time
+        quantity[i,:] = quantity_slice * self.quantity_multiplier
+
+    def close(self):
+        """ Close file underlying the class instance. """
+        self.outfile.close()
+
+
+
+def write_elevation_nc(file_out, lon, lat, depth_vector):
+    """Write an nc elevation file."""
+
+    # NetCDF file definition
+    outfile = NetCDFFile(file_out, netcdf_mode_w)
+
+    #Create new file
+    nc_lon_lat_header(outfile, lon, lat)
+
+    # ELEVATION
+    zname = 'ELEVATION'
+    outfile.createVariable(zname, precision, (lat_name, lon_name))
+    outfile.variables[zname].units = 'CENTIMETERS'
+    outfile.variables[zname].missing_value = -1.e+034
+
+    outfile.variables[lon_name][:] = ensure_numeric(lon)
+    outfile.variables[lat_name][:] = ensure_numeric(lat)
+
+    depth = num.reshape(depth_vector, (len(lat), len(lon)))
+    outfile.variables[zname][:] = depth
+
+    outfile.close()
+
+
+def nc_lon_lat_header(outfile, lon, lat):
+    """Write lat/lon headers to a NetCDF file.
+
+    outfile is the netcdf file handle.
+    lon - a list/array of the longitudes
+    lat - a list/array of the latitudes
+    """
+
+    outfile.institution = 'Geoscience Australia'
+    outfile.description = 'Converted from URS binary C'
+
+    # Longitude
+    outfile.createDimension(lon_name, len(lon))
+    outfile.createVariable(lon_name, precision, (lon_name,))
+    outfile.variables[lon_name].point_spacing = 'uneven'
+    outfile.variables[lon_name].units = 'degrees_east'
+    outfile.variables[lon_name].assignValue(lon)
+
+    # Latitude
+    outfile.createDimension(lat_name, len(lat))
+    outfile.createVariable(lat_name, precision, (lat_name,))
+    outfile.variables[lat_name].point_spacing = 'uneven'
+    outfile.variables[lat_name].units = 'degrees_north'
+    outfile.variables[lat_name].assignValue(lat)
+
+
+
+
+def filter_netcdf(filename1, filename2, first=0, last=None, step=1):
+    """Filter data file, selecting timesteps first:step:last.
+    
+    Read netcdf filename1, pick timesteps first:step:last and save to
+    nettcdf file filename2
+    """
+
+    from Scientific.IO.NetCDF import NetCDFFile
+
+    # Get NetCDF
+    infile = NetCDFFile(filename1, netcdf_mode_r)  #Open existing file for read
+    outfile = NetCDFFile(filename2, netcdf_mode_w)  #Open new file
+
+    # Copy dimensions
+    for d in infile.dimensions:
+        outfile.createDimension(d, infile.dimensions[d])
+
+    # Copy variable definitions
+    for name in infile.variables:
+        var = infile.variables[name]
+        outfile.createVariable(name, var.dtype.char, var.dimensions)
+
+    # Copy the static variables
+    for name in infile.variables:
+        if name == 'time' or name == 'stage':
+            pass
+        else:
+            outfile.variables[name][:] = infile.variables[name][:]
+
+    # Copy selected timesteps
+    time = infile.variables['time']
+    stage = infile.variables['stage']
+
+    newtime = outfile.variables['time']
+    newstage = outfile.variables['stage']
+
+    if last is None:
+        last = len(time)
+
+    selection = range(first, last, step)
+    for i, j in enumerate(selection):
+        log.critical('Copying timestep %d of %d (%f)'
+                     % (j, last-first, time[j]))
+        newtime[i] = time[j]
+        newstage[i,:] = stage[j,:]
+
+    # Close
+    infile.close()
+    outfile.close()
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file/pts.py

@@ -0,0 +1,29 @@
+"""
+    Fit a boundary polygon around arbitrary points.
+"""
+
+
+def load_pts_as_polygon(points_file, minimum_triangle_angle=3.0):
+    """
+    WARNING: This function is not fully working.
+
+    Function to return a polygon returned from alpha shape, given a points file.
+
+    WARNING: Alpha shape returns multiple polygons, but this function only
+             returns one polygon.
+    """
+
+    from anuga.pmesh.mesh import importMeshFromFile
+    from anuga.shallow_water.shallow_water_domain import Domain
+
+    mesh = importMeshFromFile(points_file)
+    mesh.auto_segment()
+    mesh.exportASCIIsegmentoutlinefile("outline.tsh")
+    mesh2 = importMeshFromFile("outline.tsh")
+    mesh2.generate_mesh(maximum_triangle_area=1000000000,
+                        minimum_triangle_angle=minimum_triangle_angle,
+                        verbose=False)
+    mesh2.export_mesh_file('outline_meshed.tsh')
+    domain = Domain("outline_meshed.tsh", use_cache = False)
+    polygon =  domain.get_boundary_polygon()
+    return polygon

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file/setup.py

@@ -0,0 +1,27 @@
+from __future__ import division, print_function
+
+import os
+import sys
+
+from os.path import join
+
+def configuration(parent_package='',top_path=None):
+    
+    from numpy.distutils.misc_util import Configuration
+    from numpy.distutils.system_info import get_info
+    
+    config = Configuration('file', parent_package, top_path)
+
+    config.add_data_dir('tests')
+
+    util_dir = os.path.abspath(join(os.path.dirname(__file__),'..','utilities'))
+    
+    config.add_extension('urs_ext',
+                         sources=['urs_ext.c'],
+                         include_dirs=[util_dir])
+    
+    return config
+    
+if __name__ == '__main__':
+    from numpy.distutils.core import setup
+    setup(configuration=configuration)

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/file/sts.py

@@ -0,0 +1,293 @@
+import numpy as num
+import anuga.utilities.log as log
+from anuga.file.netcdf import NetCDFFile
+
+from anuga.config import max_float
+from anuga.config import netcdf_float, netcdf_float32, netcdf_int
+from anuga.utilities.numerical_tools import ensure_numeric
+from anuga.coordinate_transforms.geo_reference import Geo_reference, \
+     ensure_geo_reference
+from anuga.config import netcdf_mode_r, netcdf_mode_w, netcdf_mode_a
+
+class Write_sts:
+    """ A class to write STS files.
+    """
+    sts_quantities = ['stage', 'xmomentum', 'ymomentum']
+    RANGE = '_range'
+    EXTREMA = ':extrema'
+
+    def __init__(self):
+        pass
+
+    def store_header(self,
+                     outfile,
+                     times,
+                     number_of_points,
+                     description='Converted from URS mux2 format',
+                     sts_precision=netcdf_float32,
+                     verbose=False):
+        """Write a header to the underlying data file.
+
+        outfile          handle to open file to write
+        times            list of the time slice times *or* a start time
+        number_of_points the number of URS gauge sites
+        description      description string to write into the STS file
+        sts_precision    format of data to write (netcdf constant ONLY)
+        verbose          True if this function is to be verbose
+
+        If 'times' is a list, the info will be made relative.
+        """
+
+        outfile.institution = 'Geoscience Australia'
+        outfile.description = description
+
+        try:
+            revision_number = get_revision_number()
+        except:
+            revision_number = None
+
+        # Allow None to be stored as a string
+        outfile.revision_number = str(revision_number)
+
+        # Start time in seconds since the epoch (midnight 1/1/1970)
+        # This is being used to seperate one number from a list.
+        # what it is actually doing is sorting lists from numeric arrays.
+        if isinstance(times, (list, num.ndarray)):
+            number_of_times = len(times)
+            times = ensure_numeric(times)
+            if number_of_times == 0:
+                starttime = 0
+            else:
+                starttime = times[0]
+                times = times - starttime  #Store relative times
+        else:
+            number_of_times = 0
+            starttime = times
+
+        outfile.starttime = starttime
+
+        # Dimension definitions
+        outfile.createDimension('number_of_points', number_of_points)
+        outfile.createDimension('number_of_timesteps', number_of_times)
+        outfile.createDimension('numbers_in_range', 2)
+
+        # Variable definitions
+        outfile.createVariable('permutation', netcdf_int, ('number_of_points',))
+        outfile.createVariable('x', sts_precision, ('number_of_points',))
+        outfile.createVariable('y', sts_precision, ('number_of_points',))
+        outfile.createVariable('elevation', sts_precision, \
+                                    ('number_of_points',))
+
+        q = 'elevation'
+        outfile.createVariable(q + Write_sts.RANGE, sts_precision,
+                               ('numbers_in_range',))
+
+        # Initialise ranges with small and large sentinels.
+        # If this was in pure Python we could have used None sensibly
+        outfile.variables[q + Write_sts.RANGE][0] = max_float  # Min
+        outfile.variables[q + Write_sts.RANGE][1] = -max_float # Max
+
+        self.write_dynamic_quantities(outfile, Write_sts.sts_quantities, times)
+
+    def store_points(self,
+                     outfile,
+                     points_utm,
+                     elevation, zone=None, new_origin=None,
+                     points_georeference=None, verbose=False):
+
+        """
+        points_utm - currently a list or array of the points in UTM.
+        points_georeference - the georeference of the points_utm
+
+        How about passing new_origin and current_origin.
+        If you get both, do a convertion from the old to the new.
+
+        If you only get new_origin, the points are absolute,
+        convert to relative
+
+        if you only get the current_origin the points are relative, store
+        as relative.
+
+        if you get no georefs create a new georef based on the minimums of
+        points_utm.  (Another option would be to default to absolute)
+
+        Yes, and this is done in another part of the code.
+        Probably geospatial.
+
+        If you don't supply either geo_refs, then supply a zone. If not
+        the default zone will be used.
+
+        precondition:
+             header has been called.
+        """
+
+        number_of_points = len(points_utm)
+        points_utm = num.array(points_utm)
+
+        # given the two geo_refs and the points, do the stuff
+        # described in the method header
+        points_georeference = ensure_geo_reference(points_georeference)
+        new_origin = ensure_geo_reference(new_origin)
+
+        if new_origin is None and points_georeference is not None:
+            points = points_utm
+            geo_ref = points_georeference
+        else:
+            if new_origin is None:
+                new_origin = Geo_reference(zone, min(points_utm[:,0]),
+                                                 min(points_utm[:,1]))
+            points = new_origin.change_points_geo_ref(points_utm,
+                                                      points_georeference)
+            geo_ref = new_origin
+
+        # At this stage I need a georef and points
+        # the points are relative to the georef
+        geo_ref.write_NetCDF(outfile)
+
+        x = points[:,0]
+        y = points[:,1]
+        z = outfile.variables['elevation'][:]
+
+        if verbose:
+            log.critical('------------------------------------------------')
+            log.critical('More Statistics:')
+            log.critical('  Extent (/lon):')
+            log.critical('    x in [%f, %f], len(lat) == %d'
+                         % (min(x), max(x), len(x)))
+            log.critical('    y in [%f, %f], len(lon) == %d'
+                         % (min(y), max(y), len(y)))
+            log.critical('    z in [%f, %f], len(z) == %d'
+                         % (min(elevation), max(elevation), len(elevation)))
+            log.critical('geo_ref: %s' % str(geo_ref))
+            log.critical('------------------------------------------------')
+
+        z = resize(bath_grid,outfile.variables['elevation'][:].shape)
+        outfile.variables['x'][:] = points[:,0] #- geo_ref.get_xllcorner()
+        outfile.variables['y'][:] = points[:,1] #- geo_ref.get_yllcorner()
+        #outfile.variables['z'][:] = elevation
+        outfile.variables['elevation'][:] = elevation  #FIXME HACK4
+
+        # This updates the _range values
+        q = 'elevation'
+        outfile.variables[q + Write_sts.RANGE][0] = min(elevation)
+        outfile.variables[q + Write_sts.RANGE][1] = max(elevation)
+
+    def store_quantities(self, outfile, sts_precision=num.float32,
+                         slice_index=None, time=None,
+                         verbose=False, **quant):
+        """Write the quantity info.
+
+        **quant is extra keyword arguments passed in. These must be
+          the sts quantities, currently; stage.
+
+        if the time array is already been built, use the slice_index
+        to specify the index.
+
+        Otherwise, use time to increase the time dimension
+
+        Maybe make this general, but the viewer assumes these quantities,
+        so maybe we don't want it general - unless the viewer is general
+
+        precondition:
+            triangulation and header have been called.
+        """
+
+        if time is not None:
+            file_time = outfile.variables['time']
+            slice_index = len(file_time)
+            file_time[slice_index] = time
+
+        # Write the conserved quantities from Domain.
+        # Typically stage, xmomentum, ymomentum
+        # other quantities will be ignored, silently.
+        # Also write the ranges: stage_range
+        for q in Write_sts.sts_quantities:
+            if not quant.has_key(q):
+                msg = 'STS file can not write quantity %s' % q
+                raise NewQuantity, msg
+            else:
+                q_values = quant[q]
+                outfile.variables[q][slice_index] = \
+                                q_values.astype(sts_precision)
+
+                # This updates the _range values
+                q_range = outfile.variables[q + Write_sts.RANGE][:]
+                q_values_min = num.min(q_values)
+                if q_values_min < q_range[0]:
+                    outfile.variables[q + Write_sts.RANGE][0] = q_values_min
+                q_values_max = num.max(q_values)
+                if q_values_max > q_range[1]:
+                    outfile.variables[q + Write_sts.RANGE][1] = q_values_max
+
+
+
+    def write_dynamic_quantities(self, outfile, quantities,
+                    times, precis = netcdf_float32, verbose = False):   
+        """
+            Write out given quantities to file.
+        """
+        for q in quantities:
+            outfile.createVariable(q, precis, ('number_of_timesteps',
+                                                      'number_of_points'))
+            outfile.createVariable(q + Write_sts.RANGE, precis,
+                                   ('numbers_in_range',))
+
+            # Initialise ranges with small and large sentinels.
+            # If this was in pure Python we could have used None sensibly
+            outfile.variables[q+Write_sts.RANGE][0] = max_float  # Min
+            outfile.variables[q+Write_sts.RANGE][1] = -max_float # Max
+
+        # Doing sts_precision instead of Float gives cast errors.
+        outfile.createVariable('time', netcdf_float, ('number_of_timesteps',))
+
+        if isinstance(times, (list, num.ndarray)):
+            outfile.variables['time'][:] = times    # Store time relative
+
+        if verbose:
+            log.critical('------------------------------------------------')
+            log.critical('Statistics:')
+            log.critical('    t in [%f, %f], len(t) == %d'
+                         % (num.min(times), num.max(times), len(times.flat)))
+
+
+
+def create_sts_boundary(sts_filename):
+    """Create a list of points defining a boundary from an STS file.
+
+    Create boundary segments from .sts file. Points can be stored in
+    arbitrary order within the .sts file. The order in which the .sts points
+    make up the boundary are given in order.txt file
+
+    FIXME:
+    Point coordinates are stored in relative eastings and northings.
+    But boundary is produced in absolute coordinates
+    """
+
+    if sts_filename.endswith('.sts'):
+        stsname_postfixed = sts_filename
+    else:
+        stsname_postfixed = sts_filename + '.sts'
+
+    try:
+        fid = NetCDFFile(stsname_postfixed, netcdf_mode_r)
+    except IOError:
+        msg = 'Cannot open %s' % stsname_postfixed
+        raise IOError(msg)
+
+    xllcorner = fid.xllcorner
+    yllcorner = fid.yllcorner
+
+    #Points stored in sts file are normalised to [xllcorner,yllcorner] but
+    #we cannot assume that boundary polygon will be. At least the
+    #additional points specified by the user after this function is called
+    x = fid.variables['x'][:] + xllcorner
+    y = fid.variables['y'][:] + yllcorner
+
+    x = num.reshape(x, (len(x), 1))
+    y = num.reshape(y, (len(y), 1))
+    sts_points = num.concatenate((x,y), axis=1)
+
+    return sts_points.tolist()
+
+
+