anuga 1.3.5__zip

Users/steve/Miniconda/envs/anuga/Lib/site-packages/anuga/mesh_engine/tests/test_generate_mesh.py

@@ -0,0 +1,470 @@
+#!/usr/bin/env python
+#
+"""
+I removed lone test vert's, since I'm working on removing lone verts at a lower
+level of the code, using the -j flag in triangle.
+"""
+
+
+import sys
+
+import unittest
+from anuga.mesh_engine.mesh_engine import generate_mesh
+
+import numpy as num
+
+from anuga.utilities.numerical_tools import ensure_numeric
+
+from anuga.anuga_exceptions import ANUGAError
+
+class triangTestCase(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def testrectangleIIb(self):
+        
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = []
+        regionlist.append( (1.2,1.2,5.0) )
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = []
+        
+        mode = "Qzp"
+        
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+
+        correct = num.array([(1, 0, 2), (2, 3, 1)])
+        self.assertTrue(num.alltrue(data['generatedtrianglelist'].flat == \
+                                    correct.flat),
+                        'trianglelist is wrong!')
+        correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
+                                    correct.flat),
+                        'segmentlist is wrong!')
+
+        correct = num.array([(0.0, 0.0), (0.0, 10.0),
+                             (3.0, 0.0), (3.0, 10.0)])
+        self.assertTrue(num.allclose(data['generatedpointlist'].flat, \
+                                     correct.flat),
+                        'Failed')
+     
+    def testrectangleIIc(self):
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = None
+        regionlist.append( (1.2,1.2,5.0) )
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = None
+        
+        mode = "Qzp"
+        
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+        correct = num.array([(1, 0, 2), (2, 3, 1)])
+        self.assertTrue(num.alltrue(data['generatedtrianglelist'].flat == \
+                                    correct.flat),
+                        'trianglelist is wrong!')
+        correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
+                                    correct.flat),
+                        'segmentlist is wrong!')
+
+        correct = num.array([(0.0, 0.0), (0.0, 10.0),
+                             (3.0, 0.0), (3.0, 10.0)])
+        self.assertTrue(num.allclose(data['generatedpointlist'].flat, \
+                                     correct.flat),
+                        'Failed')
+
+    def test_bad_point_atts(self):
+
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[],[],[]]
+        regionlist.append( (1.2,1.2,5.0) )
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [0,0,0,0]
+        
+        mode = "Qzp"
+        
+        try:
+            data = generate_mesh(points,seglist,holelist,
+                                  regionlist,pointattlist,segattlist,
+                                   mode, points)
+        except ANUGAError:
+            pass
+        else:
+            self.assertTrue(0 ==1,
+                        'bad list did not raise error!')
+            
+        
+    def test_bad_point_attsII(self):
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[1],[2],[3],[4,8]]
+        regionlist.append( (1.2,1.2,5.0) )
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [0,0,0,0]
+        
+        mode = "Qzp"
+        
+        try:
+            data = generate_mesh(points,seglist,holelist,
+                                  regionlist,pointattlist,segattlist,
+                                   mode, points)
+        except ANUGAError:
+            pass
+        else:
+            self.assertTrue(0 ==1,
+                        'bad list did not raise error!')
+            
+    def testsegmarker(self):
+
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[],[],[],[]]
+        regionlist.append( (1.2,1.2,5.0) )
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [1.0,2.0,3.0,4.0]
+        
+        mode = "Qzp"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+
+        correct = num.array([(1, 0, 2), (2, 3, 1)])
+        self.assertTrue(num.alltrue(data['generatedtrianglelist'].flat == \
+                                    correct.flat),
+                        'trianglelist is wrong!')
+        correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
+                                    correct.flat),
+                        'segmentlist is wrong!')
+
+        correct = num.array([(0.0, 0.0), (0.0, 10.0),
+                             (3.0, 0.0), (3.0, 10.0)])
+        self.assertTrue(num.allclose(data['generatedpointlist'].flat, \
+                                     correct.flat),
+                        'Failed')
+        
+        self.assertTrue(num.alltrue(data['generatedsegmentmarkerlist'] == \
+                                    num.array([1,2,3,4])),
+                        'Failed!')
+        
+    def testbad_region(self):
+
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = [(1.2,1.2)]
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[],[],[],[]]
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [0,0,0,0]
+        
+        mode = "Qzpn"
+        try:
+            data = generate_mesh(points,seglist,holelist,
+                                  regionlist,pointattlist,segattlist,
+                                   mode, points)
+        except ANUGAError:
+            pass
+        else:
+            self.assertTrue(0 ==1,
+                        'bad region list did not raise error!')
+
+    def testbad_regionII(self):
+
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = [(1.2,1.2), (1.2,1.25,1.0)]
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[],[],[],[]]
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [0,0,0,0]
+        
+        mode = "Qzpn"
+        try:
+            data = generate_mesh(points,seglist,holelist,
+                                  regionlist,pointattlist,segattlist,
+                                   mode, points)
+        except ANUGAError:
+            pass
+        else:
+            self.assertTrue(0==1,
+                        'bad region list did not raise error!')
+
+    def testregion_with_maxarea(self):
+
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = [(3,1,1.0)]
+
+        points = [(0.0,0.0),(6.0,0.0),(6.0,6.0),(0.0,6.0)]
+        pointattlist = [[],[],[],[]]
+        seglist = [(0,1),(1,2),(3,2),(3,0),(0,2)]
+        segattlist = [0,0,0,0,0]
+        
+        mode = "Qzpna36a"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist,  mode, points)
+
+        self.assertTrue(len(data['generatedtrianglelist']) == 2,
+                        'testregion_with_maxarea 1: # of tris is wrong!')
+        ## Another test case
+        regionlist = [(3,1,1.0),(1,3,1.0,8.0)]
+        mode = "Qzp21na36a"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist,  mode, points)
+        #print "len(data['generatedtrianglelist']",len(data['generatedtrianglelist'])
+        # for Duncan On unix this returns a 7 triangle result.
+        # for Duncan on Windows returns a 6 triangle result.
+        # for Ole on nautilus this returns 6
+        # for Duncan on nautilus this returns 7
+        # It seems to be the results from triangle that is
+        # causing the different results, and we are treating
+        # triangle as a back box.
+
+        self.assertTrue(len(data['generatedtrianglelist']) >= 6,
+                        'testregion_with_maxarea 2: # of tris is wrong!')
+        ## Another test case
+        regionlist = [(3,1,1.0,8.0),(1,3,1.0,8.0)]
+        mode = "Qzpna36a"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist,  mode, points)
+        #print "len(data['generatedtrianglelist']",len(data['generatedtrianglelist'])
+        # On unix this returns a 10 triangle result.
+        # Windows returns a 8 triangle result.
+        self.assertTrue(len(data['generatedtrianglelist']) >= 8,
+                        'testregion_with_maxarea 3: # of tris is wrong!')
+
+        ## Another test case
+        regionlist = [(3,1,1.0),(1,3,1.0,8.0)]
+        mode = "Qzpna8a"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist,  mode, points)
+        #print "len(data['generatedtrianglelist']",len(data['generatedtrianglelist'])
+        # On unix this returns a 10 triangle result.
+        # Windows returns a 8 triangle result.
+
+        self.assertTrue(len(data['generatedtrianglelist']) >= 8,
+                        'testregion_with_maxarea 4: # of tris is wrong!')
+
+
+    def FIXME_bad_hole(self):
+
+        holelist = [(9.0)]
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[],[],[],[]]
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [0,0,0,0]
+        
+        mode = "Qzpn"
+        try:
+            data = generate_mesh(points,seglist,holelist,regionlist,
+                                  pointattlist,segattlist,  mode, points)
+
+        except TypeError:
+            pass
+        else:
+            self.assertTrue(0 ==1,
+                        'bad hole list did not raise error!')
+
+
+    def testbad_segattlist(self):
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[],[],[],[]]
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [0,0]
+        
+        mode = "Qzpn"
+        try:
+            data = generate_mesh(points,seglist,holelist,regionlist,
+                                  pointattlist,segattlist, mode, points)
+            
+        except ANUGAError:
+            pass
+        else:
+            self.assertTrue(0 ==1,
+                        'bad segment attribute list did not raise error!')
+
+    def testrectangle_regions(self):
+
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[],[],[],[]]
+        #it seems that
+        #triangle only associates one region with a triangle
+        regionlist.append( (1.3,1.3,88.33) )
+        regionlist.append( (1.2,1.2,77,55) )
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [0,0,0,0]
+        mode = "QAzpq"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+
+        correct = num.array([[77.0], [77.0], [77.0], [77.0]])
+        self.assertTrue(num.allclose(data['generatedtriangleattributelist'].flat, 
+                                     correct.flat),
+                        'Failed')
+        
+    def testrectangle_regionsII(self):
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = [[],[],[],[]]
+        #it seems that
+        #triangle only associates one region with a triangle
+        regionlist.append( [1.3,1.3,88.33] )
+        regionlist.append( [1.2,1.2,77,55] )
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [0,0,0,0]
+        
+        mode = "QAzpq"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+
+        correct = num.array([[77.0], [77.0], [77.0], [77.0]])
+        self.assertTrue(num.allclose(data['generatedtriangleattributelist'].flat, 
+                                     correct.flat),
+                        'Failed')
+
+
+    def test_numeric_arrays(self):
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = []
+        points = [(0.0,0.0),(0.0,10.0),(3.0,0.0),(3.0,10.0)]
+        pointattlist = []
+        # 5.0 is the region tag, 99.0 is the max area
+        tri_tag = 123456.0
+        regionlist.append( [0.2,0.2, tri_tag,99.0] )
+        seglist = [(0,1),(1,3),(3,2),(2,0)]
+        segattlist = [21,22,23,24]
+         #The 'A' has to be there to get the region marker stuff working
+        mode = "QzpnA"
+        #mode = "jQpznAa2000.1a"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+        #print "data", data
+
+     
+        correct = num.array([(1, 0, 2), (2, 3, 1)])
+        self.assertTrue(num.alltrue(data['generatedtrianglelist'].flat == \
+                                    correct.flat),
+                        'trianglelist is wrong!')
+        correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
+                                    correct.flat),
+                        'segmentlist is wrong!')
+
+        correct = num.array([(0.0, 0.0), (0.0, 10.0),
+                             (3.0, 0.0), (3.0, 10.0)])
+        self.assertTrue(num.allclose(data['generatedpointlist'].flat, \
+                                     correct.flat),
+                        'Failed')
+        
+        correct = num.array([[tri_tag], [tri_tag]])
+        self.assertTrue(num.allclose(data['generatedtriangleattributelist'].flat, \
+                                     correct.flat),
+                        'Failed')
+        correct = num.array([(0, 1), (1, 3), (3, 2), (2, 0)])
+        self.assertTrue(num.alltrue(data['generatedsegmentlist'].flat == \
+                                    correct.flat),
+                        'Failed!')
+        
+        correct = num.array(segattlist, num.int)
+        self.assertTrue(num.allclose(data['generatedsegmentmarkerlist'].flat, 
+                                     correct.flat),
+                        'Failed')
+        
+        # I copied these answers from the output, so bad test..
+        correct = num.array([(-1, 1, -1), (-1, 0, -1)])
+        self.assertTrue(num.alltrue(data['generatedtriangleneighborlist'].flat == \
+                                    correct.flat),
+                        'Failed!')
+        
+        
+    def test_pointattlist(self):
+        # segattlist = []
+        points = []
+        seglist = []
+        holelist = []
+        regionlist = []
+
+        points = [(0.0,0.0),(0.0,4.0),(4.0,2.0),(2.0,0.0)]
+        pointattlist = [0.,0.,10.,10.]
+        regionlist.append( [0.2,0.2,2.1, 99.] )
+        seglist = [(0,1),(1,2),(2,3),(3,0)]
+        segattlist = [11,12,13,14]
+        mode = "Qzp"
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+
+        correct = num.array([[0.0],[0.0],[10],[10]])
+        self.assertTrue(num.allclose(data['generatedpointattributelist'].flat, \
+                                     correct.flat),
+                        'Failed')
+        
+        pointattlist = [[0.],[0.],[10.],[10.]]
+        mode = "Qzp"        
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+        correct = num.array([[0.0],[0.0],[10],[10]])
+        self.assertTrue(num.allclose(data['generatedpointattributelist'].flat, \
+                                     correct.flat),
+                        'Failed')
+        
+        pointattlist = [[0.,1],[0.,1],[10.,20],[10.,20]]
+        mode = "Qzp"        
+        data = generate_mesh(points,seglist,holelist,regionlist,
+                              pointattlist,segattlist, mode, points)
+        #print "data", data
+        correct = num.array(pointattlist)
+        self.assertTrue(num.allclose(data['generatedpointattributelist'].flat, \
+                                     correct.flat),
+                        'Failed')
+    
+
+if __name__ == "__main__":
+    suite = unittest.makeSuite(triangTestCase,'test')
+    runner = unittest.TextTestRunner()  #verbosity=2)
+    runner.run(suite)

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

