anuga 1.3.5__zip

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

@@ -0,0 +1,130 @@
+import matplotlib
+import matplotlib.pyplot as plt
+import matplotlib.tri as tri
+from pylab import *
+
+# The abstract Python-MPI interface
+from anuga.utilities.parallel_abstraction import size, rank, get_processor_name
+from anuga.utilities.parallel_abstraction import finalize, send, receive
+from anuga.utilities.parallel_abstraction import pypar_available, barrier
+
+import random
+
+import numpy as num
+
+'''
+Adds random noise to stage quantities (centroid) in the domain.
+domain - domain where noise is to be added
+samples - number of centroids to add noise to
+dthr - minimum depth threshold, stages corresponding to depths less than this value are not modified
+mag - (relative) magnitude of the noise, uniformly distributed in [-mag, mag]
+'''
+def addRandomNoiseToStage(domain, samples = 50, dthr = 0.1, mag = 1E-15):
+
+    # Calculate depth
+    depth = domain.get_quantity('stage').centroid_values[domain.tri_full_flag == 1] \
+        - domain.get_quantity('elevation').centroid_values[domain.tri_full_flag == 1]
+
+    stage = domain.get_quantity('stage')
+
+    # Sample centroid values with depth greater than dthr
+    n_tri = int(num.sum(domain.tri_full_flag))
+    tri_index = num.array(range(0,n_tri))
+    submerged = tri_index[depth > dthr]
+    submerged = random.sample(submerged, min(samples, len(submerged)))
+
+    # Add random noise to sampled centroid values
+    if len(submerged) > 0:
+        for i in range(len(submerged)):
+            new_val = (1.0 + random.uniform(-1.0, 1.0)*mag)*stage.centroid_values[submerged[i]]
+            domain.get_quantity('stage').centroid_values.put(submerged[i], new_val)
+
+'''
+Plot errors in centroid quantities, triangles with errors are denoted in blue, while
+triangles without errors are denoted in green.
+
+domain - domain for which the error plots will be displayed
+control_data - control data to compare quantity values against (must have serial indexing)
+rthr - relative error threshold
+athr - absolute error threshold
+quantity - quantity e.g stage
+filename - output filename
+'''
+
+def plotCentroidError(domain, control_data, rthr = 1E-7, athr = 1E-12, 
+                      quantity = 'stage', filename = 'centroid_error.png'):
+
+    n_triangles = num.sum(domain.tri_full_flag)
+    
+    if size() > 1:
+        # If parallel, translate control data to parallel indexing
+        local_control_data = num.zeros(n_triangles)
+        inv_tri_map = domain.get_inv_tri_map()
+        
+        for i in range(n_triangles):
+            local_control_data[i] = control_data[inv_tri_map[(rank(), i)]]
+    else:
+        local_control_data = control_data
+
+    # Evaluate absolute and relative difference between control and actual values
+    stage = domain.get_quantity(quantity)
+    actual_data = stage.centroid_values[:n_triangles]
+    adiff = num.fabs((actual_data - local_control_data))
+    rdiff = adiff/num.fabs(local_control_data)
+
+    # Compute masks for error (err_mask) and non-error (acc_mask) vertex indices based on thresholds
+    vertices = domain.get_vertex_coordinates()
+    err_mask = rdiff > rthr
+    err_mask[adiff <= athr] = False    
+    err_mask = num.repeat(err_mask, 3)
+
+    acc_mask = ~err_mask
+    inv_tri_map = domain.get_inv_tri_map()
+
+    # Plot error and non-error triangle
+    if rank() == 0:
+        fx = {}
+        fy = {}
+        gx = {}
+        gy = {}
+
+        fx[0] = vertices[acc_mask,0]
+        fy[0] = vertices[acc_mask,1]
+        gx[0] = vertices[err_mask,0]
+        gy[0] = vertices[err_mask,1]
+
+        # Receive vertex indices of non-error triangles (fx, fy) and error triangles (gx, gy)
+        for i in range(1,size()):
+            fx[i] = receive(i)
+            fy[i] = receive(i)
+            gx[i] = receive(i)
+            gy[i] = receive(i)
+
+        # Plot non-error triangles in green
+        for i in range(0,size()):
+            n = int(len(fx[i])/3)
+            triang = num.array(range(0,3*n))
+            triang.shape = (n, 3)
+
+            if len(fx[i]) > 0:
+                plt.triplot(fx[i], fy[i], triang, 'g-')
+
+        # Plot error triangles in blue
+        for i in range(0,size()):
+            n = int(len(gx[i])/3)
+                            
+            triang = num.array(range(0,3*n))
+            triang.shape = (n, 3)
+
+            if len(gx[i]) > 0: 
+                plt.triplot(gx[i], gy[i], triang, 'b--')
+                
+        # Save plot
+        plt.savefig(filename)
+        
+    else:
+        # Send error and non-error vertex indices to Proc 0
+        send(vertices[acc_mask,0], 0)
+        send(vertices[acc_mask,1], 0)
+        send(vertices[err_mask,0], 0)
+        send(vertices[err_mask,1], 0)      

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

