anuga 1.3.5__zip

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

@@ -0,0 +1,170 @@
+"""
+Set w_uh_vh operator
+
+Constraints: See GPL license in the user guide
+Version: 1.0 ($Revision: 7731 $)
+"""
+
+__author__="steve"
+__date__ ="$09/03/2012 4:46:39 PM$"
+
+
+from anuga import Domain
+from anuga import Quantity
+import numpy as num
+import anuga.utilities.log as log
+
+from anuga.geometry.polygon import inside_polygon
+from anuga.utilities.function_utils import determine_function_type
+from anuga.utilities.numerical_tools import ensure_numeric
+
+from anuga.operators.base_operator import Operator
+from anuga import Region
+from anuga.fit_interpolate.interpolate import Modeltime_too_early, \
+                                              Modeltime_too_late
+from anuga.config import indent
+
+
+
+class Set_w_uh_vh_operator(Operator, Region):
+    """
+    Set the w, uh and vh in a region
+
+    indices: None == all triangles, Empty list [] no triangles
+
+    rate can be a function of time.
+
+    """
+
+    def __init__(self,
+                 domain,
+                 w_uh_vh=None,
+                 indices=None,
+                 polygon=None,
+                 center=None,
+                 radius=None,
+                 description = None,
+                 label = None,
+                 logging = False,
+                 verbose = False):
+
+
+        Operator.__init__(self, domain, description, label, logging, verbose)
+
+        Region.__init__(self, domain,
+                        indices=indices,
+                        polygon=polygon,
+                        center=center,
+                        radius=radius,
+                        verbose=verbose)
+
+        #print self.indices
+        self.set_w_uh_vh(w_uh_vh)
+        
+        #------------------------------------------
+        # Local variables
+        #------------------------------------------
+        #self.w_uh_vh = w_uh_vh
+
+
+    def __call__(self):
+        """
+        Apply w_uh_vh to those triangles defined in indices
+
+        indices == [], then don't apply anywhere
+        indices == None, then apply everywhere
+        otherwise apply for the specific indices
+        """
+
+
+        if self.indices is []:
+            return
+
+        w_uh_vh = self.get_w_uh_vh()
+
+        if w_uh_vh is None:
+            return
+
+        if self.verbose is True:
+            log.critical('w_uh_vh of %s at time = %.2f = %f'
+                         % (self.quantity_name, domain.get_time(), stage))
+
+        if self.indices is None:
+            self.stage_c[:] = w_uh_vh[0]
+            self.xmom_c[:]  = w_uh_vh[1]
+            self.ymom_c[:]  = w_uh_vh[2]
+        else:
+            self.stage_c[self.indices] = w_uh_vh[0]
+            self.xmom_c[self.indices]  = w_uh_vh[1]
+            self.ymom_c[self.indices]  = w_uh_vh[2]
+
+
+    def set_w_uh_vh(self, w_uh_vh = None):
+
+        self.w_uh_vh = w_uh_vh
+
+        self.w_uh_vh_type = determine_function_type(w_uh_vh)
+        if self.w_uh_vh_type == 'array':
+            self.w_uh_vh = ensure_numeric(self.w_uh_vh)
+        elif self.w_uh_vh_type == 'scalar':
+            self.w_uh_vh = float(self.w_uh_vh)
+
+        
+    def get_w_uh_vh(self, x = None, y = None, t = None):
+        """Get w_uh_vh value at time t.
+        If t not specified, return value at current domain time
+        """
+
+        #from anuga.fit_interpolate.interpolate import Modeltime_too_early, \
+        #                                              Modeltime_too_late
+
+
+        if t is None:
+            t = self.domain.get_time()
+
+        #print  self.w_uh_vh_type
+        
+        #try:
+        if self.w_uh_vh_type == 't':
+            w_uh_vh = self.w_uh_vh(t)
+        elif self.w_uh_vh_type == 'x,y':
+            w_uh_vh = self.w_uh_vh(x,y)
+        elif self.w_uh_vh_type == 'x,y,t':
+            w_uh_vh = self.w_uh_vh(x,y,t)
+        else:
+            w_uh_vh = self.w_uh_vh
+
+        #except Modeltime_too_early, e:
+        #    raise Modeltime_too_early(e)
+        #except Modeltime_too_late, e:
+        #    raise Modeltime_too_late(e)
+
+
+        return w_uh_vh
+
+
+
+    def parallel_safe(self):
+        """Operator is applied independently on each cell and
+        so is parallel safe.
+        """
+        return True
+
+    def statistics(self):
+
+        message = self.label + ': Set_w_uh_vh_operator'
+        message = message + ' on triangles '+ str(self.indices)
+        return message
+
+
+    def timestepping_statistics(self):
+
+        message  = indent + self.label + ': Set_w_uh_vh = ' + str(self.get_w_uh_vh())
+        return message
+
+
+
+
+
+
+

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

