anuga 1.3.5__zip

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

@@ -0,0 +1,321 @@
+"""
+Define region
+"""
+
+__author__="steve"
+__date__ ="$09/03/2012 4:46:39 PM$"
+
+from anuga.utilities.numerical_tools import ensure_numeric
+
+from anuga import Domain
+from anuga import Quantity
+import numpy as num
+from pprint import pprint
+
+
+from anuga.geometry.polygon import inside_polygon, line_intersect
+
+from anuga.utilities.function_utils import determine_function_type
+
+#from anuga import indent
+
+
+class Region(object):
+    """
+    Setup region (defined by indices, polygon or center/radius). 
+    Useful in defining where to apply certain operations
+    
+    expand_polygon=True then calculation of intersection of polygon
+    with triangles based on vertices, otherwise based just on centroids
+    
+    """
+
+    def __init__(self,
+                 domain,
+                 indices=None,
+                 polygon=None,
+                 center=None,
+                 radius=None,
+                 line=None,
+                 poly=None,
+                 expand_polygon=False,
+                 verbose = False):
+
+
+        #------------------------------------------
+        # Local variables
+        #------------------------------------------
+        self.indices = indices
+        self.center = center
+        self.radius = radius
+        self.polygon = polygon
+        self.line = line
+        self.poly = poly
+
+        self.expand_polygon = expand_polygon
+        self.verbose =  verbose
+    
+        #------------------------------------------
+        #  Useful aliases
+        #------------------------------------------
+        self.domain = domain
+        self.coord_c = self.domain.centroid_coordinates
+        self.areas = self.domain.areas
+
+
+        #-------------------------------------------
+        # Work out indices associated with region:
+        #-------------------------------------------
+        if self.indices is not None:
+            # This overrides polygon, center and radius, line
+            
+            assert self.radius is None
+            assert self.center is None
+            assert self.polygon is None
+            assert self.line is None           
+        
+            self.indices = num.asarray(self.indices)
+
+            if self.indices.size == 0:
+                self.indices = []
+
+        elif (self.center is not None) and (self.radius is not None):
+
+            assert self.indices is None
+            assert self.polygon is None
+            assert self.line is None
+
+            self.setup_indices_circle()
+
+        elif (self.polygon is not None):
+
+            assert self.indices is None
+            assert self.radius is None
+            assert self.center is None
+            assert self.line is None
+
+            self.setup_indices_polygon()
+            
+        elif (self.line is not None):
+            
+            assert self.indices is None
+            assert self.radius is None
+            assert self.center is None
+            assert self.polygon is None
+
+            self.setup_indices_line() 
+            
+        elif (self.poly is not None):
+            # could be either a line or a polygon
+            # This is essentially for backwards compatibility
+            
+            assert self.indices is None
+            assert self.radius is None
+            assert self.center is None
+            assert self.polygon is None
+            assert self.line is None
+            
+            self.poly = num.asarray(self.poly)
+            if len(self.poly) > 2:
+                self.polygon = self.poly
+                self.setup_indices_polygon()                
+            else:
+                self.line = self.poly
+                self.setup_indices_line() 
+        else:
+            assert self.indices is None or self.indices is []
+
+        if self.indices is None:
+            self.full_indices = num.where(self.domain.tri_full_flag ==1)[0]
+        elif len(self.indices) == 0:
+            self.full_indices = []
+        else:
+            self.full_indices = self.indices[self.domain.tri_full_flag[self.indices]==1]
+
+        
+    def __repr__(self):
+        return "%s(%r)" % (self.__class__, self.__dict__)
+
+
+
+    def plot_region(self, filename=None):
+
+        try:
+            import matplotlib
+            #matplotlib.use('Agg')
+            import matplotlib.pyplot as plt
+            import matplotlib.tri as tri
+        except:
+            msg ="Couldn't import module from matplotlib, probably you need to update matplotlib"
+            raise msg
+
+        vertices = self.domain.get_vertex_coordinates()
+        full_mask = num.repeat(self.domain.tri_full_flag == 1, 3)
+
+        region_mask = num.zeros(len(self.domain),num.int).astype(bool)
+        region_mask[self.indices] = True
+        region_mask = num.repeat(region_mask,3)
+
+
+        #num.repeat(self.indices, 3)
+
+        #pprint(region_mask)
+
+        # Gather full and region nodes
+        fx = vertices[full_mask,0]
+        fy = vertices[full_mask,1]
+        gx = vertices[region_mask,0]
+        gy = vertices[region_mask,1]
+
+
+        # Plot mesh
+        n = int(len(fx)/3)
+        triang = num.array(range(0,3*n))
+        triang.shape = (n, 3)
+        plt.triplot(fx, fy, triang, 'b-')
+
+        # Plot region
+        n = int(len(gx)/3)
+        if n > 0:
+            triang = num.array(range(0,3*n))
+            triang.shape = (n, 3)
+            plt.triplot(gx, gy, triang, 'r-')
+
+        # Save triangulation to location pointed by filename
+        if filename is not None: plt.savefig(filename)
+        
+        plt.show()
+
+
+        
+    def setup_indices_circle(self):
+
+        # Determine indices in circular region
+        N = self.domain.get_number_of_triangles()
+        points = self.domain.get_centroid_coordinates(absolute=True)
+
+        indices = []
+
+        c = self.center
+        r = self.radius
+
+
+        intersect = False
+        for k in range(N):
+            x, y = points[k,:]    # Centroid
+
+            if ((x-c[0])**2+(y-c[1])**2) < r**2:
+                intersect = True
+                indices.append(k)
+
+        if len(indices) is 0:
+            self.indices = indices
+        else:
+            self.indices = num.asarray(indices)
+
+        if not self.domain.parallel:
+            msg = 'No centroids intersect circle center'+str(c)+' radius '+str(r)
+            if not intersect: raise Exception(msg)
+
+
+    def setup_indices_polygon(self):
+
+        # Determine indices for polygonal region
+        points = self.domain.get_centroid_coordinates(absolute=True)
+        vertex_coordinates = self.domain.get_vertex_coordinates(absolute=True)
+        
+        indices = inside_polygon(points, self.polygon)
+
+        if self.expand_polygon :
+            n = len(self.polygon)
+            for j in range(n):
+                tris_0 = line_intersect(vertex_coordinates,
+                                        [self.polygon[j],self.polygon[(j+1)%n]])
+                indices = num.union1d(tris_0, indices)            
+
+        if len(indices) is 0:
+            self.indices = indices
+        else:
+            self.indices = num.asarray(indices)
+
+        
+        if not self.domain.parallel:
+            # only warn if not parallel as we should get lots of subdomains without indices
+            if len(indices) is 0:
+                msg = 'No centroids found for polygon %s '% str(self.polygon)
+                import warnings
+                warnings.warn(msg)
+
+            
+            
+    def setup_indices_line(self):
+
+        # Determine indices for triangles intersecting a line  region
+        
+        vertex_coordinates = self.domain.get_vertex_coordinates(absolute=True)
+        
+        indices = line_intersect(vertex_coordinates, self.line) 
+        
+        if len(indices) is 0:
+            self.indices = indices
+        else:
+            self.indices = num.asarray(indices)
+
+        if not self.domain.parallel:
+            msg = 'No centroids intersecting line %s '% str(self.line)
+            if len(indices) is 0: raise Exception(msg)
+
+
+    def get_indices(self, full_only=True):
+
+        if full_only:
+            return self.full_indices
+        else:
+            return self.indices
+
+        
+        
+
+class Centroid_field(object):
+    
+    def __init__(self, region, value, verbose=None):
+        
+        self.region = region
+        self.value = value
+        self.domain = self.region.domain
+        
+        
+    def set_value(self,value):
+        """Set value
+        Can change value while running
+        Can be a scalar, or a function of t or x,y or x,y,t or a quantity
+        """
+
+        # Test if rate is a quantity
+        if isinstance(value, Quantity):
+            self.value_type = 'quantity'
+        else:
+            # Possible types are 'scalar', 't', 'x,y' and 'x,y,t'
+            from anuga.utilities.function_utils import determine_function_type
+            self.value_type = determine_function_type(value)
+
+        self.value = value
+        
+        if self.value_type == 'scalar':
+            self.value_callable = False
+            self.value_spatial = False
+        elif self.value_type == 'quantity':
+            self.value_callable = False
+            self.valuespatial = False
+        elif self.value_type == 't':
+            self.value_callable = True
+            self.value_spatial = False
+        else:
+            self.value_callable = True
+            self.value_spatial = True
+
+
+        
+        
+        
+

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