@@ -0,0 +1,193 @@
+
+from anuga.shallow_water.shallow_water_domain import Domain
+from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular_cross, \
+                                                        rectangular
+
+from anuga.abstract_2d_finite_volumes.pmesh2domain import pmesh_to_domain_instance
+
+
+
+#-----------------------------
+# rectangular domains
+#-----------------------------
+def rectangular_cross_domain(*args, **kwargs):
+    """
+    Create a rectangular domain with triangulation made
+    up of m+1 by n+1 uniform rectangular cells divided
+    into 4 triangles in a cross pattern
+
+    Arguments
+    m:      number of cells in x direction
+    n:      number of cells in y direction
+    len1:   length of domain in x direction (left to right)
+            (default 1.0)
+    len2:   length of domain in y direction (bottom to top)
+            (default 1.0)
+    origin: tuple (x,y) specifying location of lower left corner
+            of domain (default (0,0))
+    """
+
+    try:
+        verbose = kwargs.pop('verbose')
+    except:
+        verbose = False
+
+
+    points, vertices, boundary = rectangular_cross(*args, **kwargs)
+    return Domain(points, vertices, boundary, verbose= verbose)
+
+#----------------------------
+# Create domain from file
+#----------------------------
+def create_domain_from_file(filename, DomainClass=Domain):
+    """
+    Create a domain from a file
+    """
+    return pmesh_to_domain_instance(filename,DomainClass=DomainClass)
+
+#---------------------------
+# Create domain from regions
+#---------------------------
+
+def create_domain_from_regions(bounding_polygon,
+                               boundary_tags,
+                               maximum_triangle_area=None,
+                               mesh_filename=None,
+                               interior_regions=None,
+                               interior_holes=None,
+                               hole_tags=None,
+                               poly_geo_reference=None,
+                               mesh_geo_reference=None,
+                               minimum_triangle_angle=28.0,
+                               fail_if_polygons_outside=True,
+                               use_cache=False,
+                               verbose=True):
+    """Create domain from bounding polygons and resolutions.
+
+    bounding_polygon is a list of points in Eastings and Northings,
+    relative to the zone stated in poly_geo_reference if specified.
+    Otherwise points are just x, y coordinates with no particular 
+    association to any location.
+
+    boundary_tags is a dictionary of symbolic tags. For every tag there
+    is a list of indices referring to segments associated with that tag.
+    If a segment is omitted it will be assigned the default tag ''.
+
+    maximum_triangle_area is the maximal area per triangle
+    for the bounding polygon, excluding the  interior regions.
+
+    Interior_regions is a list of tuples consisting of (polygon,
+    resolution) for each region to be separately refined. Do not have
+    polygon lines cross or be on-top of each other.  Also do not have
+    polygon close to each other.
+    
+    NOTE: If a interior_region is outside the bounding_polygon it should 
+    throw an error
+    
+    interior_holes is a list of polygons for each hole. These polygons do not
+    need to be closed, but their points must be specified in a counter-clockwise
+    order.
+
+    hole_tags  is a list of tag segment dictionaries.
+
+    This function does not allow segments to share points - use underlying
+    pmesh functionality for that
+
+    poly_geo_reference is the geo_reference of the bounding polygon and
+    the interior polygons.
+    If none, assume absolute.  Please pass one though, since absolute
+    references have a zone.
+    
+    mesh_geo_reference is the geo_reference of the mesh to be created.
+    If none is given one will be automatically generated.  It was use
+    the lower left hand corner of  bounding_polygon (absolute)
+    as the x and y values for the geo_ref.
+    
+    Returns the shallow water domain instance
+
+    Note, interior regions should be fully nested, as overlaps may cause
+    unintended resolutions. 
+
+    fail_if_polygons_outside: If True (the default) Exception in thrown
+    where interior polygons fall outside bounding polygon. If False, these
+    will be ignored and execution continued.
+        
+    
+    """
+
+
+    # Build arguments and keyword arguments for use with caching or apply.
+    args = (bounding_polygon,
+            boundary_tags)
+    
+    kwargs = {'maximum_triangle_area': maximum_triangle_area,
+              'mesh_filename': mesh_filename,
+              'interior_regions': interior_regions,
+              'interior_holes': interior_holes,
+              'hole_tags': hole_tags,
+              'poly_geo_reference': poly_geo_reference,
+              'mesh_geo_reference': mesh_geo_reference,
+              'minimum_triangle_angle': minimum_triangle_angle,
+              'fail_if_polygons_outside': fail_if_polygons_outside,
+              'verbose': verbose} #FIXME (Ole): See ticket:14
+
+    # Call underlying engine with or without caching
+    if use_cache is True:
+        try:
+            from anuga.caching import cache
+        except:
+            msg = 'Caching was requested, but caching module'+\
+                  'could not be imported'
+            raise (msg)
+
+
+        domain = cache(_create_domain_from_regions,
+                       args, kwargs,
+                       verbose=verbose,
+                       compression=False)
+    else:
+        domain = apply(_create_domain_from_regions,
+                       args, kwargs)
+
+    return domain
+
+        
+def _create_domain_from_regions(bounding_polygon,
+                                boundary_tags,
+                                maximum_triangle_area=None,
+                                mesh_filename=None,                           
+                                interior_regions=None,
+                                interior_holes=None,
+                                hole_tags=None,
+                                poly_geo_reference=None,
+                                mesh_geo_reference=None,
+                                minimum_triangle_angle=28.0,
+                                fail_if_polygons_outside=True,
+                                verbose=True):
+    """_create_domain_from_regions - internal function.
+
+    See create_domain_from_regions for documentation.
+    """
+
+    #from anuga.shallow_water.shallow_water_domain import Domain
+    from anuga.pmesh.mesh_interface import create_mesh_from_regions
+    
+    create_mesh_from_regions(bounding_polygon,
+                             boundary_tags,
+                             maximum_triangle_area=maximum_triangle_area,
+                             interior_regions=interior_regions,
+                             filename=mesh_filename,
+                             interior_holes=interior_holes,
+                             hole_tags=hole_tags,
+                             poly_geo_reference=poly_geo_reference,
+                             mesh_geo_reference=mesh_geo_reference,
+                             minimum_triangle_angle=minimum_triangle_angle,
+                             fail_if_polygons_outside=fail_if_polygons_outside,
+                             use_cache=False,
+                             verbose=verbose)
+
+    domain = Domain(mesh_filename, use_cache=False, verbose=verbose)
+
+
+    return domain
+

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