@@ -0,0 +1,11 @@
+"""
+    operator classes for ANUGA.
+    
+"""
+
+from numpy.testing import Tester
+test = Tester().test
+
+
+
+

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

@@ -0,0 +1,125 @@
+
+from anuga.utilities.system_tools import log_to_file
+
+
+class Operator:
+    """Operator - generic structure for a fractional operator
+    
+    This is the base class for all fractional step operators
+    """ 
+
+    counter = 0
+
+    def __init__(self,
+                 domain,
+                 description = None,
+                 label = None,
+                 logging = False,
+                 verbose = False):
+        
+        self.domain = domain
+        self.domain.set_fractional_step_operator(self)
+
+
+        # useful aliases
+        self.stage_c = self.domain.quantities['stage'].centroid_values
+        self.xmom_c  = self.domain.quantities['xmomentum'].centroid_values
+        self.ymom_c  = self.domain.quantities['ymomentum'].centroid_values
+        self.elev_c  = self.domain.quantities['elevation'].centroid_values
+        self.coord_c = self.domain.centroid_coordinates
+        self.areas = self.domain.areas
+
+
+        if domain.numproc > 1:
+            msg = 'Not implemented to run in parallel'
+            assert self.parallel_safe(), msg
+
+        if description == None:
+            self.description = ' '
+        else:
+            self.description = description
+
+
+        self.set_label(label)
+
+
+        self.verbose = verbose
+
+        # Keep count of inlet operator
+        Operator.counter += 1
+
+        self.set_logging(logging)
+
+
+    def __call__(self):
+
+        #timestep = self.domain.get_timestep()
+        raise Exception('Need to implement __call__ for your operator')
+                    
+    def get_timestep(self):
+
+        return self.domain.get_timestep()
+
+
+    def get_time(self):
+
+        return self.domain.get_time()
+
+    def parallel_safe(self):
+        """By default an operator is not parallel safe
+        """
+        return False
+
+    def statistics(self):
+
+        message = 'You need to implement operator statistics for your operator'
+        return message
+    
+    def timestepping_statistics(self):
+
+        message  = 'You need to implement timestepping statistics for your operator'
+        return message
+
+
+    def print_statistics(self):
+
+        print self.statistics()
+
+    def print_timestepping_statistics(self):
+
+        print self.timestepping_statistics()
+
+
+    def log_timestepping_statistics(self):
+
+        from anuga.utilities.system_tools import log_to_file
+        if self.logging:
+            log_to_file(self.log_filename, self.timestepping_statistics())
+
+    def set_label(self, label=None):
+
+        if label == None:
+            self.label = "operator_%g" % Operator.counter
+        else:
+            self.label = label + '_%g' % Operator.counter
+
+
+    def set_logging(self, flag=True):
+
+        self.logging = flag
+        
+
+
+    def activate_logging(self):
+
+        # If flag is true open file with mode = "w" to form a clean file for logging
+        if self.logging:
+            self.log_filename = self.label + '.log'
+            log_to_file(self.log_filename, self.statistics(), mode='w')
+            #log_to_file(self.log_filename, 'time,Q')
+
+            #log_to_file(self.log_filename, self.culvert_type)
+
+
+
+

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

