Changeset 209

Timestamp:

Aug 24, 2004, 12:10:48 PM (21 years ago)

Author:

ole

Message:

testing of set_value and a bit of name changing

Location:

inundation/ga/storm_surge/pyvolution

Files:

• domain.py (modified) (3 diffs)
• quantity.py (modified) (9 diffs)
• shallow_water.py (modified) (5 diffs)
• test_quantity.py (modified) (6 diffs)

inundation/ga/storm_surge/pyvolution/domain.py

@@ -133 +133 @@
         return q 
 
-    def set_quantity(self, name, values, location='vertices'):
+    def set_quantity(self, name, X, location='vertices'):
         """Set values for named quantity
 
         name: Name of quantity
-        values: Compatible list or Numeric array (see below)
+        X: Compatible list, Numeric array, const or function (see below)
         location: Where values are to be stored.
                   Permissible options are: vertices, edges, centroid
@@ -149 +149 @@
         """
 
-        self.quantities[name].set_values(values, location)
+        self.quantities[name].set_values(X, location)
         
 
@@ -461 +461 @@
             Q = self.quantities[name]
             if self.order == 1:
-                Q.first_order_extrapolator()
+                Q.extrapolate_first_order()
             elif self.order == 2:
-                Q.second_order_extrapolator()
-                Q.limiter()                                
+                Q.extrapolate_second_order()
+                Q.limit()                                
             else:
                 raise 'Unknown order'

inundation/ga/storm_surge/pyvolution/quantity.py

@@ -84 +84 @@
             self.edge_values[i, 2] = 0.5*(v0 + v1)
 
+
     def update(self, timestep):
         """Update centroid values based on values stored in
@@ -185 +186 @@
         
 
-    def limiter(self):
+    def limit(self):
         """Limit slopes for each volume to eliminate artificial variance
         introduced by e.g. second order extrapolator
@@ -245 +246 @@
 
         
-    def first_order_extrapolator(self):
+    def extrapolate_first_order(self):
         """Extrapolate conserved quantities from centroid to
         vertices for each volume using
@@ -258 +259 @@
             
             
-    def second_order_extrapolator(self):
+    def extrapolate_second_order(self):
         """Extrapolate conserved quantities from centroid to
         vertices for each volume using
@@ -322 +323 @@
 
 
-        #FIXME: Should do location erro check here only
-        
-
+        #FIXME: Should do location error check here only
+        
+        if location not in ['vertices', 'centroids', 'edges']:
+            msg = 'Invalid location: %s' %location
+            raise msg
+        
         import types
         
@@ -331 +335 @@
             self.set_function_values(X, location)            
         elif type(X) in [types.FloatType, types.IntType, types.LongType]:
-            if location == 'vertices':
-                self.vertex_values[:] = X
+            if location == 'centroids':
+                self.centroid_values[:] = X
             elif location == 'edges':
                 self.edge_values[:] = X
-            elif location == 'centroids':
-                self.centroid_values[:] = X
             else:
-                raise 'Invalid location: %s' %location                
+                self.vertex_values[:] = X                
+
         else:
             #Use array specific method
             self.set_array_values(X, location)
+
+        if location == 'vertices':
+            #Intialise centroid and edge_values
+            self.interpolate()
+            
 
 
@@ -353 +361 @@
         """
 
-
-        if location == 'vertices':
-            V = self.domain.get_vertex_coordinates()
-
+        if location == 'centroids':
+            P = self.domain.centroids
+            self.set_values(f(P[:,0], P[:,1]), location)
+        elif location == 'edges':
+            raise 'Not yet implemented: %s' %location
+        else:
+            #Vertices
+            P = self.domain.get_vertex_coordinates()
             for i in range(3):
-                self.set_values(f(V[:,2*i], V[:,2*i+1]), location)
-        elif location == 'edges':
-            raise 'Not yet implemented'
-        elif location == 'centroids':
-            V = self.domain.centroids
-            self.set_values(f(V[:,0], V[:,1]), location)            
-        else:
-            raise 'Invalid location: %s' %location                            
+                self.vertex_values[:,i] = f(P[:,2*i], P[:,2*i+1])
 
             
@@ -398 +403 @@
         assert values.shape[0] == N, msg
         
-        if location == 'vertices':
-            assert len(values.shape) == 2, 'Values array must be 2d'
-            msg = 'Array must be N x 3'            
-            assert values.shape[1] == 3, msg
-            
-            self.vertex_values = values
-            
-            #Intialise centroid and edge_values
-            self.interpolate()
+        if location == 'centroids':
+            assert len(values.shape) == 1, 'Values array must be 1d'
+            self.centroid_values = values                        
         elif location == 'edges':
             assert len(values.shape) == 2, 'Values array must be 2d'
@@ -413 +412 @@
             
             self.edge_values = values
-            
-        elif location == 'centroids':
-            assert len(values.shape) == 1, 'Values array must be 1d'
-            self.centroid_values = values                        
         else:
-            raise 'Invalid location: %s' %location
+            assert len(values.shape) == 2, 'Values array must be 2d'
+            msg = 'Array must be N x 3'            
+            assert values.shape[1] == 3, msg
+            
+            self.vertex_values = values
+

inundation/ga/storm_surge/pyvolution/shallow_water.py

@@ -274 +274 @@
     protect_against_infinitesimal_heights_centroid(domain)
     if domain.order == 1:
-        first_order_extrapolator(domain)
+        extrapolate_first_order(domain)
     elif domain.order == 2:
-        second_order_extrapolator(domain)        
+        extrapolate_second_order(domain)        
     else:
         raise 'Unknown order'
@@ -312 +312 @@
 
 
-def first_order_extrapolator(domain):
+def extrapolate_first_order(domain):
     """First order extrapolator function, specific
     to the shallow water wave equation.
