anuga 1.3.5__zip

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

@@ -0,0 +1,12 @@
+"""
+    A simple implementation of the shallow wave equation, mainly for test
+    purposes.
+"""
+
+from advection import Advection_Domain
+
+from numpy.testing import Tester
+test = Tester().test
+
+
+

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

@@ -0,0 +1,298 @@
+"""Class Domain -
+2D triangular domains for finite-volume computations of
+the advection equation.
+
+This module contains a specialisation of class Domain from module domain.py
+consisting of methods specific to the advection equantion
+
+The equation is
+
+  u_t + (v_1 u)_x + (v_2 u)_y = 0
+
+There is only one conserved quantity, the stage u
+
+The advection equation is a very simple specialisation of the generic
+domain and may serve as an instructive example or a test of other
+components such as visualisation.
+
+Ole Nielsen, Stephen Roberts, Duncan Gray, Christopher Zoppou
+Geoscience Australia, 2004
+"""
+
+
+#import logging, logging.config
+#logger = logging.getLogger('advection')
+#logger.setLevel(logging.WARNING)
+#
+#try:
+#    logging.config.fileConfig('log.ini')
+#except:
+#    pass
+
+
+from anuga.abstract_2d_finite_volumes.generic_domain \
+                import Generic_Domain
+import anuga.utilities.log as log
+
+import numpy as num
+
+
+class Advection_Domain(Generic_Domain):
+
+    def __init__(self,
+                 coordinates,
+                 vertices,
+                 boundary = None,
+                 tagged_elements = None,
+                 geo_reference = None,
+                 use_inscribed_circle=False,
+                 velocity = None,
+                 full_send_dict=None,
+                 ghost_recv_dict=None,
+                 processor=0,
+                 numproc=1
+                 ):
+
+        conserved_quantities = ['stage']
+        other_quantities = []
+        Generic_Domain.__init__(self,
+                                source=coordinates,
+                                triangles=vertices,
+                                boundary=boundary,
+                                conserved_quantities=conserved_quantities,
+                                other_quantities=other_quantities,
+                                tagged_elements=tagged_elements,
+                                geo_reference=geo_reference,
+                                use_inscribed_circle=use_inscribed_circle,
+                                full_send_dict=full_send_dict,
+                                ghost_recv_dict=ghost_recv_dict,
+                                processor=processor,
+                                numproc=numproc)
+
+        if velocity is None:
+            self.velocity = num.array([1,0],'d')
+        else:
+            self.velocity = num.array(velocity,'d')
+
+        #Only first is implemented for advection
+        self.set_default_order(1)
+        self.set_beta(1.0)
+        
+        self.smooth = True
+        self.max_flux_update_frequency=1
+
+    def check_integrity(self):
+        Generic_Domain.check_integrity(self)
+
+        msg = 'Conserved quantity must be "stage"'
+        assert self.conserved_quantities[0] == 'stage', msg
+
+
+    def distribute_to_vertices_and_edges(self):
+        """Extrapolate conserved quantities from centroid to
+        vertices and edge-midpoints for each volume
+
+        Default implementation is straight first order,
+        i.e. constant values throughout each element and
+        no reference to non-conserved quantities.
+        """
+
+        for name in self.conserved_quantities:
+            Q = self.quantities[name]
+            if self._order_ == 1:
+                Q.extrapolate_first_order()
+            elif self._order_ == 2:
+                Q.extrapolate_second_order_and_limit_by_edge()
+                #Q.limit()
+            else:
+                raise Exception('Unknown order: %s' % str(self._order_))
+            #Q.interpolate_from_vertices_to_edges()
+
+
+
+
+    def flux_function(self, normal, ql, qr, zl=None, zr=None):
+        """Compute outward flux as inner product between velocity
+        vector v=(v_1, v_2) and normal vector n.
+
+        if <n,v> > 0 flux direction is outward bound and its magnitude is
+        determined by the quantity inside volume: ql.
+        Otherwise it is inbound and magnitude is determined by the
+        quantity outside the volume: qr.
+        """
+
+        v1 = self.velocity[0]
+        v2 = self.velocity[1]
+
+
+        normal_velocity = v1*normal[0] + v2*normal[1]
+
+        if normal_velocity < 0:
+            flux = qr * normal_velocity
+        else:
+            flux = ql * normal_velocity
+
+        max_speed = abs(normal_velocity)
+        return flux, max_speed
+
+
+
+    def compute_fluxes(self):
+        """Compute all fluxes and the timestep suitable for all volumes
+        in domain.
+
+        Compute total flux for each conserved quantity using "flux_function"
+
+        Fluxes across each edge are scaled by edgelengths and summed up
+        Resulting flux is then scaled by area and stored in
+        domain.explicit_update
+
+        The maximal allowable speed computed by the flux_function
+        for each volume
+        is converted to a timestep that must not be exceeded. The minimum of
+        those is computed as the next overall timestep.
+
+        Post conditions:
+        domain.explicit_update is reset to computed flux values
+        domain.timestep is set to the largest step satisfying all volumes.
+        """
+
+        import sys
+        from anuga.config import max_timestep
+
+
+        huge_timestep = float(sys.maxint)
+        Stage = self.quantities['stage']
+
+        """
+        log.critical("======================================")
+        log.critical("BEFORE compute_fluxes")
+        log.critical("stage_update=%s" % str(Stage.explicit_update))
+        log.critical("stage_edge=%s" % str(Stage.edge_values))
+        log.critical("stage_bdry=%s" % str(Stage.boundary_values))
+        log.critical("neighbours=%s" % str(self.neighbours))
+        log.critical("neighbour_edges=%s" % str(self.neighbour_edges))
+        log.critical("normals=%s" % str(self.normals))
+        log.critical("areas=%s" % str(self.areas))
+        log.critical("radii=%s" % str(self.radii))
+        log.critical("edgelengths=%s" % str(self.edgelengths))
+        log.critical("tri_full_flag=%s" % str(self.tri_full_flag))
+        log.critical("huge_timestep=%s" % str(huge_timestep))
+        log.critical("max_timestep=%s" % str(max_timestep))
+        log.critical("velocity=%s" % str(self.velocity))
+        """
+
+        import advection_ext		
+        self.flux_timestep = advection_ext.compute_fluxes(self, Stage, huge_timestep, max_timestep)
+
+
+
+##     def evolve(self,
+##                yieldstep = None,
+##                finaltime = None,
+##                duration = None,
+##                skip_initial_step = False):
+
+##         """Specialisation of basic evolve method from parent class
+##         """
+
+##         #Call basic machinery from parent class
+##         for t in Generic_domain.evolve(self,
+##                                        yieldstep=yieldstep,
+##                                        finaltime=finaltime,
+##                                        duration=duration,
+##                                        skip_initial_step=skip_initial_step):
+
+##             #Pass control on to outer loop for more specific actions
+##             yield(t)
+
+
+
+
+    def compute_fluxes_python(self):
+        """Compute all fluxes and the timestep suitable for all volumes
+        in domain.
+
+        Compute total flux for each conserved quantity using "flux_function"
+
+        Fluxes across each edge are scaled by edgelengths and summed up
+        Resulting flux is then scaled by area and stored in
+        domain.explicit_update
+
+        The maximal allowable speed computed by the flux_function
+        for each volume
+        is converted to a timestep that must not be exceeded. The minimum of
+        those is computed as the next overall timestep.
+
+        Post conditions:
+        domain.explicit_update is reset to computed flux values
+        domain.timestep is set to the largest step satisfying all volumes.
+        """
+
+        import sys
+        from anuga.config import max_timestep
+
+        N = len(self)
+
+        neighbours = self.neighbours
+        neighbour_edges = self.neighbour_edges
+        normals = self.normals
+
+        areas = self.areas
+        radii = self.radii
+        edgelengths = self.edgelengths
+
+        timestep = max_timestep #FIXME: Get rid of this
+
+        #Shortcuts
+        Stage = self.quantities['stage']
+
+        #Arrays
+        stage = Stage.edge_values
+
+        stage_bdry = Stage.boundary_values
+
+        flux = num.zeros(1, num.float) #Work array for summing up fluxes
+
+        #Loop
+        for k in range(N):
+            optimal_timestep = float(sys.maxint)
+
+            flux[:] = 0.  #Reset work array
+            for i in range(3):
+                #Quantities inside volume facing neighbour i
+                ql = stage[k, i]
+
+                #Quantities at neighbour on nearest face
+                n = neighbours[k,i]
+                if n < 0:
+                    m = -n-1 #Convert neg flag to index
+                    qr = stage_bdry[m]
+                else:
+                    m = neighbour_edges[k,i]
+                    qr = stage[n, m]
+
+
+                #Outward pointing normal vector
+                normal = normals[k, 2*i:2*i+2]
+
+                #Flux computation using provided function
+                edgeflux, max_speed = self.flux_function(normal, ql, qr)
+                flux -= edgeflux * edgelengths[k,i]
+
+                #Update optimal_timestep
+                if  self.tri_full_flag[k] == 1 :
+                    try:
+                        optimal_timestep = min(optimal_timestep, radii[k]/max_speed)
+                    except ZeroDivisionError:
+                        pass
+
+            #Normalise by area and store for when all conserved
+            #quantities get updated
+            flux /= areas[k]
+            Stage.explicit_update[k] = flux[0]
+
+            timestep = min(timestep, optimal_timestep)
+
+        self.timestep = timestep
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/advection/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('advection', parent_package, top_path)
+
+    config.add_data_dir('tests')
+
+    util_dir = os.path.abspath(join(os.path.dirname(__file__),'..','utilities'))
+            
+    config.add_extension('advection_ext',
+                         sources=['advection_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/advection/tests/__init__.py

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

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/advection/tests/test_advection.py

@@ -0,0 +1,183 @@
+import sys
+from os import sep
+
+import unittest
+from math import sqrt, pi
+
+from anuga.config import g, epsilon
+from anuga.abstract_2d_finite_volumes.generic_domain import Generic_Domain
+from anuga.abstract_2d_finite_volumes.generic_boundary_conditions import \
+                Transmissive_boundary, Dirichlet_boundary
+
+from anuga.advection.advection import Advection_Domain
+
+import numpy as num
+
+
+class Test_Advection(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_init(self):
+        a = [0.0, 0.0]
+        b = [0.0, 2.0]
+        c = [2.0,0.0]
+        d = [0.0, 4.0]
+        e = [2.0, 2.0]
+        f = [4.0,0.0]
+
+        points = [a, b, c, d, e, f]
+        #bac, bce, ecf, dbe, daf, dae
+        vertices = [ [1,0,2], [1,2,4], [4,2,5], [3,1,4]]
+
+        domain = Advection_Domain(points, vertices)
+        domain.check_integrity()
+
+        assert domain.quantities.has_key('stage')
+
+        assert domain.get_conserved_quantities(0, edge=1) == 0.
+
+
+    def test_flux_1_triangle0(self):
+        a = [0.0, 0.5]
+        b = [0.0, 0.0]
+        c = [0.5, 0.5]
+
+        points = [a, b, c]
+        vertices = [ [0,1,2] ]
+        domain = Advection_Domain(points, vertices)
+        domain.check_integrity()
+
+
+        #Populate boundary array with dirichlet conditions.
+        domain.neighbours = num.array([[-1,-2,-3]])
+        domain.quantities['stage'].boundary_values[:] = 1.0
+
+        domain.order = 1
+
+        domain.distribute_to_vertices_and_edges() #Use first order default
+
+        domain.check_integrity()
+
+        domain.compute_fluxes()
+        U = -domain.quantities['stage'].explicit_update
+        R = -0.5/domain.areas[0]
+
+        assert U==R, '%s %s' %(U, R)
+
+
+    def test_flux_1_triangle1(self):
+
+        a = [0.0, 0.5]
+        b = [0.0, 0.0]
+        c = [0.5, 0.5]
+
+        points = [a, b, c]
+        vertices = [ [0,1,2] ]
+        domain = Advection_Domain(points, vertices)
+        domain.check_integrity()
+
+        domain.set_quantity('stage', [1.0], location='centroids')
+
+        domain.distribute_to_vertices_and_edges()
+        domain.check_integrity()
+
+
+        domain.compute_fluxes()
+        U = -domain.quantities['stage'].explicit_update
+        R = 0.5/domain.areas[0]
+
+        assert U==R, '%s %s' %(U, R)
+
+
+
+    def test_flux_1_triangle2(self):
+
+        a = [0.0, 0.5]
+        b = [0.0, 0.0]
+        c = [0.5, 0.5]
+
+        points = [a, b, c]
+        vertices = [ [0,1,2] ]
+        domain = Advection_Domain(points, vertices)
+        domain.check_integrity()
+
+
+        #Populate boundary array with dirichlet conditions.
+        domain.neighbours = num.array([[-1,-2,-3]])
+        domain.quantities['stage'].boundary_values[0] = 1.0
+
+        domain.distribute_to_vertices_and_edges() #Use first order default
+
+        domain.check_integrity()
+
+        domain.compute_fluxes()
+        U = domain.quantities['stage'].explicit_update
+        assert num.allclose(U, 0)
+
+
+
+
+    def test_flux_2_triangles(self):
+        """Flow between two triangles
+        Check that fluxes have opposite signs
+        """
+
+        a = [0.0, 0.5]
+        b = [0.0, 0.0]
+        c = [0.5, 0.5]
+        d = [0.5, 0.0]
+
+        points = [a, b, c, d]
+        vertices = [ [0,1,2], [3,2,1] ]
+        domain = Advection_Domain(points, vertices)
+        domain.check_integrity()
+
+
+        #Populate boundary array with dirichlet conditions.
+        domain.neighbours = num.array([[1,-1,-2], [0,-3,-4]])
+        domain.set_quantity('stage', [1.0, 0.0], location='centroids')
+        domain.distribute_to_vertices_and_edges()
+
+        domain.compute_fluxes()
+
+        X = domain.quantities['stage'].explicit_update
+        assert X[0] == -X[1]
+
+
+    def test_advection_example(self):
+        #Test that system can evolve
+
+        from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular
+
+        points, vertices, boundary = rectangular(6, 6)
+
+        #Create advection domain with direction (1,-1)
+        domain = Advection_Domain(points, vertices, boundary,
+                                        velocity=[1.0, -1.0])
+
+        # Initial condition is zero by default
+
+        #Boundaries
+        T = Transmissive_boundary(domain)
+        D = Dirichlet_boundary(num.array([3.1415]))
+
+        domain.set_boundary( {'left': D, 'right': T, 'bottom': T, 'top': T} )
+        domain.check_integrity()
+
+        #Check that the boundary value gets propagated to all elements
+        for t in domain.evolve(yieldstep = 0.05, finaltime = 10):
+            if num.allclose(domain.quantities['stage'].centroid_values, 3.1415):
+                break
+
+        assert num.allclose(domain.quantities['stage'].centroid_values, 3.1415)
+
+
+#-------------------------------------------------------------
+if __name__ == "__main__":
+    suite = unittest.makeSuite(Test_Advection, 'test')
+    runner = unittest.TextTestRunner()
+    runner.run(suite)

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

@@ -0,0 +1,4 @@
+#nothing
+
+from numpy.testing import Tester
+test = Tester().test