@@ -0,0 +1,33 @@
+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('operators', parent_package, top_path)
+
+    config.add_data_dir('tests')
+
+    util_dir = os.path.abspath(join(os.path.dirname(__file__),'..','utilities'))
+    
+    config.add_extension('mannings_operator_ext',
+                         sources=['mannings_operator_ext.c'],
+                         include_dirs=[util_dir])
+
+    config.add_extension('kinematic_viscosity_operator_ext',
+                         sources=['kinematic_viscosity_operator_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/operators/tests/test_base_operator.py

@@ -0,0 +1,51 @@
+from anuga import Domain
+from anuga import Dirichlet_boundary
+from anuga import Operator
+
+import numpy as num
+import unittest
+
+class Test_Operator(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_create_operator(self):
+        points = num.array([[0.0,0.0],[1.0,0.0],[0.0,1.0]])
+        
+        elements = num.array([[0,1,2]])
+        boundary_map = {}
+        boundary_map[(0,0)] = 'edge0'
+        boundary_map[(0,1)] = 'edge1'
+        boundary_map[(0,2)] = 'edge2'
+
+        domain = Domain(points, elements, boundary_map)
+
+        operator = Operator(domain)
+
+        message = operator.statistics()
+        assert message == 'You need to implement operator statistics for your operator'
+
+        message = operator.timestepping_statistics()
+        assert message == 'You need to implement timestepping statistics for your operator'
+
+        domain.timestep = 3.0
+
+        assert operator.get_timestep() == domain.get_timestep()
+        
+        try:
+            operator()
+        except:
+            pass
+        else:
+            raise Exception('should have raised an exception')
+
+
+################################################################################
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(Test_Operator, 'test')
+    runner = unittest.TextTestRunner()
+    runner.run(suite)

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/operators/tests/test_boundary_flux_integral_operator.py

@@ -0,0 +1,98 @@
+import unittest
+import anuga
+import numpy
+import os
+
+boundaryPolygon=[ [0., 0.], [0., 100.], [100.0, 100.0], [100.0, 0.0]]
+
+verbose=False
+
+class Test_boundary_flux_integral_operator(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        try:
+            os.remove('test_boundaryfluxintegral.msh')
+        except:
+            pass
+
+
+        try:
+            os.remove('test_boundaryfluxintegral.sww')
+        except:
+            pass
+
+    def create_domain(self, flowalg):
+        # Riverwall = list of lists, each with a set of x,y,z (and optional QFactor) values
+
+        # Make the domain
+        anuga.create_mesh_from_regions(boundaryPolygon, 
+                                 boundary_tags={'left': [0],
+                                                'top': [1],
+                                                'right': [2],
+                                                'bottom': [3]},
+                                   maximum_triangle_area = 200.,
+                                   minimum_triangle_angle = 28.0,
+                                   filename = 'test_boundaryfluxintegral.msh',
+                                   use_cache=False,
+                                   verbose=verbose)
+
+        domain=anuga.create_domain_from_file('test_boundaryfluxintegral.msh')
+
+        # 05/05/2014 -- riverwalls only work with DE0 and DE1
+        domain.set_flow_algorithm(flowalg)
+        domain.set_name('test_boundaryfluxintegral')
+
+        domain.set_store_vertices_uniquely()
+       
+        def topography(x,y):
+            return -x/150. 
+
+        # NOTE: Setting quantities at centroids is important for exactness of tests
+        domain.set_quantity('elevation',topography,location='centroids')     
+        domain.set_quantity('friction',0.03)             
+        domain.set_quantity('stage', topography,location='centroids')            
+       
+        # Boundary conditions
+        Br=anuga.Reflective_boundary(domain)
+        Bd=anuga.Dirichlet_boundary([0., 0., 0.])
+        domain.set_boundary({'left': Br, 'right': Bd, 'top': Br, 'bottom':Br})
+
+        return domain
+
+    def test_boundary_flux_operator_DE0(self):
+        """
+        A (the) boundary flux operator is instantiated when a domain is created.
+        This tests the calculation for euler timestepping 
+        """
+        
+        domain=self.create_domain('DE0')
+        for t in domain.evolve(yieldstep=0.1,finaltime=1.0):
+            pass
+        # The domain was initially dry
+        vol=domain.get_water_volume()
+        boundaryFluxInt=domain.get_boundary_flux_integral()
+
+        assert(numpy.allclose(vol,boundaryFluxInt))
+    
+    def test_boundary_flux_operator_DE1(self):
+        """
+        A (the) boundary flux operator is instantiated when a domain is created.
+        This tests the calculation for rk2 timestepping 
+        """
+        
+        domain=self.create_domain('DE1')
+        for t in domain.evolve(yieldstep=0.1,finaltime=1.0):
+            pass
+        # The domain was initially dry
+        vol=domain.get_water_volume()
+        boundaryFluxInt=domain.get_boundary_flux_integral()
+
+        assert(numpy.allclose(vol,boundaryFluxInt))
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(Test_boundary_flux_integral_operator, 'test')
+    runner = unittest.TextTestRunner(verbosity=1)
+    runner.run(suite)
+

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/operators/tests/test_erosion_operators.py

@@ -0,0 +1,344 @@
+"""  Test erosion operators
+"""
+
+import unittest, os
+import anuga
+from anuga import Domain
+from anuga import Reflective_boundary
+from anuga import rectangular_cross_domain
+from anuga import file_function
+
+from anuga.config import netcdf_mode_r, netcdf_mode_w, netcdf_mode_a
+from anuga.file_conversion.file_conversion import timefile2netcdf
+from anuga.config import time_format
+
+from anuga.operators.erosion_operators import Erosion_operator
+
+import numpy as num
+import warnings
+import time
+
+
+
+class Test_erosion_operators(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+
+
+    def test_erosion_operator_simple(self):
+        from anuga.config import rho_a, rho_w, eta_w
+        from math import pi, cos, sin
+
+        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
+        vertices = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
+
+        domain = Domain(points, vertices)
+
+        #Flat surface with 1m of water
+        domain.set_quantity('elevation', 0.5)
+        domain.set_quantity('stage', 1.0)
+        domain.set_quantity('friction', 0)
+        domain.set_quantity('xmomentum',2.0)
+        domain.set_quantity('ymomentum',3.0)
+
+        Stage = domain.quantities['stage'].centroid_values
+        Elevation = domain.quantities['elevation'].centroid_values
+
+        Height = Stage - Elevation
+
+        sum1 = num.sum(Height)
+
+        Br = Reflective_boundary(domain)
+        domain.set_boundary({'exterior': Br})
+
+
+#        print domain.quantities['stage'].centroid_values
+#        print domain.quantities['xmomentum'].centroid_values
+#        print domain.quantities['ymomentum'].centroid_values
+
+        # Apply operator to these triangles
+        indices = [0,1,3]
+
+
+        operator = Erosion_operator(domain, indices=indices, logging=True)
+
+        # Apply Operator
+        domain.timestep = 2.0
+        operator()
+
+        elev_ex  = [ 0.05555556,  0.11111111,  0.27777778,  0.05555556]
+        stage_ex = [ 0.55555556,  0.61111111,  0.77777778,  0.55555556]
+
+        Stage = domain.quantities['stage'].centroid_values
+        Elevation = domain.quantities['elevation'].centroid_values
+
+        Height = Stage - Elevation
+
+        sum2 = num.sum(Height)
+        
+        #print domain.quantities['elevation'].centroid_values
+        #print domain.quantities['stage'].centroid_values
+        #print domain.quantities['xmomentum'].centroid_values
+        #print domain.quantities['ymomentum'].centroid_values
+
+        assert sum1 == sum2
+        assert num.allclose(domain.quantities['stage'].centroid_values, stage_ex)
+        assert num.allclose(domain.quantities['xmomentum'].centroid_values, 2.0)
+        assert num.allclose(domain.quantities['ymomentum'].centroid_values, 3.0)
+
+
+
+#    def test_rate_operator_rate_from_file(self):
+#        from anuga.config import rho_a, rho_w, eta_w
+#        from math import pi, cos, sin
+#
+#        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
+#        vertices = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
+#
+#
+#        #---------------------------------
+#        #Typical ASCII file
+#        #---------------------------------
+#        finaltime = 1200
+#        filename = 'test_file_function'
+#        fid = open(filename + '.txt', 'w')
+#        start = time.mktime(time.strptime('2000', '%Y'))
+#        dt = 60  #One minute intervals
+#        t = 0.0
+#        while t <= finaltime:
+#            t_string = time.strftime(time_format, time.gmtime(t+start))
+#            fid.write('%s, %f %f %f\n' %(t_string, 2*t, t**2, sin(t*pi/600)))
+#            t += dt
+#
+#        fid.close()
+#
+#        #Convert ASCII file to NetCDF (Which is what we really like!)
+#        timefile2netcdf(filename+'.txt')
+#
+#
+#        #Create file function from time series
+#        F = file_function(filename + '.tms',
+#                          quantities = ['Attribute0',
+#                                        'Attribute1',
+#                                        'Attribute2'])
+#
+#        #Now try interpolation
+#        for i in range(20):
+#            t = i*10
+#            q = F(t)
+#
+#            #Exact linear intpolation
+#            assert num.allclose(q[0], 2*t)
+#            if i%6 == 0:
+#                assert num.allclose(q[1], t**2)
+#                assert num.allclose(q[2], sin(t*pi/600))
+#
+#        #Check non-exact
+#
+#        t = 90 #Halfway between 60 and 120
+#        q = F(t)
+#        assert num.allclose( (120**2 + 60**2)/2, q[1] )
+#        assert num.allclose( (sin(120*pi/600) + sin(60*pi/600))/2, q[2] )
+#
+#
+#        t = 100 #Two thirds of the way between between 60 and 120
+#        q = F(t)
+#        assert num.allclose( 2*120**2/3 + 60**2/3, q[1] )
+#        assert num.allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
+#
+#        #os.remove(filename + '.txt')
+#        #os.remove(filename + '.tms')
+#
+#
+#        domain = Domain(points, vertices)
+#
+#        #Flat surface with 1m of water
+#        domain.set_quantity('elevation', 0)
+#        domain.set_quantity('stage', 1.0)
+#        domain.set_quantity('friction', 0)
+#
+#        Br = Reflective_boundary(domain)
+#        domain.set_boundary({'exterior': Br})
+#
+##        print domain.quantities['elevation'].centroid_values
+##        print domain.quantities['stage'].centroid_values
+##        print domain.quantities['xmomentum'].centroid_values
+##        print domain.quantities['ymomentum'].centroid_values
+#
+#        # Apply operator to these triangles
+#        indices = [0,1,3]
+#
+#
+#        rate = file_function('test_file_function.tms', quantities=['Attribute1'])
+#
+#        factor = 1000.0
+#        default_rate= 17.7
+#
+#        operator = Rate_operator(domain, rate=rate, factor=factor, \
+#                      indices=indices, default_rate = default_rate)
+#
+#
+#        # Apply Operator
+#        domain.set_starttime(360.0)
+#        domain.timestep = 1.0
+#
+#        operator()
+#
+#
+#        d = domain.get_time()**2 * factor + 1.0
+#        stage_ex0 = [ d,  d,   1.,  d]
+#
+##        print d, domain.get_time(), F(360.0)
+#
+##        print domain.quantities['elevation'].centroid_values
+##        print domain.quantities['stage'].centroid_values
+##        print domain.quantities['xmomentum'].centroid_values
+##        print domain.quantities['ymomentum'].centroid_values
+#
+#        assert num.allclose(domain.quantities['stage'].centroid_values, stage_ex0)
+#        assert num.allclose(domain.quantities['xmomentum'].centroid_values, 0.0)
+#        assert num.allclose(domain.quantities['ymomentum'].centroid_values, 0.0)
+#
+#
+#        domain.set_starttime(-10.0)
+#        domain.timestep = 1.0
+#
+#        try:
+#            operator()
+#        except:
+#            pass
+#        else:
+#            raise Exception('Should have raised an exception, time too early')
+#
+#
+#        domain.set_starttime(1300.0)
+#        domain.timestep = 1.0
+#
+#        operator()
+#
+#        d = default_rate*factor + d
+#        stage_ex1 = [ d,  d,   1.,  d]
+#
+##        print domain.quantities['elevation'].centroid_values
+##        print domain.quantities['stage'].centroid_values
+##        print domain.quantities['xmomentum'].centroid_values
+##        print domain.quantities['ymomentum'].centroid_values
+#
+#        assert num.allclose(domain.quantities['stage'].centroid_values, stage_ex1)
+#        assert num.allclose(domain.quantities['xmomentum'].centroid_values, 0.0)
+#        assert num.allclose(domain.quantities['ymomentum'].centroid_values, 0.0)
+
+
+#    def test_rate_operator_functions_rate_default_rate(self):
+#        from anuga.config import rho_a, rho_w, eta_w
+#        from math import pi, cos, sin
+#
+#        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
+#        vertices = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
+#
+#        domain = Domain(points, vertices)
+#
+#        #Flat surface with 1m of water
+#        domain.set_quantity('elevation', 0)
+#        domain.set_quantity('stage', 1.0)
+#        domain.set_quantity('friction', 0)
+#
+#        Br = Reflective_boundary(domain)
+#        domain.set_boundary({'exterior': Br})
+#
+#        verbose = False
+#
+#        if verbose:
+#            print domain.quantities['elevation'].centroid_values
+#            print domain.quantities['stage'].centroid_values
+#            print domain.quantities['xmomentum'].centroid_values
+#            print domain.quantities['ymomentum'].centroid_values
+#
+#        # Apply operator to these triangles
+#        indices = [0,1,3]
+#        factor = 10.0
+#
+#
+#        def main_rate(t):
+#            if t > 20:
+#                msg = 'Model time exceeded.'
+#                raise Modeltime_too_late, msg
+#            else:
+#                return 3.0 * t + 7.0
+#
+#        default_rate = lambda t: 3*t + 7
+#
+#
+#        operator = Rate_operator(domain, rate=main_rate, factor=factor, \
+#                      indices=indices, default_rate = default_rate)
+#
+#
+#        # Apply Operator
+#        domain.timestep = 2.0
+#        operator()
+#
+#        t = operator.get_time()
+#        d = operator.get_timestep()*main_rate(t)*factor + 1
+#        stage_ex = [ d,  d,   1.,  d]
+#
+#        if verbose:
+#            print domain.quantities['elevation'].centroid_values
+#            print domain.quantities['stage'].centroid_values
+#            print domain.quantities['xmomentum'].centroid_values
+#            print domain.quantities['ymomentum'].centroid_values
+#
+#        assert num.allclose(domain.quantities['stage'].centroid_values, stage_ex)
+#        assert num.allclose(domain.quantities['xmomentum'].centroid_values, 0.0)
+#        assert num.allclose(domain.quantities['ymomentum'].centroid_values, 0.0)
+#
+#        domain.set_starttime(30.0)
+#        domain.timestep = 1.0
+#        operator()
+#
+#        t = operator.get_time()
+#        d = operator.get_timestep()*default_rate(t)*factor + d
+#        stage_ex = [ d,  d,   1.,  d]
+#
+#        if verbose:
+#            print domain.quantities['elevation'].centroid_values
+#            print domain.quantities['stage'].centroid_values
+#            print domain.quantities['xmomentum'].centroid_values
+#            print domain.quantities['ymomentum'].centroid_values
+#
+#        assert num.allclose(domain.quantities['stage'].centroid_values, stage_ex)
+#        assert num.allclose(domain.quantities['xmomentum'].centroid_values, 0.0)
+#        assert num.allclose(domain.quantities['ymomentum'].centroid_values, 0.0)
+
+            
+if __name__ == "__main__":
+    suite = unittest.makeSuite(Test_erosion_operators, 'test')
+    runner = unittest.TextTestRunner(verbosity=1)
+    runner.run(suite)