@@ -0,0 +1,48 @@
+from __future__ import division, print_function
+
+import os
+import sys
+
+from os.path import join
+
+def local_fun():
+    pass
+
+
+def configuration(parent_package='',top_path=None):
+    
+    from numpy.distutils.misc_util import Configuration
+    from numpy.distutils.system_info import get_info
+    
+    config = Configuration('abstract_2d_finite_volumes', parent_package, top_path)
+
+    config.add_data_dir('tests')
+
+    util_dir = os.path.abspath(join(os.path.dirname(__file__),'..','utilities'))    
+    
+    config.add_extension('neighbour_mesh_ext',
+                         sources=['neighbour_mesh_ext.c'],
+                         include_dirs=[util_dir])
+    
+    config.add_extension('mesh_factory_ext',
+                         sources=['mesh_factory_ext.c'],
+                         include_dirs=[util_dir])
+
+    config.add_extension('neighbour_table_ext',
+                         sources=['neighbour_table_ext.c'],
+                         include_dirs=[util_dir])
+
+    config.add_extension('pmesh2domain_ext',
+                         sources=['pmesh2domain_ext.c'],
+                         include_dirs=[util_dir])
+
+    config.add_extension('quantity_ext',
+                         sources=['quantity_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/abstract_2d_finite_volumes/tag_region.py

@@ -0,0 +1,167 @@
+"""region.py - Classes for implementing region conditions
+
+NOTE: I've only set it up for testing X values of constants and functions.
+Although it should work for vectors/arrays of values, that implies
+knowing info about the actual triangles, and that is not how the user should
+operate.
+"""
+# FIXME (DSG-DSG) add better comments
+
+import numpy as num
+
+
+class Tag_region:
+    """Base class for modifying quantities based on a region.
+    """   
+
+    def __init__(self, location='vertices'):
+        self.location = location
+        
+    def __call__(self, tag, elements, domain):
+        msg = 'Generic class Boundary must be subclassed'
+        raise Exception(msg)
+
+
+    def build_indices(self, elements, domain):
+        """
+        Return a list of triangle_id or vertex_id, depending on the location
+        """
+        if self.location == 'unique vertices':
+            return domain.get_unique_vertices(elements)
+        else:
+            return elements
+                
+class Set_tag_region(Tag_region):
+    
+    def __init__(self, tag, quantity, X, location='vertices'):
+        """ 
+        name: Name of quantity
+        X: const or function 
+        location: Where values are to be stored.
+        Permissible options are: vertices, centroid
+        """
+        
+        Tag_region.__init__(self)
+        self.tag = tag 
+        self.quantity = quantity
+        self.location = location
+        self.X = X
+
+    def __repr__(self):
+        pass
+    
+    def __call__(self, tag, elements, domain):
+        """
+        """    
+        if tag == self.tag:
+            domain.set_quantity(self.quantity,
+                                self.X,
+                                location=self.location,
+                                indices=self.build_indices(elements, domain))
+
+        
+class Add_value_to_region(Tag_region):
+    """
+    Will add a value to the current quantity value.
+    
+    quantity = initial_quantity + X.
+    
+    This method does not work with functions
+    
+    Use average to add X to a mean average of the quantity values.
+    eg if applying this to elevation this will give a flat roof.
+    """
+    
+    def __init__(self, tag, quantity, X, location='vertices', initial_quantity=None, average=False):
+        #I have to get this going!
+        #Region.__init__(self)
+        self.tag = tag 
+        self.quantity_answer = quantity
+        self.location = location
+        self.X = X
+        self.average = average
+        if initial_quantity is None:
+            self.quantity_initial_value = quantity
+        else:
+            self.quantity_initial_value = initial_quantity
+        if callable(X):
+            raise Exception('This class does not work with functions')
+
+    def __repr__(self):
+        pass
+    
+    def __call__(self, tag, elements, domain):
+        """
+        """    
+        if tag == self.tag:
+            #new_values = domain.get_quantity(self.quantity_initial_value,
+            #              indices=self.build_indices(elements, domain),
+            #              location=self.location) + self.X
+            Q = domain.get_quantity(self.quantity_initial_value)
+            if self.average is True:
+                # Average the points, and then the verts in the averaged point.  
+                values = Q.get_values(indices=self.build_indices(elements, domain),
+                                      location=self.location)
+                av = num.average(values)
+                if self.location == "vertices":
+                    av = num.average(av)
+                new_values = av + self.X    
+            else:
+                new_values = Q.get_values(indices=self.build_indices(elements, domain),
+                                      location=self.location) + self.X    
+            domain.set_quantity(self.quantity_answer, new_values,
+                                indices=self.build_indices(elements, domain),
+                                location=self.location)
+
+class Add_quantities(Tag_region):
+    """
+    Will add a quantity to the current quantity value.
+    """
+    
+    def __init__(self, tag, quantity_answer, adding_quantity, location='vertices'):
+        #I have to get this going!
+        #Region.__init__(self)
+        self.tag = tag 
+        self.quantity_answer = quantity_answer
+        self.adding_quantity = adding_quantity
+        self.location = location
+
+    def __repr__(self):
+        pass
+    
+    def __call__(self, tag, elements, domain):
+        """
+        """    
+        if tag == self.tag:
+
+            #new_values = domain.get_quantity(self.quantity_answer,
+            #              indices=self.build_indices(elements, domain),
+            #              location=self.location) \
+            #              + domain.get_quantity(self.adding_quantity,
+            #              indices=self.build_indices(elements, domain),
+            #              location=self.location)
+
+
+
+            indices = self.build_indices(elements, domain)
+            location = self.location
+            Q1 = domain.get_quantity(self.quantity_answer)
+            Q2 = domain.get_quantity(self.adding_quantity)            
+            new_values = Q1.get_values(indices=indices, location=location) +\
+                         Q2.get_values(indices=indices, location=location)
+
+            
+            domain.set_quantity(self.quantity_answer, new_values,
+                                indices=self.build_indices(elements, domain),
+                                location=self.location)
+
+
+class Stage_no_less_than_elevation(Tag_region):
+    """
+    Will set the stage to not be less than the elevation.
+    This would be good, but it's not region dependent.
+    Wait for it to become a default for pyvolution.
+    """
+    
+    def __init__(self):
+        pass

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

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

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/abstract_2d_finite_volumes/tests/show_balanced_limiters.py

@@ -0,0 +1,87 @@
+"""Example of shallow water wave equation.
+
+Specific methods pertaining to the 2D shallow water equation
+are imported from shallow_water
+for use with the generic finite volume framework
+
+Conserved quantities are h, uh and vh stored as elements 0, 1 and 2 in the
+numerical vector named conserved_quantities.
+"""
+
+######################
+# Module imports 
+#
+from anuga.shallow_water import Domain,\
+     Reflective_boundary, Dirichlet_boundary,\
+     Transmissive_boundary, Time_boundary
+from anuga.shallow_water.shallow_water_domain import Weir_simple as Weir
+import anuga.utilities.log as log
+
+from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular
+
+
+######################
+# Domain
+#
+
+N = 12
+
+log.critical('Creating domain')
+#Create basic mesh
+points, vertices, boundary = rectangular(N, N/2, len1=1.2,len2=0.6,
+                                         origin=(-0.07, 0))
+
+log.critical('Number of elements=%d' % len(vertices))
+#Create shallow water domain
+domain = Domain(points, vertices, boundary)
+domain.smooth = False
+domain.default_order = 2
+domain.set_name('show_balanced_limiters')
+domain.store = True
+domain.format = 'sww'   #Native netcdf visualisation format
+
+#Set bed-slope and friction
+inflow_stage = 0.1
+manning = 0.1
+Z = Weir(inflow_stage)
+
+log.critical('Field values')
+domain.set_quantity('elevation', Z)
+domain.set_quantity('friction', manning)
+
+
+######################
+# Boundary conditions
+#
+log.critical('Boundaries')
+Br = Reflective_boundary(domain)
+Bt = Transmissive_boundary(domain)
+
+#Constant inflow
+Bd = Dirichlet_boundary([inflow_stage, 0.0, 0.0])
+
+#Time dependent inflow
+from math import sin, pi
+Bw = Time_boundary(domain=domain,
+                   f=lambda x: [(1 + sin(x*pi/4))*\
+                                (inflow_stage*(sin(2.5*x*pi)+0.7)),0,0])
+
+#Set boundary conditions
+domain.set_boundary({'left': Bd, 'right': Br, 'bottom': Br, 'top': Br})
+
+                    
+
+######################
+#Initial condition
+#
+log.critical('Initial condition')
+domain.set_quantity('stage', Z)
+
+#Evolve
+for t in domain.evolve(yieldstep = 0.1, finaltime = 30):
+    domain.write_time(track_speeds=True)
+    domain.write_boundary_statistics(['stage'],'left')
+
+log.critical('Done')
+    
+