@@ -0,0 +1,79 @@
+"""
+
+Integrate the fluxes through the boundaries
+
+Relies on boundary_flux_sum being computed in
+compute_fluxes.
+
+
+
+"""
+
+__author__="gareth"
+__date__ ="$10/07/2014 $"
+
+
+
+import numpy as num
+from anuga.operators.base_operator import Operator
+
+class boundary_flux_integral_operator(Operator):
+    """
+    Simple operator to collect the integral of the boundary fluxes during a run
+    """
+
+    def __init__(self,
+                 domain,
+                 description = None,
+                 label = None,
+                 logging = False,
+                 verbose = False):
+
+
+        Operator.__init__(self, domain, description, label, logging, verbose)
+
+        #------------------------------------------
+        # Setup a quantity to store the boundary flux integral 
+        #------------------------------------------
+        self.boundary_flux_integral=num.array([0.])
+
+        # Alias for domain
+        self.domain=domain
+        
+
+    def __call__(self):
+        """
+        Accumulate boundary flux for each timestep
+        """
+
+        dt=self.domain.timestep
+        ts_method=self.domain.timestepping_method        
+        
+        if(ts_method=='euler'): 
+            self.boundary_flux_integral = self.boundary_flux_integral + dt*self.domain.boundary_flux_sum[0]
+        elif(ts_method=='rk2'):
+            self.boundary_flux_integral = self.boundary_flux_integral + 0.5*dt*self.domain.boundary_flux_sum[0:2].sum()
+        else:
+            raise Exception, 'Cannot compute boundary flux integral with this timestepping method'
+     
+        # Zero the boundary_flux_sum 
+        self.domain.boundary_flux_sum=self.domain.boundary_flux_sum*0.
+
+    def parallel_safe(self):
+        """Operator is applied independently on each parallel domain
+
+        """
+        return True
+
+    def statistics(self):
+
+        message = self.label + ': Boundary_flux_integral operator'
+        return message
+
+
+    def timestepping_statistics(self):
+        from anuga import indent
+
+        message  = indent + self.label + ': Integrating the boundary flux'
+        return message
+