@@ -0,0 +1,54 @@
+"""Common file modules.
+
+    Here you will find modules to load, save, and extract information in a
+    variety of different file formats.
+    
+This module takes care of reading and writing datafiles such as topograhies,
+model output, etc
+
+
+Formats used within AnuGA:
+
+.sww: Netcdf format for storing model output f(t,x,y)
+.tms: Netcdf format for storing time series f(t)
+
+.csv: ASCII format for storing arbitrary points and associated attributes
+.pts: NetCDF format for storing arbitrary points and associated attributes
+
+.asc: ASCII format of regular DEMs as output from ArcView
+.prj: Associated ArcView file giving more meta data for asc format
+.ers: ERMapper header format of regular DEMs for ArcView
+
+.dem: NetCDF representation of regular DEM data
+
+.tsh: ASCII format for storing meshes and associated boundary and region info
+.msh: NetCDF format for storing meshes and associated boundary and region info
+
+.nc: Native ferret NetCDF format
+
+
+A typical dataflow can be described as follows
+
+Manually created files:
+ASC, PRJ:     Digital elevation models (gridded)
+TSH:          Triangular meshes (e.g. created from anuga.pmesh)
+NC            Model outputs for use as boundary conditions (e.g from MOST)
+
+
+AUTOMATICALLY CREATED FILES:
+
+ASC, PRJ  ->  DEM  ->  PTS: Conversion of DEM's to native pts file
+
+NC -> SWW: Conversion of MOST bundary files to boundary sww
+
+PTS + TSH -> TSH with elevation: Least squares fit
+
+TSH -> SWW:  Conversion of TSH to sww viewable using Swollen
+
+TSH + Boundary SWW -> SWW: Simluation using abstract_2d_finite_volumes    
+"""
+
+from numpy.testing import Tester
+test = Tester().test
+
+