@@ -332 +332 @@
     for name in domain.conserved_quantities:
         Q = domain.quantities[name]
-        Q.first_order_extrapolator()
+        Q.extrapolate_first_order()
         Q.interpolate_from_vertices_to_edges()        
      
@@ -396 +396 @@
 
         
-def second_order_extrapolator(domain):
+def extrapolate_second_order(domain):
     """Second order limiter function, specific to the shallow water wave
     equation.
@@ -427 +427 @@
         Q = domain.quantities[name]
 
-        Q.second_order_extrapolator()
+        Q.extrapolate_second_order()
         Q.limiter()
         Q.interpolate_from_vertices_to_edges()                

inundation/ga/storm_surge/pyvolution/test_quantity.py

@@ -145 +145 @@
 
 
+    def test_set_values_const(self):
+        quantity = Quantity(self.mesh4)
+
+        quantity.set_values(1.0, location = 'vertices')
+        assert allclose(quantity.vertex_values,
+                        [[1,1,1], [1,1,1], [1,1,1], [1, 1, 1]])
+        assert allclose(quantity.centroid_values, [1, 1, 1, 1]) #Centroid
+        assert allclose(quantity.edge_values, [[1, 1, 1],
+                                               [1, 1, 1],
+                                               [1, 1, 1],
+                                               [1, 1, 1]])
+
+
+        quantity.set_values(2.0, location = 'centroids')
+        assert allclose(quantity.centroid_values, [2, 2, 2, 2])
+
+        quantity.set_values(3.0, location = 'edges')
+        assert allclose(quantity.edge_values, [[3, 3, 3],
+                                               [3, 3, 3],
+                                               [3, 3, 3],
+                                               [3, 3, 3]])        
+
+
+    def test_set_values_func(self):
+        quantity = Quantity(self.mesh4)
+
+        def f(x, y):
+            return x+y
+
+        quantity.set_values(f, location = 'vertices')
+        assert allclose(quantity.vertex_values,
+                        [[2,0,2], [2,2,4], [4,2,4], [4,2,4]])        
+        assert allclose(quantity.centroid_values,
+                        [4.0/3, 8.0/3, 10.0/3, 10.0/3])
+        assert allclose(quantity.edge_values,
+                        [[1,2,1], [3,3,2], [3,4,3], [3,4,3]])                
+
+        
+        quantity.set_values(f, location = 'centroids')
+        assert allclose(quantity.centroid_values,
+                        [4.0/3, 8.0/3, 10.0/3, 10.0/3])        
+
+
     def test_gradient(self):
         quantity = Quantity(self.mesh4)
@@ -165 +208 @@
 
 
-        quantity.second_order_extrapolator()
+        quantity.extrapolate_second_order()
         
         assert allclose(quantity.vertex_values, [[2., 2.,  2.],
@@ -359 +402 @@
 
         #Extrapolate
-        quantity.first_order_extrapolator()
+        quantity.extrapolate_first_order()
 
         #Check vertices but not edge values
@@ -375 +418 @@
 
 
-        quantity.second_order_extrapolator()
-        quantity.limiter()
+        quantity.extrapolate_second_order()
+        quantity.limit()
 
 
@@ -408 +451 @@
 
         #Limit
-        quantity.limiter()
+        quantity.limit()
 
         #Assert that central triangle is limited by neighbours
@@ -439 +482 @@
 
         #Extrapolate
-        quantity.first_order_extrapolator()
+        quantity.extrapolate_first_order()
 
         #Interpolate