Changeset 2666

Timestamp:

Apr 6, 2006, 11:07:20 AM (17 years ago)

Author:

ole

Message:

Introduced acceptable_overhoot limit in least_squares and tested it

Location:

inundation/pyvolution

Files:

• least_squares.py (modified) (4 diffs)
• test_least_squares.py (modified) (2 diffs)

inundation/pyvolution/least_squares.py

@@ -38 +38 @@
 
 
-
-acceptable_fit_overshoot = 1.001 #Must be larger than 1
 
 DEFAULT_ALPHA = 0.001
@@ -159 +157 @@
                 alpha = DEFAULT_ALPHA,
                 verbose = False,
+                acceptable_overshoot = 1,
                 expand_search = False,
                 data_origin = None,
@@ -181 +180 @@
 
           alpha: Smoothing parameter.
+
+          acceptable overshoot: controls the allowed factor by which fitted values
+          may exceed the value of input data. The lower limit is defined
+          as min(z) - acceptable_overshoot*delta z and upper limit
+          as max(z) + acceptable_overshoot*delta z
+          
 
           point_attributes: Vector or array of data at the point_coordinates.
@@ -252 +257 @@
         zeta = Zeta[:,i]
         z = Z[:,i]                
-        zc = Zc[:,i]        
+        zc = Zc[:,i]
+
+        max_zc = max(zc)
+        min_zc = min(zc)
+        delta_zc = max_zc-min_zc
+        upper_limit = max_zc + delta_zc*acceptable_overshoot
+        lower_limit = min_zc - delta_zc*acceptable_overshoot        
         
-        if max(zeta) > max(zc)*acceptable_fit_overshoot or\
-           min(zeta) < min(zc)/acceptable_fit_overshoot:
-            msg = 'Least sqares produced values outside the range of the input '
-            msg += 'data by a factor greater than %.2f. ' %acceptable_fit_overshoot
-            msg += 'z in [%f, %f], zeta in [%f, %f].\n' %(min(zc), max(zc),
+
+        if max(zeta) > upper_limit or min(zeta) < lower_limit:
+            msg = 'Least sqares produced values outside the allowed '
+            msg += 'range [%f, %f].\n' %(lower_limit, upper_limit)
+            msg += 'z in [%f, %f], zeta in [%f, %f].\n' %(min_zc, max_zc,
                                                           min(zeta), max(zeta))
-
-            offending_vertices = (zeta > max(zc)*acceptable_fit_overshoot) or\
-                                 (zeta < min(zc)/acceptable_fit_overshoot)
-
+            msg += 'If greater range is needed, increase the value of '
+            msg += 'acceptable_fit_overshoot (currently %f).\n' %(acceptable_overshoot)
+
+
+            offending_vertices = (zeta > upper_limit or zeta < lower_limit)
             Xi_c = compress(offending_vertices, Xi)
             Eta_c = compress(offending_vertices, Eta)

inundation/pyvolution/test_least_squares.py

@@ -1856 +1856 @@
         #Fit surface to mesh
         z = linear_function(data_points1) #Example z-values
-        v = fit_to_mesh(points, triangles, data_points1, z, alpha=0.0, 
-                        precrop=True, verbose=False)
+        v = fit_to_mesh(points, triangles, data_points1, z, alpha=0.0,
+                        precrop=True, verbose=False)
+
         assert allclose(linear_function(points), v)
+
+
+        
+    def test_acceptable_overshoot(self):
+        """Fit a surface to one set of points. Then interpolate that surface
+        using another set of points.
+        Check that exceedance in fitted values are caught.
+        """
+        from mesh import Mesh
+
+
+        #Setup mesh used to represent fitted function
+        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
+        triangles = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
+
+        #Datapoints to fit from
+        data_points1 = [[ 0.66666667, 0.66666667],
+                        [ 1.33333333, 1.33333333],
+                        [ 2.66666667, 0.66666667],
+                        [ 0.66666667, 2.66666667],
+                        [ 0.0, 1.0],
+                        [ 0.0, 3.0],
+                        [ 1.0, 0.0],
+                        [ 1.0, 1.0],
+                        [ 15, -17],   #Outside mesh
+                        [ 1.0, 2.0],
+                        [ 1.0, 3.0],
+                        [ 2.0, 1.0],
+                        [ 3.0, 0.0],
+                        [ 3.0, 1.0]]
+
+        #Fit surface to mesh
+        z = linear_function(data_points1) #Example z-values
+
+        try:
+            v = fit_to_mesh(points, triangles, data_points1, z, alpha=0.0,
+                            acceptable_overshoot = 0.2,
+                            precrop=True, verbose=False)
+        except FittingError, e:
+            pass
+        else:
+            raise 'Should have raised exception'
+            
+
+        #assert allclose(linear_function(points), v)
+        
 
         
@@ -1864 +1919 @@
 if __name__ == "__main__":
     #suite = unittest.makeSuite(Test_Least_Squares,'test_smooth_attributes_to_mesh_function')
-    suite = unittest.makeSuite(Test_Least_Squares,'test_fit_using_fit_to_mesh')
+    suite = unittest.makeSuite(Test_Least_Squares,'test')
 
     #suite = unittest.makeSuite(Test_Least_Squares,'test_fit_to_msh_netcdf_fileII')