Changeset 5903

Timestamp:

Nov 6, 2008, 3:37:26 PM (16 years ago)

Author:

rwilson

Message:

NumPy? conversion.

Location:

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes

Files:

• domain.py (modified) (16 diffs)
• ermapper_grids.py (modified) (1 diff)
• general_mesh.py (modified) (16 diffs)
• generic_boundary_conditions.py (modified) (8 diffs)
• mesh_factory.py (modified) (9 diffs)
• neighbour_mesh.py (modified) (21 diffs)
• pmesh2domain.py (modified) (4 diffs)
• quantity.py (modified) (23 diffs)
• region.py (modified) (3 diffs)
• show_balanced_limiters.py (modified) (3 diffs)
• test_domain.py (modified) (19 diffs)
• test_ermapper.py (modified) (2 diffs)
• test_general_mesh.py (modified) (20 diffs)
• test_generic_boundary_conditions.py (modified) (6 diffs)
• test_ghost.py (modified) (3 diffs)
• test_neighbour_mesh.py (modified) (49 diffs)
• test_pmesh2domain.py (modified) (6 diffs)
• test_quantity.py (modified) (6 diffs)
• test_region.py (modified) (14 diffs)
• test_util.py (modified) (66 diffs)
• util.py (modified) (20 diffs)

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/domain.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """Class Domain - 2D triangular domains for finite-volume computations of
    conservation laws.
@@ -10 +8 @@
 """
 
-##from numpy.oldnumeric import allclose, argmax, zeros, Float
-from numpy import allclose, argmax, zeros, float
+import numpy
+
 from anuga.config import epsilon
 from anuga.config import beta_euler, beta_rk2
@@ -108 +106 @@
 
         if verbose: print 'Initialising Domain'
-##        from numpy.oldnumeric import zeros, Float, Int, ones
-        from numpy import zeros, float, int, ones
         from quantity import Quantity
 
@@ -159 +155 @@
         for key in self.full_send_dict:
             buffer_shape = self.full_send_dict[key][0].shape[0]
-            self.full_send_dict[key].append(zeros( (buffer_shape,self.nsys) ,float))
+            self.full_send_dict[key].append(numpy.zeros( (buffer_shape,self.nsys), numpy.float))
 
 
         for key in self.ghost_recv_dict:
             buffer_shape = self.ghost_recv_dict[key][0].shape[0]
-            self.ghost_recv_dict[key].append(zeros( (buffer_shape,self.nsys) ,float))
+            self.ghost_recv_dict[key].append(numpy.zeros( (buffer_shape,self.nsys), numpy.float))
 
 
@@ -172 +168 @@
         N = len(self) #number_of_elements
         self.number_of_elements = N
-        self.tri_full_flag = ones(N, int)
+        self.tri_full_flag = numpy.ones(N, numpy.int)
         for i in self.ghost_recv_dict.keys():
             for id in self.ghost_recv_dict[i][0]:
@@ -179 +175 @@
         # Test the assumption that all full triangles are store before
         # the ghost triangles.
-        if not allclose(self.tri_full_flag[:self.number_of_full_nodes],1):
+        if not numpy.allclose(self.tri_full_flag[:self.number_of_full_nodes],1):
             print 'WARNING:  Not all full triangles are store before ghost triangles'
                         
@@ -234 +230 @@
         # calculation
         N = len(self) # Number_of_triangles
-        self.already_computed_flux = zeros((N, 3), int)
+        self.already_computed_flux = numpy.zeros((N, 3), numpy.int)
 
         # Storage for maximal speeds computed for each triangle by
         # compute_fluxes
         # This is used for diagnostics only (reset at every yieldstep)
-        self.max_speed = zeros(N, float)
+        self.max_speed = numpy.zeros(N, numpy.float)
 
         if mesh_filename is not None:
@@ -270 +266 @@
         """
 
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
-
         if not (vertex is None or edge is None):
             msg = 'Values for both vertex and edge was specified.'
@@ -278 +271 @@
             raise msg
 
-        q = zeros( len(self.conserved_quantities), float)
+        q = numpy.zeros( len(self.conserved_quantities), numpy.float)
 
         for i, name in enumerate(self.conserved_quantities):
@@ -774 +767 @@
             # Find index of largest computed flux speed
             if triangle_id is None:
-                k = self.k = argmax(self.max_speed)
+                k = self.k = numpy.argmax(self.max_speed)
             else:
                 errmsg = 'Triangle_id %d does not exist in mesh: %s' %(triangle_id,
@@ -1091 +1084 @@
 
         """
+        print '.evolve: 0'
 
         from anuga.config import min_timestep, max_timestep, epsilon
@@ -1101 +1095 @@
                %self.get_boundary_tags()
         assert hasattr(self, 'boundary_objects'), msg
+        print '.evolve: 1'
 
 
@@ -1109 +1104 @@
 
         self._order_ = self.default_order
+        print '.evolve: 2'
 
 
@@ -1132 +1128 @@
         self.number_of_first_order_steps = 0
 
-
+        print '.evolve: 3'
         # Update ghosts
         self.update_ghosts()
 
+        print '.evolve: 4'
         # Initial update of vertex and edge values
         self.distribute_to_vertices_and_edges()
 
+        print '.evolve: 5'
         # Update extrema if necessary (for reporting)
         self.update_extrema()
         
+        print '.evolve: 6'
         # Initial update boundary values
         self.update_boundary()
 
+        print '.evolve: 7'
         # Or maybe restore from latest checkpoint
         if self.checkpoint is True:
             self.goto_latest_checkpoint()
+        print '.evolve: 8'
 
         if skip_initial_step is False:
@@ -1207 +1208 @@
                 self.number_of_steps = 0
                 self.number_of_first_order_steps = 0
-                self.max_speed = zeros(N, float)
+                self.max_speed = numpy.zeros(N, numpy.float)
 
     def evolve_one_euler_step(self, yieldstep, finaltime):
@@ -1573 +1574 @@
         """
 
-##        from numpy.oldnumeric import ones, sum, equal, Float
-        from numpy import ones, sum, equal, float
-
         N = len(self) # Number_of_triangles
         d = len(self.conserved_quantities)

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/ermapper_grids.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
 # from os import open, write, read
-##import numpy.oldnumeric as Numeric
 import numpy
 

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/general_mesh.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
-
-##from numpy.oldnumeric import concatenate, reshape, take, allclose
-##from numpy.oldnumeric import array, zeros, Int, Float, sqrt, sum, arange
-from numpy import concatenate, reshape, take, allclose
-from numpy import array, zeros, int, float, sqrt, sum, arange
+import numpy
 
 from anuga.coordinate_transforms.geo_reference import Geo_reference
@@ -96 +90 @@
 ##        self.triangles = array(triangles, Int)
 ##        self.nodes = array(nodes, Float)
-        self.triangles = array(triangles, int)
-        self.nodes = array(nodes, float)
+        self.triangles = numpy.array(triangles, numpy.int)
+        self.nodes = numpy.array(nodes, numpy.float)
 
 
@@ -153 +147 @@
 
 ##        self.xy_extent = array(xy_extent, Float)
-        self.xy_extent = array(xy_extent, float)
+        self.xy_extent = numpy.array(xy_extent, numpy.float)
 
 
@@ -160 +154 @@
 ##        self.areas = zeros(N, Float)
 ##        self.edgelengths = zeros((N, 3), Float)
-        self.normals = zeros((N, 6), float)
-        self.areas = zeros(N, float)
-        self.edgelengths = zeros((N, 3), float)
+        self.normals = numpy.zeros((N, 6), numpy.float)
+        self.areas = numpy.zeros(N, numpy.float)
+        self.edgelengths = numpy.zeros((N, 3), numpy.float)
 
         # Get x,y coordinates for all triangles and store
@@ -197 +191 @@
             #   - Stored as six floats n0x,n0y,n1x,n1y,n2x,n2y per triangle
 
-            n0 = array([x2 - x1, y2 - y1])
-            l0 = sqrt(sum(n0**2))
-
-            n1 = array([x0 - x2, y0 - y2])
-            l1 = sqrt(sum(n1**2))
-
-            n2 = array([x1 - x0, y1 - y0])
-            l2 = sqrt(sum(n2**2))
+            n0 = numpy.array([x2 - x1, y2 - y1])
+            l0 = numpy.sqrt(numpy.sum(n0**2))
+
+            n1 = numpy.array([x0 - x2, y0 - y2])
+            l1 = numpy.sqrt(numpy.sum(n1**2))
+
+            n2 = numpy.array([x1 - x0, y1 - y0])
+            l2 = numpy.sqrt(numpy.sum(n2**2))
 
             # Normalise
@@ -284 +278 @@
         if absolute is True:
             if not self.geo_reference.is_absolute():
-                return V + array([self.geo_reference.get_xllcorner(),
-                                  self.geo_reference.get_yllcorner()])
+                return V + numpy.array([self.geo_reference.get_xllcorner(),
+                                        self.geo_reference.get_yllcorner()])
             else:
                 return V
@@ -321 +315 @@
             i = triangle_id
             msg = 'triangle_id must be an integer'
-            print 'type(triangle_id)=%s. triangle_id=%s' % (type(triangle_id), str(triangle_id))
             assert int(i) == i, msg
             assert 0 <= i < self.number_of_triangles
@@ -327 +320 @@
             i3 = 3*i  
             if absolute is True and not self.geo_reference.is_absolute():
-                offset=array([self.geo_reference.get_xllcorner(),
-                                  self.geo_reference.get_yllcorner()])
-                return array([V[i3,:]+offset,
-                              V[i3+1,:]+offset,
-                              V[i3+2,:]+offset])
+                offset = numpy.array([self.geo_reference.get_xllcorner(),
+                                      self.geo_reference.get_yllcorner()])
+                return numpy.array([V[i3,:]+offset,
+                                    V[i3+1,:]+offset,
+                                    V[i3+2,:]+offset])
             else:
-                return array([V[i3,:], V[i3+1,:], V[i3+2,:]])
+                return numpy.array([V[i3,:], V[i3+1,:], V[i3+2,:]])
                 
 
@@ -361 +354 @@
         M = self.number_of_triangles
 ##        vertex_coordinates = zeros((3*M, 2), Float)
-        vertex_coordinates = zeros((3*M, 2), float)
+        vertex_coordinates = numpy.zeros((3*M, 2), numpy.float)
 
         for i in range(M):
@@ -388 +381 @@
             indices = range(M)
 
-        return take(self.triangles, indices, axis=0)
+        return numpy.take(self.triangles, indices, axis=0)
     
 
@@ -422 +415 @@
         #T = reshape(array(range(K)).astype(Int), (M,3))
 ##        T = reshape(arange(K).astype(Int), (M,3))  # Faster
-        T = reshape(arange(K).astype(int), (M,3))  # Faster
+        T = numpy.reshape(numpy.arange(K).astype(numpy.int), (M,3))  # Faster
         
         return T     
@@ -452 +445 @@
         if node is not None:
             # Get index for this node
-            first = sum(self.number_of_triangles_per_node[:node])
+            first = numpy.sum(self.number_of_triangles_per_node[:node])
             
             # Get number of triangles for this node
@@ -465 +458 @@
                 triangle_list.append( (volume_id, vertex_id) )
 
-            triangle_list = array(triangle_list)    
+            triangle_list = numpy.array(triangle_list)    
         else:
             # Get info for all nodes recursively.
@@ -542 +535 @@
 
         # Count number of triangles per node
-        number_of_triangles_per_node = zeros(self.number_of_full_nodes)
+        number_of_triangles_per_node = numpy.zeros(self.number_of_full_nodes)
         for volume_id, triangle in enumerate(self.get_triangles()):
             for vertex_id in triangle:
@@ -548 +541 @@
 
         # Allocate space for inverted structure
-        number_of_entries = sum(number_of_triangles_per_node)
-        vertex_value_indices = zeros(number_of_entries)
+        number_of_entries = numpy.sum(number_of_triangles_per_node)
+        vertex_value_indices = numpy.zeros(number_of_entries, numpy.int)
 
         # Register (triangle, vertex) indices for each node
@@ -611 +604 @@
         """
 
-        return sum(self.areas)
-
-        
-        
+        return numpy.sum(self.areas)

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/generic_boundary_conditions.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """boundary.py - Classes for implementing boundary conditions
 """
@@ -9 +7 @@
 from anuga.fit_interpolate.interpolate import Modeltime_too_late
 from anuga.fit_interpolate.interpolate import Modeltime_too_early
+
+import numpy
 
 
@@ -69 +69 @@
             raise Exception, msg
 
-#        from numpy.oldnumeric import array, Float
-        from numpy import array, float
-        self.conserved_quantities=array(conserved_quantities).astype(float)
+        self.conserved_quantities=numpy.array(conserved_quantities).astype(numpy.float)
 
     def __repr__(self):
@@ -99 +97 @@
             raise msg
 
-
-#        from numpy.oldnumeric import array, Float
-        from numpy import array, float
         try:
-            q = array(q).astype(float)
+            q = numpy.array(q).astype(numpy.float)
         except:
             msg = 'Return value from time boundary function could '
@@ -140 +135 @@
     def __init__(self, filename, domain):
         import time
-#        from numpy.oldnumeric import array
-        from numpy import array
         from anuga.config import time_format
         from anuga.abstract_2d_finite_volumes.util import File_function
@@ -211 +204 @@
 
         import time
-#        from numpy.oldnumeric import array, zeros, Float
-        from numpy import array, zeros, float
         from anuga.config import time_format
         from anuga.abstract_2d_finite_volumes.util import file_function
@@ -228 +219 @@
 
         if verbose: print 'Find midpoint coordinates of entire boundary'
-        self.midpoint_coordinates = zeros( (len(domain.boundary), 2), float)
+        self.midpoint_coordinates = numpy.zeros( (len(domain.boundary), 2), numpy.float)
         boundary_keys = domain.boundary.keys()
 
@@ -248 +239 @@
             
             # Compute midpoints
-            if edge_id == 0: m = array([(x1 + x2)/2, (y1 + y2)/2])
-            if edge_id == 1: m = array([(x0 + x2)/2, (y0 + y2)/2])
-            if edge_id == 2: m = array([(x1 + x0)/2, (y1 + y0)/2])
+            if edge_id == 0: m = numpy.array([(x1 + x2)/2, (y1 + y2)/2])
+            if edge_id == 1: m = numpy.array([(x0 + x2)/2, (y0 + y2)/2])
+            if edge_id == 2: m = numpy.array([(x1 + x0)/2, (y1 + y0)/2])
 
             # Convert to absolute UTM coordinates

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/mesh_factory.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """Library of standard meshes and facilities for reading various
 mesh file formats
 """
+
+import numpy
 
 
@@ -75 +75 @@
 
     from anuga.config import epsilon
-#    from numpy.oldnumeric import zeros, Float, Int
-    from numpy import zeros, float, int
 
     delta1 = float(len1)/m
@@ -96 +94 @@
     index = Index(n,m)
 
-    points = zeros( (Np,2), float)
+    points = numpy.zeros( (Np,2), numpy.float)
 
     for i in range(m+1):
@@ -108 +106 @@
 
 
-    elements = zeros( (Nt,3), int)
+    elements = numpy.zeros( (Nt,3), numpy.int)
     boundary = {}
     nt = -1
@@ -152 +150 @@
 
     from anuga.config import epsilon
-#    from numpy.oldnumeric import zeros, Float, Int
-    from numpy import zeros, float, int
 
     delta1 = float(len1)/m
@@ -212 +208 @@
     """
 
-#    from numpy.oldnumeric import array
-    from numpy import array
     import math
 
@@ -516 +510 @@
 
 #    from numpy.oldnumeric import array
-    from numpy import array
     import math
 
@@ -598 +591 @@
     """
 
-#    from numpy.oldnumeric import array
-    from numpy import array
     import math
 
@@ -693 +684 @@
     """
 
-#    from numpy.oldnumeric import array
-    from numpy import array
     import math
-
     from anuga.config import epsilon
-
 
     deltax = lenx/float(m)

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/neighbour_mesh.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """Classes implementing general 2D triangular mesh with neighbour structure.
 
@@ -13 +11 @@
 from anuga.caching import cache
 from math import pi, sqrt
-#from numpy.oldnumeric import array, allclose
-from numpy import array, allclose
-        
+import numpy        
 
 class Mesh(General_mesh):
@@ -82 +78 @@
         """
 
-
-
-#        from numpy.oldnumeric import array, zeros, Int, Float, maximum, sqrt, sum
-        from numpy import array, zeros, int, float, maximum, sqrt, sum
-
         General_mesh.__init__(self, coordinates, triangles,
                               number_of_full_nodes=\
@@ -102 +93 @@
 
         #Allocate space for geometric quantities
-        self.centroid_coordinates = zeros((N, 2), float)
-
-        self.radii = zeros(N, float)
-
-        self.neighbours = zeros((N, 3), int)
-        self.neighbour_edges = zeros((N, 3), int)
-        self.number_of_boundaries = zeros(N, int)
-        self.surrogate_neighbours = zeros((N, 3), int)
+        self.centroid_coordinates = numpy.zeros((N, 2), numpy.float)
+
+        self.radii = numpy.zeros(N, numpy.float)
+
+        self.neighbours = numpy.zeros((N, 3), numpy.int)
+        self.neighbour_edges = numpy.zeros((N, 3), numpy.int)
+        self.number_of_boundaries = numpy.zeros(N, numpy.int)
+        self.surrogate_neighbours = numpy.zeros((N, 3), numpy.int)
 
         #Get x,y coordinates for all triangles and store
@@ -128 +119 @@
 
             #Compute centroid
-            centroid = array([(x0 + x1 + x2)/3, (y0 + y1 + y2)/3])
+            centroid = numpy.array([(x0 + x1 + x2)/3, (y0 + y1 + y2)/3])
             self.centroid_coordinates[i] = centroid
 
@@ -137 +128 @@
 
                 #Midpoints
-                m0 = array([(x1 + x2)/2, (y1 + y2)/2])
-                m1 = array([(x0 + x2)/2, (y0 + y2)/2])
-                m2 = array([(x1 + x0)/2, (y1 + y0)/2])
+                m0 = numpy.array([(x1 + x2)/2, (y1 + y2)/2])
+                m1 = numpy.array([(x0 + x2)/2, (y0 + y2)/2])
+                m2 = numpy.array([(x1 + x0)/2, (y1 + y0)/2])
 
                 #The radius is the distance from the centroid of
                 #a triangle to the midpoint of the side of the triangle
                 #closest to the centroid
-                d0 = sqrt(sum( (centroid-m0)**2 ))
-                d1 = sqrt(sum( (centroid-m1)**2 ))
-                d2 = sqrt(sum( (centroid-m2)**2 ))
+                d0 = numpy.sqrt(numpy.sum( (centroid-m0)**2 ))
+                d1 = numpy.sqrt(numpy.sum( (centroid-m1)**2 ))
+                d2 = numpy.sqrt(numpy.sum( (centroid-m2)**2 ))
 
                 self.radii[i] = min(d0, d1, d2)
@@ -154 +145 @@
                 #of inscribed circle is computed
 
-                a = sqrt((x0-x1)**2+(y0-y1)**2)
-                b = sqrt((x1-x2)**2+(y1-y2)**2)
-                c = sqrt((x2-x0)**2+(y2-y0)**2)
+                a = numpy.sqrt((x0-x1)**2+(y0-y1)**2)
+                b = numpy.sqrt((x1-x2)**2+(y1-y2)**2)
+                c = numpy.sqrt((x2-x0)**2+(y2-y0)**2)
 
                 self.radii[i]=2.0*self.areas[i]/(a+b+c)
@@ -392 +383 @@
             self.element_tag is defined
         """
-#        from numpy.oldnumeric import array, Int
-        from numpy import array, int
 
         if tagged_elements is None:
@@ -400 +389 @@
             #Check that all keys in given boundary exist
             for tag in tagged_elements.keys():
-                tagged_elements[tag] = array(tagged_elements[tag]).astype(int)
+                tagged_elements[tag] = numpy.array(tagged_elements[tag]).astype(numpy.int)
 
                 msg = 'Not all elements exist. '
@@ -468 +457 @@
         """
         
-#        from numpy.oldnumeric import allclose, sqrt, array, minimum, maximum
-        from numpy import allclose, sqrt, array, minimum, maximum
         from anuga.utilities.numerical_tools import angle, ensure_numeric     
 
@@ -483 +470 @@
         inverse_segments = {}
         p0 = None
-        mindist = sqrt(sum((pmax-pmin)**2)) # Start value across entire mesh
+        mindist = numpy.sqrt(numpy.sum((pmax-pmin)**2)) # Start value across entire mesh
         for i, edge_id in self.boundary.keys():
             # Find vertex ids for boundary segment
@@ -493 +480 @@
             B = self.get_vertex_coordinate(i, b, absolute=True) # End
 
-
             # Take the point closest to pmin as starting point
             # Note: Could be arbitrary, but nice to have
             # a unique way of selecting
-            dist_A = sqrt(sum((A-pmin)**2))
-            dist_B = sqrt(sum((B-pmin)**2))
+            dist_A = numpy.sqrt(numpy.sum((A-pmin)**2))
+            dist_B = numpy.sqrt(numpy.sum((B-pmin)**2))
 
             # Find lower leftmost point
@@ -599 +585 @@
                 # We have reached a point already visited. 
                 
-                if allclose(p1, polygon[0]):
+                if numpy.allclose(p1, polygon[0]):
                     # If it is the initial point, the polygon is complete. 
                     
@@ -635 +621 @@
         from anuga.utilities.numerical_tools import anglediff
 
-#        from numpy.oldnumeric import sort, allclose
-        from numpy import sort, allclose
-
         N = len(self)
 
@@ -679 +662 @@
 
                 # Normalise
-                l_u = sqrt(u[0]*u[0] + u[1]*u[1])
-                l_v = sqrt(v[0]*v[0] + v[1]*v[1])
+                l_u = numpy.sqrt(u[0]*u[0] + u[1]*u[1])
+                l_v = numpy.sqrt(v[0]*v[0] + v[1]*v[1])
 
                 msg = 'Normal vector in triangle %d does not have unit length' %i
-                assert allclose(l_v, 1), msg
+                assert numpy.allclose(l_v, 1), msg
 
                 x = (u[0]*v[0] + u[1]*v[1])/l_u # Inner product
@@ -737 +720 @@
 
         V = self.vertex_value_indices[:] #Take a copy
-        V = sort(V)
-        assert allclose(V, range(3*N))
+        V = numpy.sort(V)
+        assert numpy.allclose(V, range(3*N))
 
         assert sum(self.number_of_triangles_per_node) ==\
@@ -749 +732 @@
                 count[i] += 1
 
-        assert allclose(count, self.number_of_triangles_per_node)
+        assert numpy.allclose(count, self.number_of_triangles_per_node)
 
 
@@ -812 +795 @@
         """
 
-#        from numpy.oldnumeric import arange
-        from numpy import arange
         from anuga.utilities.numerical_tools import histogram, create_bins
 
@@ -1149 +1130 @@
 
             # Distances from line origin to the two intersections
-            z0 = array([x0 - xi0, y0 - eta0])
-            z1 = array([x1 - xi0, y1 - eta0])              
-            d0 = sqrt(sum(z0**2)) 
-            d1 = sqrt(sum(z1**2))
+            z0 = numpy.array([x0 - xi0, y0 - eta0])
+            z1 = numpy.array([x1 - xi0, y1 - eta0])              
+            d0 = numpy.sqrt(numpy.sum(z0**2)) 
+            d1 = numpy.sqrt(numpy.sum(z1**2))
                
             if d1 < d0:
@@ -1165 +1146 @@
             # Normal direction:
             # Right hand side relative to line direction
-            vector = array([x1 - x0, y1 - y0]) # Segment vector
-            length = sqrt(sum(vector**2))      # Segment length
-            normal = array([vector[1], -vector[0]])/length
+            vector = numpy.array([x1 - x0, y1 - y0]) # Segment vector
+            length = numpy.sqrt(numpy.sum(vector**2))      # Segment length
+            normal = numpy.array([vector[1], -vector[0]])/length
 
 
@@ -1247 +1228 @@
         assert isinstance(segment, Triangle_intersection), msg
         
-        midpoint = sum(array(segment.segment))/2
+        midpoint = numpy.sum(numpy.array(segment.segment))/2
         midpoints.append(midpoint)
 

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/pmesh2domain.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """Class pmesh2domain - Converting .tsh files to doamains
 
@@ -11 +9 @@
 import sys
 
+import numpy
 
 
@@ -163 +162 @@
     """
 
-#    from numpy.oldnumeric import transpose
-    from numpy import transpose
     from load_mesh.loadASCII import import_mesh_file
 
@@ -175 +172 @@
     volumes = mesh_dict['triangles']
     vertex_quantity_dict = {}
-    point_atts = transpose(mesh_dict['vertex_attributes'])
+    point_atts = numpy.transpose(mesh_dict['vertex_attributes'])
     point_titles  = mesh_dict['vertex_attribute_titles']
     geo_reference  = mesh_dict['geo_reference']
     if point_atts != None:
-        print 'type(point_atts)=%s' % type(point_atts)
         for quantity, value_vector in map(None, point_titles, point_atts):
             vertex_quantity_dict[quantity] = value_vector

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/quantity.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """Class Quantity - Implements values at each triangular element
 
@@ -17 +15 @@
 """
 
-#from numpy.oldnumeric import array, zeros, Float, less, concatenate, NewAxis,\
-#     argmax, argmin, allclose, take, reshape, alltrue, Int
-from numpy import array, zeros, float, less, concatenate, \
-     argmax, argmin, allclose, take, reshape, alltrue, int
+import numpy
 
 from anuga.utilities.numerical_tools import ensure_numeric, is_scalar
@@ -42 +37 @@
         if vertex_values is None:
             N = len(domain) # number_of_elements
-            self.vertex_values = zeros((N, 3), float)
+            self.vertex_values = numpy.zeros((N, 3), numpy.float)
         else:
-            self.vertex_values = array(vertex_values).astype(float)
+            self.vertex_values = numpy.array(vertex_values).astype(numpy.float)
 
             N, V = self.vertex_values.shape
@@ -61 +56 @@
 
         # Allocate space for other quantities
-        self.centroid_values = zeros(N, float)
-        self.edge_values = zeros((N, 3), float)
+        self.centroid_values = numpy.zeros(N, numpy.float)
+        self.edge_values = numpy.zeros((N, 3), numpy.float)
 
         # Allocate space for Gradient
-        self.x_gradient = zeros(N, float)
-        self.y_gradient = zeros(N, float)
+        self.x_gradient = numpy.zeros(N, numpy.float)
+        self.y_gradient = numpy.zeros(N, numpy.float)
 
         # Allocate space for Limiter Phi
-        self.phi = zeros(N, float)        
+        self.phi = numpy.zeros(N, numpy.float)        
 
         # Intialise centroid and edge_values
@@ -76 +71 @@
         # Allocate space for boundary values
         L = len(domain.boundary)
-        self.boundary_values = zeros(L, float)
+        self.boundary_values = numpy.zeros(L, numpy.float)
 
         # Allocate space for updates of conserved quantities by
@@ -82 +77 @@
 
         # Allocate space for update fields
-        self.explicit_update = zeros(N, float )
-        self.semi_implicit_update = zeros(N, float )
-        self.centroid_backup_values = zeros(N, float)
+        self.explicit_update = numpy.zeros(N, numpy.float )
+        self.semi_implicit_update = numpy.zeros(N, numpy.float )
+        self.centroid_backup_values = numpy.zeros(N, numpy.float)
 
         self.set_beta(1.0)
@@ -386 +381 @@
         from anuga.geospatial_data.geospatial_data import Geospatial_data
         from types import FloatType, IntType, LongType, ListType, NoneType
-##NumPy        from numpy.oldnumeric import ArrayType
-        from numpy import ndarray, float
 
         # Treat special case: Polygon situation
@@ -453 +446 @@
 
         msg = 'Indices must be a list or None'
-##NumPy        assert type(indices) in [ListType, NoneType, ArrayType], msg
-        assert type(indices) in [ListType, NoneType, ndarray], msg
+        assert type(indices) in [ListType, NoneType, numpy.ndarray], msg
 
 
@@ -464 +456 @@
                 self.set_values_from_constant(numeric,
                                               location, indices, verbose)
-##NumPy            elif type(numeric) in [ArrayType, ListType]:
-            elif type(numeric) in [ndarray, ListType]:
+            elif type(numeric) in [numpy.ndarray, ListType]:
                 self.set_values_from_array(numeric,
                                            location, indices, verbose)
@@ -617 +608 @@
         """
 
-#        from numpy.oldnumeric import array, Float, Int, allclose
-        from numpy import array, float, int, allclose
-
-        values = array(values).astype(float)
+        values = numpy.array(values).astype(numpy.float)
 
         if indices is not None:
-            indices = array(indices).astype(int)
+            indices = numpy.array(indices).astype(numpy.int)
             msg = 'Number of values must match number of indices:'
             msg += ' You specified %d values and %d indices'\
@@ -648 +636 @@
 
         elif location == 'unique vertices':
-            assert len(values.shape) == 1 or allclose(values.shape[1:], 1),\
+            assert len(values.shape) == 1 or numpy.allclose(values.shape[1:], 1),\
                    'Values array must be 1d'
 
@@ -684 +672 @@
         A = q.vertex_values
 
-#        from numpy.oldnumeric import allclose
-        from numpy import allclose
         msg = 'Quantities are defined on different meshes. '+\
               'This might be a case for implementing interpolation '+\
               'between different meshes.'
-        assert allclose(A.shape, self.vertex_values.shape), msg
+        assert numpy.allclose(A.shape, self.vertex_values.shape), msg
 
         self.set_values(A, location='vertices',
@@ -725 +711 @@
                 indices = range(len(self))
                 
-            V = take(self.domain.get_centroid_coordinates(), indices)
-            print 'V=%s' % str(V)
+            V = numpy.take(self.domain.get_centroid_coordinates(), indices, axis=0)
             self.set_values(f(V[:,0], V[:,1]),
                             location=location,
@@ -790 +775 @@
 
 
-        points = ensure_numeric(points, float)
-        values = ensure_numeric(values, float)
+        points = ensure_numeric(points, numpy.float)
+        values = ensure_numeric(values, numpy.float)
 
         if location != 'vertices':
@@ -923 +908 @@
         # Always return absolute indices
         if mode is None or mode == 'max':
-            i = argmax(V)
+            i = numpy.argmax(V)
         elif mode == 'min':    
-            i = argmin(V)
+            i = numpy.argmin(V)
 
             
@@ -1128 +1113 @@
         """
         
-#        from numpy.oldnumeric import take
-        from numpy import take
-
         # FIXME (Ole): I reckon we should have the option of passing a
         #              polygon into get_values. The question becomes how
@@ -1154 +1136 @@
             raise msg
 
-#        import types, numpy.oldnumeric as Numeric
         import types
-        from numpy import ndarray
-        
-        assert type(indices) in [types.ListType, types.NoneType, ndarray], \
+        
+        assert type(indices) in [types.ListType, types.NoneType, numpy.ndarray], \
                                  'Indices must be a list or None'
 
@@ -1164 +1144 @@
             if (indices ==  None):
                 indices = range(len(self))
-            return take(self.centroid_values,indices)
+            return numpy.take(self.centroid_values, indices, axis=0)
         elif location == 'edges':
             if (indices ==  None):
                 indices = range(len(self))
-            return take(self.edge_values,indices)
+            return numpy.take(self.edge_values, indices, axis=0)
         elif location == 'unique vertices':
             if (indices ==  None):
@@ -1191 +1171 @@
                     sum += self.vertex_values[triangle_id, vertex_id]
                 vert_values.append(sum/len(triangles))
-            return Numeric.array(vert_values)
+            return numpy.array(vert_values)
         else:
             if (indices is None):
                 indices = range(len(self))
-            return take(self.vertex_values, indices)
+            return numpy.take(self.vertex_values, indices, axis=0)
 
 
@@ -1209 +1189 @@
         """
 
-#        from numpy.oldnumeric import array, Float
-        from numpy import array, float
-
         # Assert that A can be converted to a Numeric array of appropriate dim
-        A = ensure_numeric(A, float)
+        A = ensure_numeric(A, numpy.float)
 
         # print 'SHAPE A', A.shape
@@ -1287 +1264 @@
         """
 
-#        from numpy.oldnumeric import concatenate, zeros, Float, Int, array, reshape
-        from numpy import concatenate, zeros, float, int, array, reshape
-
-
         if smooth is None:
             # Take default from domain
@@ -1299 +1272 @@
 
         if precision is None:
-            precision = float
+            precision = numpy.float
             
 
@@ -1308 +1281 @@
             V = self.domain.get_triangles()
             N = self.domain.number_of_full_nodes # Ignore ghost nodes if any
-            A = zeros(N, float)
+            A = numpy.zeros(N, numpy.float)
             points = self.domain.get_nodes()            
             

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/region.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """region.py - Classes for implementing region conditions
 
@@ -10 +8 @@
 # FIXME (DSG-DSG) add better comments
 
-from numpy.oldnumeric import average
+import numpy
+
+
 class Region:
     """Base class for modifying quantities based on a region.
@@ -103 +103 @@
                 values = Q.get_values(indices=self.build_indices(elements, domain),
                                       location=self.location)
-                av = average(values)
+                av = numpy.average(values)
                 if self.location == "vertices":
-                    av = average(av)
+                    av = numpy.average(av)
                 new_values = av + self.X    
             else:

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/show_balanced_limiters.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """Example of shallow water wave equation.
 
@@ -20 +18 @@
 
 from mesh_factory import rectangular
-from numpy.oldnumeric import array
-    
+
 
 ######################
@@ -80 +77 @@
 domain.set_quantity('stage', Z)
 
-from numpy.oldnumeric import allclose
-
 #Evolve
 for t in domain.evolve(yieldstep = 0.1, finaltime = 30):

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_domain.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
@@ -8 +6 @@
 from domain import *
 from anuga.config import epsilon
-##from numpy.oldnumeric import allclose, array, ones, Float, alltrue
-from numpy import allclose, array, ones, float, alltrue
+import numpy
 
 
@@ -67 +64 @@
 
 
-        assert alltrue(domain.get_conserved_quantities(0, edge=1) == 0.)
+        assert numpy.alltrue(domain.get_conserved_quantities(0, edge=1) == 0.)
 
 
@@ -98 +95 @@
         #Centroids
         q = domain.get_conserved_quantities(0)
-        assert allclose(q, [2., 2., 0.])
+        assert numpy.allclose(q, [2., 2., 0.])
 
         q = domain.get_conserved_quantities(1)
-        assert allclose(q, [5., 5., 0.])
+        assert numpy.allclose(q, [5., 5., 0.])
 
         q = domain.get_conserved_quantities(2)
-        assert allclose(q, [3., 3., 0.])
+        assert numpy.allclose(q, [3., 3., 0.])
 
         q = domain.get_conserved_quantities(3)
-        assert allclose(q, [0., 0., 0.])
+        assert numpy.allclose(q, [0., 0., 0.])
 
 
         #Edges
         q = domain.get_conserved_quantities(0, edge=0)
-        assert allclose(q, [2.5, 2.5, 0.])
+        assert numpy.allclose(q, [2.5, 2.5, 0.])
         q = domain.get_conserved_quantities(0, edge=1)
-        assert allclose(q, [2., 2., 0.])
+        assert numpy.allclose(q, [2., 2., 0.])
         q = domain.get_conserved_quantities(0, edge=2)
-        assert allclose(q, [1.5, 1.5, 0.])
+        assert numpy.allclose(q, [1.5, 1.5, 0.])
 
         for i in range(3):
             q = domain.get_conserved_quantities(1, edge=i)
-            assert allclose(q, [5, 5, 0.])
+            assert numpy.allclose(q, [5, 5, 0.])
 
 
         q = domain.get_conserved_quantities(2, edge=0)
-        assert allclose(q, [4.5, 4.5, 0.])
+        assert numpy.allclose(q, [4.5, 4.5, 0.])
         q = domain.get_conserved_quantities(2, edge=1)
-        assert allclose(q, [4.5, 4.5, 0.])
+        assert numpy.allclose(q, [4.5, 4.5, 0.])
         q = domain.get_conserved_quantities(2, edge=2)
-        assert allclose(q, [0., 0., 0.])
+        assert numpy.allclose(q, [0., 0., 0.])
 
 
         q = domain.get_conserved_quantities(3, edge=0)
-        assert allclose(q, [3., 3., 0.])
+        assert numpy.allclose(q, [3., 3., 0.])
         q = domain.get_conserved_quantities(3, edge=1)
-        assert allclose(q, [-1.5, -1.5, 0.])
+        assert numpy.allclose(q, [-1.5, -1.5, 0.])
         q = domain.get_conserved_quantities(3, edge=2)
-        assert allclose(q, [-1.5, -1.5, 0.])
+        assert numpy.allclose(q, [-1.5, -1.5, 0.])
 
 
@@ -182 +179 @@
         Q = domain.create_quantity_from_expression(expression)
 
-        assert allclose(Q.vertex_values, [[2,3,4], [6,6,6],
-                                      [1,1,10], [-5, 4, 4]])
+        assert numpy.allclose(Q.vertex_values, [[2,3,4], [6,6,6],
+                                                [1,1,10], [-5, 4, 4]])
 
         expression = '(xmomentum*xmomentum + ymomentum*ymomentum)**0.5'
@@ -191 +188 @@
         Y = domain.quantities['ymomentum'].vertex_values
 
-        assert allclose(Q.vertex_values, (X**2 + Y**2)**0.5)
+        assert numpy.allclose(Q.vertex_values, (X**2 + Y**2)**0.5)
 
 
@@ -317 +314 @@
         Q = domain.quantities['depth']
 
-        assert allclose(Q.vertex_values, [[2,3,4], [6,6,6],
-                                      [1,1,10], [-5, 4, 4]])
+        assert numpy.allclose(Q.vertex_values, [[2,3,4], [6,6,6],
+                                                [1,1,10], [-5, 4, 4]])
 
 
@@ -385 +382 @@
         domain.check_integrity()
 
-        assert allclose(domain.neighbours, [[-1,-2,-3]])
+        assert numpy.allclose(domain.neighbours, [[-1,-2,-3]])
 
 
@@ -474 +471 @@
                                       [0,0,9], [-6, 3, 3]])
 
-        assert allclose( domain.quantities['stage'].centroid_values,
-                         [2,5,3,0] )
+        assert numpy.allclose( domain.quantities['stage'].centroid_values,
+                               [2,5,3,0] )
 
         domain.set_quantity('xmomentum', [[1,1,1], [2,2,2],
@@ -487 +484 @@
 
         #First order extrapolation
-        assert allclose( domain.quantities['stage'].vertex_values,
-                         [[ 2.,  2.,  2.],
-                          [ 5.,  5.,  5.],
-                          [ 3.,  3.,  3.],
-                          [ 0.,  0.,  0.]])
+        assert numpy.allclose( domain.quantities['stage'].vertex_values,
+                               [[ 2.,  2.,  2.],
+                                [ 5.,  5.,  5.],
+                                [ 3.,  3.,  3.],
+                                [ 0.,  0.,  0.]])
 
 
@@ -530 +527 @@
 
         for name in domain.conserved_quantities:
-            domain.quantities[name].explicit_update = array([4.,3.,2.,1.])
-            domain.quantities[name].semi_implicit_update = array([1.,1.,1.,1.])
+            domain.quantities[name].explicit_update = numpy.array([4.,3.,2.,1.])
+            domain.quantities[name].semi_implicit_update = numpy.array([1.,1.,1.,1.])
 
 
@@ -538 +535 @@
         domain.update_conserved_quantities()
 
-        sem = array([1.,1.,1.,1.])/array([1, 2, 3, 4])
-        denom = ones(4, float)-domain.timestep*sem
+        sem = numpy.array([1.,1.,1.,1.])/numpy.array([1, 2, 3, 4])
+        denom = numpy.ones(4, numpy.float)-domain.timestep*sem
 
 #        x = array([1, 2, 3, 4]) + array( [.4,.3,.2,.1] )
 #        x /= denom
 
-        x = array([1., 2., 3., 4.])
+        x = numpy.array([1., 2., 3., 4.])
         x /= denom
-        x += domain.timestep*array( [4,3,2,1] )
+        x += domain.timestep*numpy.array( [4,3,2,1] )
 
         for name in domain.conserved_quantities:
-            assert allclose(domain.quantities[name].centroid_values, x)
+            assert numpy.allclose(domain.quantities[name].centroid_values, x)
 
 
@@ -581 +578 @@
                                       [0,0,9], [-6, 3, 3]])
 
-        assert allclose( domain.quantities['stage'].centroid_values,
-                         [2,5,3,0] )
+        assert numpy.allclose( domain.quantities['stage'].centroid_values,
+                               [2,5,3,0] )
 
         domain.set_quantity('xmomentum', [[1,1,1], [2,2,2],
@@ -594 +591 @@
 
         #First order extrapolation
-        assert allclose( domain.quantities['stage'].vertex_values,
-                         [[ 2.,  2.,  2.],
-                          [ 5.,  5.,  5.],
-                          [ 3.,  3.,  3.],
-                          [ 0.,  0.,  0.]])
+        assert numpy.allclose( domain.quantities['stage'].vertex_values,
+                               [[ 2.,  2.,  2.],
+                                [ 5.,  5.,  5.],
+                                [ 3.,  3.,  3.],
+                                [ 0.,  0.,  0.]])
 
         domain.build_tagged_elements_dictionary({'mound':[0,1]})
@@ -613 +610 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -631 +626 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -650 +643 @@
         domain.set_region([set_bottom_friction, set_top_friction])
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),\
-                        [[ 0.09,  0.09,  0.09],
-                         [ 0.09,  0.09,  0.09],
-                         [ 0.07,  0.07,  0.07],
-                         [ 0.07,  0.07,  0.07],
-                         [ 1.0,  1.0,  1.0],
-                         [ 1.0,  1.0,  1.0]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),\
+                              [[ 0.09,  0.09,  0.09],
+                               [ 0.09,  0.09,  0.09],
+                               [ 0.07,  0.07,  0.07],
+                               [ 0.07,  0.07,  0.07],
+                               [ 1.0,  1.0,  1.0],
+                               [ 1.0,  1.0,  1.0]])
 
         domain.set_region([set_all_friction])
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),
-                        [[ 10.09, 10.09, 10.09],
-                         [ 10.09, 10.09, 10.09],
-                         [ 10.07, 10.07, 10.07],
-                         [ 10.07, 10.07, 10.07],
-                         [ 11.0,  11.0,  11.0],
-                         [ 11.0,  11.0,  11.0]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),
+                              [[ 10.09, 10.09, 10.09],
+                               [ 10.09, 10.09, 10.09],
+                               [ 10.07, 10.07, 10.07],
+                               [ 10.07, 10.07, 10.07],
+                               [ 11.0,  11.0,  11.0],
+                               [ 11.0,  11.0,  11.0]])
 
 
@@ -675 +668 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -696 +687 @@
         
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),\
-                        [[ 0.09,  0.09,  0.09],
-                         [ 0.09,  0.09,  0.09],
-                         [ 0.07,  0.07,  0.07],
-                         [ 0.07,  0.07,  0.07],
-                         [ 1.0,  1.0,  1.0],
-                         [ 1.0,  1.0,  1.0]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),
+                              [[ 0.09,  0.09,  0.09],
+                               [ 0.09,  0.09,  0.09],
+                               [ 0.07,  0.07,  0.07],
+                               [ 0.07,  0.07,  0.07],
+                               [ 1.0,  1.0,  1.0],
+                               [ 1.0,  1.0,  1.0]])
         
         domain.set_region([set_bottom_friction, set_top_friction])
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),\
-                        [[ 0.09,  0.09,  0.09],
-                         [ 0.09,  0.09,  0.09],
-                         [ 0.07,  0.07,  0.07],
-                         [ 0.07,  0.07,  0.07],
-                         [ 1.0,  1.0,  1.0],
-                         [ 1.0,  1.0,  1.0]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),
+                              [[ 0.09,  0.09,  0.09],
+                               [ 0.09,  0.09,  0.09],
+                               [ 0.07,  0.07,  0.07],
+                               [ 0.07,  0.07,  0.07],
+                               [ 1.0,  1.0,  1.0],
+                               [ 1.0,  1.0,  1.0]])
 
         domain.set_region([set_all_friction])
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),
-                        [[ 10.09, 10.09, 10.09],
-                         [ 10.09, 10.09, 10.09],
-                         [ 10.07, 10.07, 10.07],
-                         [ 10.07, 10.07, 10.07],
-                         [ 11.0,  11.0,  11.0],
-                         [ 11.0,  11.0,  11.0]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),
+                              [[ 10.09, 10.09, 10.09],
+                               [ 10.09, 10.09, 10.09],
+                               [ 10.07, 10.07, 10.07],
+                               [ 10.07, 10.07, 10.07],
+                               [ 11.0,  11.0,  11.0],
+                               [ 11.0,  11.0,  11.0]])
 
 #-------------------------------------------------------------

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_ermapper.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
@@ -7 +5 @@
 
 import ermapper_grids
-##import numpy.oldnumeric as Numeric
 import numpy
 from os import remove

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_general_mesh.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
@@ -9 +7 @@
 
 from anuga.config import epsilon
-##from numpy.oldnumeric import allclose, array, ones, Float, alltrue
-from numpy import allclose, array, ones, float, alltrue
+import numpy
 from general_mesh import General_mesh
 from anuga.coordinate_transforms.geo_reference import Geo_reference
@@ -26 +23 @@
     def test_get_vertex_coordinates(self):
         from mesh_factory import rectangular
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -34 +29 @@
 
 
-        assert allclose(domain.get_nodes(), nodes)
+        assert numpy.allclose(domain.get_nodes(), nodes)
 
 
@@ -45 +40 @@
             for j in range(3):
                 k = triangles[i,j]  #Index of vertex j in triangle i
-                assert allclose(V[3*i+j,:], nodes[k])
+                assert numpy.allclose(V[3*i+j,:], nodes[k])
 
     def test_get_vertex_coordinates_with_geo_ref(self):
@@ -59 +54 @@
         f = [4.0, 0.0]
 
-        nodes = array([a, b, c, d, e, f])
+        nodes = numpy.array([a, b, c, d, e, f])
 
         nodes_absolute = geo.get_absolute(nodes)
         
         #bac, bce, ecf, dbe, daf, dae
-        triangles = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+        triangles = numpy.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
 
         domain = General_mesh(nodes, triangles,
                        geo_reference = geo)
         verts = domain.get_vertex_coordinates(triangle_id=0)        
-        self.assert_(allclose(array([b,a,c]), verts)) 
+        self.assert_(numpy.allclose(numpy.array([b,a,c]), verts)) 
         verts = domain.get_vertex_coordinates(triangle_id=0)       
-        self.assert_(allclose(array([b,a,c]), verts))
+        self.assert_(numpy.allclose(numpy.array([b,a,c]), verts))
         verts = domain.get_vertex_coordinates(triangle_id=0,
                                               absolute=True)       
-        self.assert_(allclose(array([nodes_absolute[1],
-                                     nodes_absolute[0],
-                                     nodes_absolute[2]]), verts))
+        self.assert_(numpy.allclose(numpy.array([nodes_absolute[1],
+                                                 nodes_absolute[0],
+                                                 nodes_absolute[2]]), verts))
         verts = domain.get_vertex_coordinates(triangle_id=0,
                                               absolute=True)       
-        self.assert_(allclose(array([nodes_absolute[1],
-                                     nodes_absolute[0],
-                                     nodes_absolute[2]]), verts))
+        self.assert_(numpy.allclose(numpy.array([nodes_absolute[1],
+                                                 nodes_absolute[0],
+                                                 nodes_absolute[2]]), verts))
         
         
@@ -90 +85 @@
         """
         from mesh_factory import rectangular
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -98 +91 @@
 
 
-        assert allclose(domain.get_nodes(), nodes)
+        assert numpy.allclose(domain.get_nodes(), nodes)
 
 
@@ -109 +102 @@
             for j in range(3):
                 k = triangles[i,j]  #Index of vertex j in triangle i
-                assert allclose(V[j,:], nodes[k])
+                assert numpy.allclose(V[j,:], nodes[k])
 
 
@@ -119 +112 @@
         """
         from mesh_factory import rectangular
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -127 +118 @@
 
         value = [7]
-        assert allclose(domain.get_triangles(), triangles)
-        assert allclose(domain.get_triangles([0,4]),
-                        [triangles[0], triangles[4]])
+        assert numpy.allclose(domain.get_triangles(), triangles)
+        assert numpy.allclose(domain.get_triangles([0,4]),
+                              [triangles[0], triangles[4]])
         
 
@@ -136 +127 @@
         """
         from mesh_factory import rectangular
-##        from numpy.oldnumeric import zeros, Float, array
-        from numpy import zeros, float, array
-
-        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]
-
-        nodes = array([a, b, c, d, e, f])
+
+        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]
+
+        nodes = numpy.array([a, b, c, d, e, f])
         #bac, bce, ecf, dbe, daf, dae
-        triangles = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+        triangles = numpy.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
 
         domain1 = General_mesh(nodes, triangles)
@@ -169 +158 @@
             #print count
             #
-            assert allclose(count, domain.number_of_triangles_per_node)
+            assert numpy.allclose(count, domain.number_of_triangles_per_node)
             
             # Check indices
@@ -203 +192 @@
         f = [4.0, 0.0]
 
-        nodes = array([a, b, c, d, e, f])
+        nodes = numpy.array([a, b, c, d, e, f])
         #bac, bce, ecf, dbe, daf, dae
-        triangles = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+        triangles = numpy.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
 
         domain = General_mesh(nodes, triangles)
@@ -211 +200 @@
         # One node
         L = domain.get_triangles_and_vertices_per_node(node=2)
-        print 'L=%s' % str(L)
-        assert allclose(L[0], [0, 2])
-        assert allclose(L[1], [1, 1])
-        assert allclose(L[2], [2, 1])
+        assert numpy.allclose(L[0], [0, 2])
+        assert numpy.allclose(L[1], [1, 1])
+        assert numpy.allclose(L[2], [2, 1])
 
         # All nodes
@@ -221 +209 @@
         for i, Lref in enumerate(ALL):
             L = domain.get_triangles_and_vertices_per_node(node=i)
-            assert allclose(L, Lref)
+            assert numpy.allclose(L, Lref)
             
 
@@ -232 +220 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -248 +234 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-##        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -283 +267 @@
         f = [4.0, 0.0]
 
-        nodes = array([a, b, c, d, e, f])
+        nodes = numpy.array([a, b, c, d, e, f])
 
         nodes_absolute = geo.get_absolute(nodes)
         
         #bac, bce, ecf, dbe, daf, dae
-        triangles = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+        triangles = numpy.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
 
         domain = General_mesh(nodes, triangles,
                        geo_reference = geo)
         node = domain.get_node(2)        
-        self.assertTrue(alltrue(c == node))
+        self.assertTrue(numpy.alltrue(c == node))
         
         node = domain.get_node(2, absolute=True)     
-        self.assertTrue(alltrue(nodes_absolute[2] == node))
+        self.assertTrue(numpy.alltrue(nodes_absolute[2] == node))
         
         node = domain.get_node(2, absolute=True)     
-        self.assertTrue(alltrue(nodes_absolute[2] == node))
+        self.assertTrue(numpy.alltrue(nodes_absolute[2] == node))
         
 
@@ -320 +304 @@
         f = [4.0, 0.0]
 
-        nodes = array([a, b, c, d, e, f])
+        nodes = numpy.array([a, b, c, d, e, f])
 
         nodes_absolute = geo.get_absolute(nodes)
         
         # max index is 5, use 5, expect success
-        triangles = array([[1,5,2], [1,2,4], [4,2,5], [3,1,4]])
+        triangles = numpy.array([[1,5,2], [1,2,4], [4,2,5], [3,1,4]])
         General_mesh(nodes, triangles, geo_reference=geo)
         
         # max index is 5, use 6, expect assert failure
-        triangles = array([[1,6,2], [1,2,4], [4,2,5], [3,1,4]])
+        triangles = numpy.array([[1,6,2], [1,2,4], [4,2,5], [3,1,4]])
         self.failUnlessRaises(AssertionError, General_mesh,
                               nodes, triangles, geo_reference=geo)
         
         # max index is 5, use 10, expect assert failure
-        triangles = array([[1,10,2], [1,2,4], [4,2,5], [3,1,4]])
+        triangles = numpy.array([[1,10,2], [1,2,4], [4,2,5], [3,1,4]])
         self.failUnlessRaises(AssertionError, General_mesh,
                               nodes, triangles, geo_reference=geo)

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_generic_boundary_conditions.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
@@ -8 +6 @@
 from generic_boundary_conditions import *
 from anuga.config import epsilon
-#from numpy.oldnumeric import allclose, array
-from numpy import allclose, array
+import numpy
 
 
@@ -47 +44 @@
 
         q = Bd.evaluate()
-        assert allclose(q, x)
+        assert numpy.allclose(q, x)
 
 
@@ -101 +98 @@
         q = T.evaluate(0, 2)  #Vol=0, edge=2
 
-        assert allclose(q, [1.5, 2.5])
+        assert numpy.allclose(q, [1.5, 2.5])
 
 
@@ -178 +175 @@
 
         #Check that midpoint coordinates at boundary are correctly computed
-        assert allclose( F.midpoint_coordinates,
-                         [[1.0, 0.0], [0.0, 1.0], [3.0, 0.0],
-                          [3.0, 1.0], [1.0, 3.0], [0.0, 3.0]])
-
-        #assert allclose(F.midpoint_coordinates[(3,2)], [0.0, 3.0])
-        #assert allclose(F.midpoint_coordinates[(3,1)], [1.0, 3.0])
-        #assert allclose(F.midpoint_coordinates[(0,2)], [0.0, 1.0])
-        #assert allclose(F.midpoint_coordinates[(0,0)], [1.0, 0.0])
-        #assert allclose(F.midpoint_coordinates[(2,0)], [3.0, 0.0])
-        #assert allclose(F.midpoint_coordinates[(2,1)], [3.0, 1.0])
+        assert numpy.allclose( F.midpoint_coordinates,
+                               [[1.0, 0.0], [0.0, 1.0], [3.0, 0.0],
+                                [3.0, 1.0], [1.0, 3.0], [0.0, 3.0]])
+
+        #assert numpy.allclose(F.midpoint_coordinates[(3,2)], [0.0, 3.0])
+        #assert numpy.allclose(F.midpoint_coordinates[(3,1)], [1.0, 3.0])
+        #assert numpy.allclose(F.midpoint_coordinates[(0,2)], [0.0, 1.0])
+        #assert numpy.allclose(F.midpoint_coordinates[(0,0)], [1.0, 0.0])
+        #assert numpy.allclose(F.midpoint_coordinates[(2,0)], [3.0, 0.0])
+        #assert numpy.allclose(F.midpoint_coordinates[(2,1)], [3.0, 1.0])
 
 
@@ -196 +193 @@
         domain.time = 5*30/2  #A quarter way through first step
         q = F.evaluate()
-        assert allclose(q, [1.0/4, sin(2*pi/10)/4])
+        assert numpy.allclose(q, [1.0/4, sin(2*pi/10)/4])
 
 
         domain.time = 2.5*5*60  #Half way between steps 2 and 3
         q = F.evaluate()
-        assert allclose(q, [2.5, (sin(2*2*pi/10) + sin(3*2*pi/10))/2])
+        assert numpy.allclose(q, [2.5, (sin(2*2*pi/10) + sin(3*2*pi/10))/2])
 
 

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_ghost.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
@@ -8 +6 @@
 from domain import *
 from anuga.config import epsilon
-from numpy.oldnumeric import allclose, array, ones, Float, alltrue
-
-
+import numpy
 
 
@@ -45 +41 @@
 
 
-        assert alltrue(domain.get_conserved_quantities(0, edge=1) == 0.)
+        assert numpy.alltrue(domain.get_conserved_quantities(0, edge=1) == 0.)
 
 

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_neighbour_mesh.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
-
-
 
 #FIXME: Seperate the tests for mesh and general_mesh
@@ -15 +11 @@
 from mesh_factory import rectangular
 from anuga.config import epsilon
-#from numpy.oldnumeric import allclose, array, Int
-from numpy import allclose, array, int
+import numpy
 
 from anuga.coordinate_transforms.geo_reference import Geo_reference
@@ -23 +18 @@
 
 def distance(x, y):
-    return sqrt( sum( (array(x)-array(y))**2 ))
+    return sqrt( sum( (numpy.array(x)-numpy.array(y))**2 ))
 
 class Test_Mesh(unittest.TestCase):
@@ -66 +61 @@
         #Normals
         normals = mesh.get_normals()
-        assert allclose(normals[0, 0:2], [3.0/5, 4.0/5])
-        assert allclose(normals[0, 2:4], [-1.0, 0.0])
-        assert allclose(normals[0, 4:6], [0.0, -1.0])
-
-        assert allclose(mesh.get_normal(0,0), [3.0/5, 4.0/5])
-        assert allclose(mesh.get_normal(0,1), [-1.0, 0.0])
-        assert allclose(mesh.get_normal(0,2), [0.0, -1.0])
+        assert numpy.allclose(normals[0, 0:2], [3.0/5, 4.0/5])
+        assert numpy.allclose(normals[0, 2:4], [-1.0, 0.0])
+        assert numpy.allclose(normals[0, 4:6], [0.0, -1.0])
+
+        assert numpy.allclose(mesh.get_normal(0,0), [3.0/5, 4.0/5])
+        assert numpy.allclose(mesh.get_normal(0,1), [-1.0, 0.0])
+        assert numpy.allclose(mesh.get_normal(0,2), [0.0, -1.0])
 
         #Edge lengths
-        assert allclose(mesh.edgelengths[0], [5.0, 3.0, 4.0])
+        assert numpy.allclose(mesh.edgelengths[0], [5.0, 3.0, 4.0])
 
 
@@ -84 +79 @@
 
         V = mesh.get_vertex_coordinates()
-        assert allclose(V, [ [0.0, 0.0],
-                             [4.0, 0.0],
-                             [0.0, 3.0] ])
+        assert numpy.allclose(V, [ [0.0, 0.0],
+                                   [4.0, 0.0],
+                                   [0.0, 3.0] ])
 
         V0 = mesh.get_vertex_coordinate(0, 0)
-        assert allclose(V0, [0.0, 0.0])
+        assert numpy.allclose(V0, [0.0, 0.0])
 
         V1 = mesh.get_vertex_coordinate(0, 1)
-        assert allclose(V1, [4.0, 0.0])
+        assert numpy.allclose(V1, [4.0, 0.0])
 
         V2 = mesh.get_vertex_coordinate(0, 2)
-        assert allclose(V2, [0.0, 3.0])
+        assert numpy.allclose(V2, [0.0, 3.0])
 
 
@@ -240 +235 @@
 
         mesh = Mesh(points, vertices,use_inscribed_circle=False)
-        assert allclose(mesh.radii[0],sqrt(3.0)/3),'Steve''s doesn''t work'
+        assert numpy.allclose(mesh.radii[0],sqrt(3.0)/3),'Steve''s doesn''t work'
 
         mesh = Mesh(points, vertices,use_inscribed_circle=True)
-        assert allclose(mesh.radii[0],sqrt(3.0)/3),'inscribed circle doesn''t work'
+        assert numpy.allclose(mesh.radii[0],sqrt(3.0)/3),'inscribed circle doesn''t work'
 
     def test_inscribed_circle_rightangle_triangle(self):
@@ -255 +250 @@
 
         mesh = Mesh(points, vertices,use_inscribed_circle=False)
-        assert allclose(mesh.radii[0],5.0/6),'Steve''s doesn''t work'
+        assert numpy.allclose(mesh.radii[0],5.0/6),'Steve''s doesn''t work'
 
         mesh = Mesh(points, vertices,use_inscribed_circle=True)
-        assert allclose(mesh.radii[0],1.0),'inscribed circle doesn''t work'
+        assert numpy.allclose(mesh.radii[0],1.0),'inscribed circle doesn''t work'
 
 
@@ -272 +267 @@
         assert mesh.areas[0] == 2.0
 
-        assert allclose(mesh.centroid_coordinates[0], [2.0/3, 2.0/3])
+        assert numpy.allclose(mesh.centroid_coordinates[0], [2.0/3, 2.0/3])
 
 
@@ -306 +301 @@
         assert mesh.edgelengths[1,2] == sqrt(8.0)
 
-        assert allclose(mesh.centroid_coordinates[0], [2.0/3, 2.0/3])
-        assert allclose(mesh.centroid_coordinates[1], [4.0/3, 4.0/3])
-        assert allclose(mesh.centroid_coordinates[2], [8.0/3, 2.0/3])
-        assert allclose(mesh.centroid_coordinates[3], [2.0/3, 8.0/3])
+        assert numpy.allclose(mesh.centroid_coordinates[0], [2.0/3, 2.0/3])
+        assert numpy.allclose(mesh.centroid_coordinates[1], [4.0/3, 4.0/3])
+        assert numpy.allclose(mesh.centroid_coordinates[2], [8.0/3, 2.0/3])
+        assert numpy.allclose(mesh.centroid_coordinates[3], [2.0/3, 8.0/3])
 
     def test_mesh_and_neighbours(self):
@@ -700 +695 @@
         get values based on triangle lists.
         """
+
         from mesh_factory import rectangular
-#        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -720 +714 @@
     def test_boundary_polygon(self):
         from mesh_factory import rectangular
-        #from mesh import Mesh
-#        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
 
         #Create basic mesh
@@ -732 +723 @@
 
         assert len(P) == 8
-        assert allclose(P, [[0.0, 0.0], [0.5, 0.0], [1.0, 0.0],
-                            [1.0, 0.5], [1.0, 1.0], [0.5, 1.0],
-                            [0.0, 1.0], [0.0, 0.5]])
+        assert numpy.allclose(P, [[0.0, 0.0], [0.5, 0.0], [1.0, 0.0],
+                                  [1.0, 0.5], [1.0, 1.0], [0.5, 1.0],
+                                  [0.0, 1.0], [0.0, 0.5]])
         for p in points:
             #print p, P
@@ -741 +732 @@
 
     def test_boundary_polygon_II(self):
-#        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
-        
-
         #Points
         a = [0.0, 0.0] #0
@@ -770 +757 @@
 
         assert len(P) == 8
-        assert allclose(P, [a, d, f, i, h, e, c, b])
+        assert numpy.allclose(P, [a, d, f, i, h, e, c, b])
 
         for p in points:
@@ -780 +767 @@
         """Same as II but vertices ordered differently
         """
-
-#        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
-
 
         #Points
@@ -811 +794 @@
 
         assert len(P) == 8
-        assert allclose(P, [a, d, f, i, h, e, c, b])
+        assert numpy.allclose(P, [a, d, f, i, h, e, c, b])
 
         for p in points:
@@ -822 +805 @@
         is partitioned using pymetis.
         """
-
-#        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
-
 
         #Points
@@ -855 +834 @@
         
         # Note that point e appears twice!
-        assert allclose(P, [a, d, f, e, g, h, e, c, b])
+        assert numpy.allclose(P, [a, d, f, e, g, h, e, c, b])
 
         for p in points:
@@ -872 +851 @@
         """
 
-#        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
         from mesh_factory import rectangular        
 
@@ -916 +893 @@
         
         """
-#        from numpy.oldnumeric import zeros, Float
-        from numpy import zeros, float
-        
 
         #Points
@@ -965 +939 @@
         
         assert len(P) == 8
-        assert allclose(P, [a, d, f, i, h, e, c, b])
-        assert allclose(P, [(0.0, 0.0), (0.5, 0.0), (1.0, 0.0), (1.5, 0.5), (1.0, 1.0), (0.5, 0.5), (0.0, 1.0), (0.0, 0.5)])
+        assert numpy.allclose(P, [a, d, f, i, h, e, c, b])
+        assert numpy.allclose(P, [(0.0, 0.0), (0.5, 0.0), (1.0, 0.0), (1.5, 0.5), (1.0, 1.0), (0.5, 0.5), (0.0, 1.0), (0.0, 0.5)])
         
 
@@ -1152 +1126 @@
             assert is_inside_polygon(p, P)            
 
-        assert allclose(P, Pref)    
+        assert numpy.allclose(P, Pref)    
 
     def test_lone_vertices(self):
@@ -1204 +1178 @@
         boundary_polygon = mesh.get_boundary_polygon()
 
-        assert allclose(absolute_points, boundary_polygon)
+        assert numpy.allclose(absolute_points, boundary_polygon)
 
     def test_get_triangle_containing_point(self):
@@ -1251 +1225 @@
 
         neighbours = mesh.get_triangle_neighbours(0)
-        assert allclose(neighbours, [-1,1,-1])
+        assert numpy.allclose(neighbours, [-1,1,-1])
         neighbours = mesh.get_triangle_neighbours(-10)
         assert neighbours == []
@@ -1300 +1274 @@
             for x in L:
                 if x.triangle_id % 2 == 0:
-                    assert allclose(x.length, ceiling-y_line)
+                    assert numpy.allclose(x.length, ceiling-y_line)
                 else:
-                    assert allclose(x.length, y_line-floor)                
+                    assert numpy.allclose(x.length, y_line-floor)                
 
                 
-                assert allclose(x.normal, [0,-1])
-
-                assert allclose(x.segment[1][0], x.segment[0][0] + x.length)
-                assert allclose(x.segment[0][1], y_line)
-                assert allclose(x.segment[1][1], y_line)                
+                assert numpy.allclose(x.normal, [0,-1])
+
+                assert numpy.allclose(x.segment[1][0], x.segment[0][0] + x.length)
+                assert numpy.allclose(x.segment[0][1], y_line)
+                assert numpy.allclose(x.segment[1][1], y_line)                
 
                 assert x.triangle_id in intersected_triangles
@@ -1316 +1290 @@
 
             msg = 'Segments do not add up'
-            assert allclose(total_length, 2), msg
+            assert numpy.allclose(total_length, 2), msg
             
 
@@ -1351 +1325 @@
         total_length = 0
         for x in L:
-            assert allclose(x.length, 1.0)
-            assert allclose(x.normal, [0,-1])
-
-            assert allclose(x.segment[1][0], x.segment[0][0] + x.length)
-            assert allclose(x.segment[0][1], y_line)
-            assert allclose(x.segment[1][1], y_line)                            
+            assert numpy.allclose(x.length, 1.0)
+            assert numpy.allclose(x.normal, [0,-1])
+
+            assert numpy.allclose(x.segment[1][0], x.segment[0][0] + x.length)
+            assert numpy.allclose(x.segment[0][1], y_line)
+            assert numpy.allclose(x.segment[1][1], y_line)                            
 
 
@@ -1365 +1339 @@
 
         msg = 'Segments do not add up'
-        assert allclose(total_length, 2), msg
+        assert numpy.allclose(total_length, 2), msg
         
 
@@ -1405 +1379 @@
         for x in L:
             if x.triangle_id == 1:
-                assert allclose(x.length, 1)        
-                assert allclose(x.normal, [0, -1])
+                assert numpy.allclose(x.length, 1)        
+                assert numpy.allclose(x.normal, [0, -1])
                 
             if x.triangle_id == 5:
-                assert allclose(x.length, 0.5)
-                assert allclose(x.normal, [0, -1])
+                assert numpy.allclose(x.length, 0.5)
+                assert numpy.allclose(x.normal, [0, -1])
 
 
@@ -1418 +1392 @@
 
         msg = 'Segments do not add up'
-        assert allclose(total_length, 1.5), msg            
+        assert numpy.allclose(total_length, 1.5), msg            
 
 
@@ -1452 +1426 @@
         total_length = 0
         for i, x in enumerate(L): 
-            assert allclose(x.length, s2)
-            assert allclose(x.normal, [-s2, -s2])
-            assert allclose(sum(x.normal**2), 1)
+            assert numpy.allclose(x.length, s2)
+            assert numpy.allclose(x.normal, [-s2, -s2])
+            assert numpy.allclose(sum(x.normal**2), 1)
             
             assert x.triangle_id in intersected_triangles
@@ -1461 +1435 @@
 
         msg = 'Segments do not add up'
-        assert allclose(total_length, 4*s2), msg
+        assert numpy.allclose(total_length, 4*s2), msg
 
 
@@ -1476 +1450 @@
         total_length = 0
         for i, x in enumerate(L): 
-            assert allclose(x.length, s2)
-            assert allclose(x.normal, [s2, s2])
-            assert allclose(sum(x.normal**2), 1)
+            assert numpy.allclose(x.length, s2)
+            assert numpy.allclose(x.normal, [s2, s2])
+            assert numpy.allclose(sum(x.normal**2), 1)
             
             assert x.triangle_id in intersected_triangles
@@ -1485 +1459 @@
 
         msg = 'Segments do not add up'
-        assert allclose(total_length, 4*s2), msg                    
+        assert numpy.allclose(total_length, 4*s2), msg                    
 
 
@@ -1501 +1475 @@
         total_length = 0
         for i, x in enumerate(L): 
-            assert allclose(x.length, 2*s2)
-            assert allclose(x.normal, [-s2, s2])
-            assert allclose(sum(x.normal**2), 1)
+            assert numpy.allclose(x.length, 2*s2)
+            assert numpy.allclose(x.normal, [-s2, s2])
+            assert numpy.allclose(sum(x.normal**2), 1)
             
             assert x.triangle_id in intersected_triangles
@@ -1510 +1484 @@
 
         msg = 'Segments do not add up'
-        assert allclose(total_length, 4*s2), msg                        
+        assert numpy.allclose(total_length, 4*s2), msg                        
 
 
@@ -1525 +1499 @@
         total_length = 0
         for i, x in enumerate(L): 
-            assert allclose(x.length, 2*s2)
-            assert allclose(x.normal, [s2, -s2])
-            assert allclose(sum(x.normal**2), 1)
+            assert numpy.allclose(x.length, 2*s2)
+            assert numpy.allclose(x.normal, [s2, -s2])
+            assert numpy.allclose(sum(x.normal**2), 1)
             
             assert x.triangle_id in intersected_triangles
@@ -1534 +1508 @@
 
         msg = 'Segments do not add up'
-        assert allclose(total_length, 4*s2), msg                        
+        assert numpy.allclose(total_length, 4*s2), msg                        
 
 
@@ -1550 +1524 @@
         total_length = 0
         for i, x in enumerate(L): 
-            assert allclose(x.length, s2)
-            assert allclose(x.normal, [-s2, -s2])
-            assert allclose(sum(x.normal**2), 1)
+            assert numpy.allclose(x.length, s2)
+            assert numpy.allclose(x.normal, [-s2, -s2])
+            assert numpy.allclose(sum(x.normal**2), 1)
             
             assert x.triangle_id in intersected_triangles
@@ -1559 +1533 @@
 
         msg = 'Segments do not add up'
-        assert allclose(total_length, 2*s2), msg
+        assert numpy.allclose(total_length, 2*s2), msg
 
 
@@ -1572 +1546 @@
         total_length = 0
         for i, x in enumerate(L): 
-            assert allclose(x.normal, [-s2, -s2])
-            assert allclose(sum(x.normal**2), 1)
+            assert numpy.allclose(x.normal, [-s2, -s2])
+            assert numpy.allclose(sum(x.normal**2), 1)
 
             msg = 'Triangle %d' %x.triangle_id + ' is not in %s' %(intersected_triangles)
@@ -1608 +1582 @@
         assert len(L) == 1
         assert L[0].triangle_id == 3
-        assert allclose(L[0].length, 0.5)        
-        assert allclose(L[0].normal, [-1,0])                
+        assert numpy.allclose(L[0].length, 0.5)        
+        assert numpy.allclose(L[0].normal, [-1,0])                
 
 
@@ -1620 +1594 @@
         assert len(L) == 1
         assert L[0].triangle_id == 3
-        assert allclose(L[0].length, 0.4)
-        assert allclose(L[0].normal, [-1,0])
+        assert numpy.allclose(L[0].length, 0.4)
+        assert numpy.allclose(L[0].normal, [-1,0])
 
         intersected_triangles = [3]
@@ -1633 +1607 @@
         assert len(L) == 1
         assert L[0].triangle_id == 3
-        assert allclose(L[0].length, 0.4)
-        assert allclose(L[0].normal, [1,0])                
+        assert numpy.allclose(L[0].length, 0.4)
+        assert numpy.allclose(L[0].normal, [1,0])                
         
 
@@ -1668 +1642 @@
         for x in L:
             if x.triangle_id == 3:
-                assert allclose(x.length, 0.5)        
-                assert allclose(x.normal, [-1,0])
+                assert numpy.allclose(x.length, 0.5)        
+                assert numpy.allclose(x.normal, [-1,0])
                 
             if x.triangle_id == 2:
-                assert allclose(x.length, s2)
-                assert allclose(x.normal, [-s2,-s2])
+                assert numpy.allclose(x.length, s2)
+                assert numpy.allclose(x.normal, [-s2,-s2])
 
 
@@ -1706 +1680 @@
         for x in L:
             if x.triangle_id == 3:
-                assert allclose(x.length, 0.5)        
-                assert allclose(x.normal, [-1,0])
+                assert numpy.allclose(x.length, 0.5)        
+                assert numpy.allclose(x.normal, [-1,0])
                 
             if x.triangle_id == 2:
                 msg = str(x.length)
-                assert allclose(x.length, s2), msg
-                assert allclose(x.normal, [-s2,-s2])
+                assert numpy.allclose(x.length, s2), msg
+                assert numpy.allclose(x.normal, [-s2,-s2])
 
             if x.triangle_id == 5:
-                segvec = array([line[2][0]-1,
-                                line[2][1]-1])
+                segvec = numpy.array([line[2][0]-1,
+                                      line[2][1]-1])
                 msg = str(x.length)
-                assert allclose(x.length, sqrt(sum(segvec**2))), msg
-                assert allclose(x.normal, [-s2,-s2])                                                
+                assert numpy.allclose(x.length, sqrt(sum(segvec**2))), msg
+                assert numpy.allclose(x.normal, [-s2,-s2])                                                
 
 
@@ -1757 +1731 @@
         for x in L:
             if x.triangle_id == 3:
-                assert allclose(x.length, 0.5)        
-                assert allclose(x.normal, [-1,0])
+                assert numpy.allclose(x.length, 0.5)        
+                assert numpy.allclose(x.normal, [-1,0])
                 
             if x.triangle_id == 2:
                 msg = str(x.length)
-                assert allclose(x.length, s2), msg
-                assert allclose(x.normal, [-s2,-s2])
+                assert numpy.allclose(x.length, s2), msg
+                assert numpy.allclose(x.normal, [-s2,-s2])
 
             if x.triangle_id == 5:
                 if x.segment == ((1.0, 1.0), (1.25, 0.75)):                    
-                    segvec = array([line[2][0]-1,
-                                    line[2][1]-1])
+                    segvec = numpy.array([line[2][0]-1,
+                                          line[2][1]-1])
                     msg = str(x.length)
-                    assert allclose(x.length, sqrt(sum(segvec**2))), msg
-                    assert allclose(x.normal, [-s2,-s2])
+                    assert numpy.allclose(x.length, sqrt(sum(segvec**2))), msg
+                    assert numpy.allclose(x.normal, [-s2,-s2])
                 elif x.segment == ((1.25, 0.75), (1.5, 1.0)):
-                    segvec = array([1.5-line[2][0],
-                                    1.0-line[2][1]])
+                    segvec = numpy.array([1.5-line[2][0],
+                                          1.0-line[2][1]])
                     
-                    assert allclose(x.length, sqrt(sum(segvec**2))), msg
-                    assert allclose(x.normal, [s2,-s2])
+                    assert numpy.allclose(x.length, sqrt(sum(segvec**2))), msg
+                    assert numpy.allclose(x.normal, [s2,-s2])
                 else:
                     msg = 'Unknow segment: %s' %x.segment
@@ -1785 +1759 @@
                     
             if x.triangle_id == 6:
-                assert allclose(x.normal, [s2,-s2])
-                assert allclose(x.segment, ((1.5, 1.0), (2, 1.5)))
+                assert numpy.allclose(x.normal, [s2,-s2])
+                assert numpy.allclose(x.segment, ((1.5, 1.0), (2, 1.5)))
 
 
@@ -1852 +1826 @@
             ref_length = line[1][1] - line[0][1]
             #print ref_length, total_length
-            assert allclose(total_length, ref_length)
+            assert numpy.allclose(total_length, ref_length)
 
 

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_pmesh2domain.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 #
 
 import unittest
-
-#from numpy.oldnumeric import allclose, array
-from numpy import allclose, array
-
+import numpy
 
 #from anuga.pyvolution.pmesh2domain import *
@@ -69 +64 @@
 
          tags = {}
-         b1 =  Dirichlet_boundary(conserved_quantities = array([0.0]))
-         b2 =  Dirichlet_boundary(conserved_quantities = array([1.0]))
-         b3 =  Dirichlet_boundary(conserved_quantities = array([2.0]))
+         b1 =  Dirichlet_boundary(conserved_quantities = numpy.array([0.0]))
+         b2 =  Dirichlet_boundary(conserved_quantities = numpy.array([1.0]))
+         b3 =  Dirichlet_boundary(conserved_quantities = numpy.array([2.0]))
          tags["1"] = b1
          tags["2"] = b2
@@ -83 +78 @@
          answer = [[0., 8., 0.],
                    [0., 10., 8.]]
-         assert allclose(domain.quantities['elevation'].vertex_values,
-                        answer)
+         assert numpy.allclose(domain.quantities['elevation'].vertex_values,
+                               answer)
 
          #print domain.quantities['stage'].vertex_values
          answer = [[0., 12., 10.],
                    [0., 10., 12.]]
-         assert allclose(domain.quantities['stage'].vertex_values,
-                        answer)
+         assert numpy.allclose(domain.quantities['stage'].vertex_values,
+                               answer)
 
          #print domain.quantities['friction'].vertex_values
          answer = [[0.01, 0.04, 0.03],
                    [0.01, 0.02, 0.04]]
-         assert allclose(domain.quantities['friction'].vertex_values,
-                        answer)
-
-         #print domain.quantities['friction'].vertex_values
-         assert allclose(domain.tagged_elements['dsg'][0],0)
-         assert allclose(domain.tagged_elements['ole nielsen'][0],1)
+         assert numpy.allclose(domain.quantities['friction'].vertex_values,
+                               answer)
+
+         #print domain.quantities['friction'].vertex_values
+         assert numpy.allclose(domain.tagged_elements['dsg'][0],0)
+         assert numpy.allclose(domain.tagged_elements['ole nielsen'][0],1)
 
          self.failUnless( domain.boundary[(1, 0)]  == '1',
@@ -162 +157 @@
         
          tags = {}
-         b1 =  Dirichlet_boundary(conserved_quantities = array([0.0]))
-         b2 =  Dirichlet_boundary(conserved_quantities = array([1.0]))
-         b3 =  Dirichlet_boundary(conserved_quantities = array([2.0]))
+         b1 =  Dirichlet_boundary(conserved_quantities = numpy.array([0.0]))
+         b2 =  Dirichlet_boundary(conserved_quantities = numpy.array([1.0]))
+         b3 =  Dirichlet_boundary(conserved_quantities = numpy.array([2.0]))
          tags["1"] = b1
          tags["2"] = b2
@@ -177 +172 @@
          answer = [[0., 8., 0.],
                    [0., 10., 8.]]
-         assert allclose(domain.quantities['elevation'].vertex_values,
-                        answer)
+         assert numpy.allclose(domain.quantities['elevation'].vertex_values,
+                               answer)
 
          #print domain.quantities['stage'].vertex_values
          answer = [[0., 12., 10.],
                    [0., 10., 12.]]
-         assert allclose(domain.quantities['stage'].vertex_values,
-                        answer)
+         assert numpy.allclose(domain.quantities['stage'].vertex_values,
+                               answer)
 
          #print domain.quantities['friction'].vertex_values
          answer = [[0.01, 0.04, 0.03],
                    [0.01, 0.02, 0.04]]
-         assert allclose(domain.quantities['friction'].vertex_values,
-                        answer)
-
-         #print domain.quantities['friction'].vertex_values
-         assert allclose(domain.tagged_elements['dsg'][0],0)
-         assert allclose(domain.tagged_elements['ole nielsen'][0],1)
+         assert numpy.allclose(domain.quantities['friction'].vertex_values,
+                               answer)
+
+         #print domain.quantities['friction'].vertex_values
+         assert numpy.allclose(domain.tagged_elements['dsg'][0],0)
+         assert numpy.allclose(domain.tagged_elements['ole nielsen'][0],1)
 
          self.failUnless( domain.boundary[(1, 0)]  == '1',
@@ -231 +226 @@
          #domain.set_tag_dict(tag_dict)
          #Boundary tests
-         b1 =  Dirichlet_boundary(conserved_quantities = array([0.0]))
-         b2 =  Dirichlet_boundary(conserved_quantities = array([1.0]))
-         b3 =  Dirichlet_boundary(conserved_quantities = array([1.0]))
+         b1 =  Dirichlet_boundary(conserved_quantities = numpy.array([0.0]))
+         b2 =  Dirichlet_boundary(conserved_quantities = numpy.array([1.0]))
+         b3 =  Dirichlet_boundary(conserved_quantities = numpy.array([1.0]))
          #test adding a boundary
          tags = {}

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_quantity.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
@@ -9 +7 @@
 from quantity import *
 from anuga.config import epsilon
-#from numpy.oldnumeric import allclose, array, ones, Float
-from numpy import allclose, array, ones, float
+import numpy
 
 from anuga.fit_interpolate.fit import fit_to_mesh
@@ -21 +18 @@
 #Aux for fit_interpolate.fit example
 def linear_function(point):
-    point = array(point)
+    point = numpy.array(point)
     return point[:,0]+point[:,1]
 
@@ -63 +60 @@
 
 
-##    def test_creation(self):
-##
-##        quantity = Quantity(self.mesh1, [[1,2,3]])
-##        assert allclose(quantity.vertex_values, [[1.,2.,3.]])
-##
-##        try:
-##            quantity = Quantity()
-##        except:
-##            pass
-##        else:
-##            raise 'Should have raised empty quantity exception'
-##
-##
-##        try:
-##            quantity = Quantity([1,2,3])
-##        except AssertionError:
-##            pass
-##        except:
-##            raise 'Should have raised "mising mesh object" error'
-##
-##
-##    def test_creation_zeros(self):
-##
-##        quantity = Quantity(self.mesh1)
-##        assert allclose(quantity.vertex_values, [[0.,0.,0.]])
-##
-##
-##        quantity = Quantity(self.mesh4)
-##        assert allclose(quantity.vertex_values, [[0.,0.,0.], [0.,0.,0.],
-##                                                 [0.,0.,0.], [0.,0.,0.]])
-##
-##
-##    def test_interpolation(self):
-##        quantity = Quantity(self.mesh1, [[1,2,3]])
-##        assert allclose(quantity.centroid_values, [2.0]) #Centroid
-##
-##        assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5]])
-##
-##
-##    def test_interpolation2(self):
-##        quantity = Quantity(self.mesh4,
-##                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
-##        assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
-##
-##
-##        quantity.extrapolate_second_order()
-##
-##        #print quantity.vertex_values
-##        assert allclose(quantity.vertex_values, [[3.5, -1.0, 3.5],
-##                                                 [3.+2./3, 6.+2./3, 4.+2./3],
-##                                                 [4.6, 3.4, 1.],
-##                                                 [-5.0, 1.0, 4.0]])
-##
-##        #print quantity.edge_values
-##        assert allclose(quantity.edge_values, [[1.25, 3.5, 1.25],
-##                                               [5. + 2/3.0, 4.0 + 1.0/6, 5.0 + 1.0/6],
-##                                               [2.2, 2.8, 4.0],
-##                                               [2.5, -0.5, -2.0]])
-##
-##
-##        #assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
-##        #                                       [5., 5., 5.],
-##        #                                       [4.5, 4.5, 0.],
-##        #                                       [3.0, -1.5, -1.5]])
-##
+    def test_creation(self):
+
+        quantity = Quantity(self.mesh1, [[1,2,3]])
+        assert numpy.allclose(quantity.vertex_values, [[1.,2.,3.]])
+
+        try:
+            quantity = Quantity()
+        except:
+            pass
+        else:
+            raise 'Should have raised empty quantity exception'
+
+
+        try:
+            quantity = Quantity([1,2,3])
+        except AssertionError:
+            pass
+        except:
+            raise 'Should have raised "mising mesh object" error'
+
+
+    def test_creation_zeros(self):
+
+        quantity = Quantity(self.mesh1)
+        assert numpy.allclose(quantity.vertex_values, [[0.,0.,0.]])
+
+
+        quantity = Quantity(self.mesh4)
+        assert numpy.allclose(quantity.vertex_values, [[0.,0.,0.], [0.,0.,0.],
+                                                 [0.,0.,0.], [0.,0.,0.]])
+
+
+    def test_interpolation(self):
+        quantity = Quantity(self.mesh1, [[1,2,3]])
+        assert numpy.allclose(quantity.centroid_values, [2.0]) #Centroid
+
+        assert numpy.allclose(quantity.edge_values, [[2.5, 2.0, 1.5]])
+
+
+    def test_interpolation2(self):
+        quantity = Quantity(self.mesh4,
+                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
+        assert numpy.allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
+
+
+        quantity.extrapolate_second_order()
+
+        #print quantity.vertex_values
+        assert numpy.allclose(quantity.vertex_values, [[3.5, -1.0, 3.5],
+                                                       [3.+2./3, 6.+2./3, 4.+2./3],
+                                                       [4.6, 3.4, 1.],
+                                                       [-5.0, 1.0, 4.0]])
+
+        #print quantity.edge_values
+        assert numpy.allclose(quantity.edge_values, [[1.25, 3.5, 1.25],
+                                                     [5. + 2/3.0, 4.0 + 1.0/6, 5.0 + 1.0/6],
+                                                     [2.2, 2.8, 4.0],
+                                                     [2.5, -0.5, -2.0]])
+
+
+        #assert numpy.allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
+        #                                             [5., 5., 5.],
+        #                                             [4.5, 4.5, 0.],
+        #                                             [3.0, -1.5, -1.5]])
+
     def test_get_extrema_1(self):
         quantity = Quantity(self.mesh4,
                                       [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
-        assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroids
+        assert numpy.allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroids
 
         v = quantity.get_maximum_value()
@@ -151 +148 @@
 
         v = quantity.get_values(interpolation_points = [[x,y]])
-        assert allclose(v, 5)
+        assert numpy.allclose(v, 5)
 
 
         x,y = quantity.get_minimum_location()
         v = quantity.get_values(interpolation_points = [[x,y]])
-        assert allclose(v, 0)
-
-
-##    def test_get_maximum_2(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
-##        vertices = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
-##
-##        domain = Domain(points, vertices)
-##
-##        quantity = Quantity(domain)
-##        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
-##        
-##        v = quantity.get_maximum_value()
-##        assert v == 6
-##
-##        v = quantity.get_minimum_value()
-##        assert v == 2        
-##
-##        i = quantity.get_maximum_index()
-##        assert i == 3
-##
-##        i = quantity.get_minimum_index()
-##        assert i == 0        
-##        
-##        x,y = quantity.get_maximum_location()
-##        xref, yref = 2.0/3, 8.0/3
-##        assert x == xref
-##        assert y == yref
-##
-##        v = quantity.get_values(interpolation_points = [[x,y]])
-##        assert allclose(v, 6)
-##
-##        x,y = quantity.get_minimum_location()        
-##        v = quantity.get_values(interpolation_points = [[x,y]])
-##        assert allclose(v, 2)
-##
-##        #Multiple locations for maximum -
-##        #Test that the algorithm picks the first occurrence        
-##        v = quantity.get_maximum_value(indices=[0,1,2])
-##        assert allclose(v, 4)
-##
-##        i = quantity.get_maximum_index(indices=[0,1,2])
-##        assert i == 1
-##        
-##        x,y = quantity.get_maximum_location(indices=[0,1,2])
-##        xref, yref = 4.0/3, 4.0/3
-##        assert x == xref
-##        assert y == yref
-##
-##        v = quantity.get_values(interpolation_points = [[x,y]])
-##        assert allclose(v, 4)        
-##
-##        # More test of indices......
-##        v = quantity.get_maximum_value(indices=[2,3])
-##        assert allclose(v, 6)
-##
-##        i = quantity.get_maximum_index(indices=[2,3])
-##        assert i == 3
-##        
-##        x,y = quantity.get_maximum_location(indices=[2,3])
-##        xref, yref = 2.0/3, 8.0/3
-##        assert x == xref
-##        assert y == yref
-##
-##        v = quantity.get_values(interpolation_points = [[x,y]])
-##        assert allclose(v, 6)        
-##
-##        
-##
-##    def test_boundary_allocation(self):
-##        quantity = Quantity(self.mesh4,
-##                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
-##
-##        assert quantity.boundary_values.shape[0] == len(self.mesh4.boundary)
-##
-##
-##    def test_set_values(self):
-##        quantity = Quantity(self.mesh4)
-##
-##
-##        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
-##                            location = 'vertices')
-##        assert allclose(quantity.vertex_values,
-##                        [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
-##        assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
-##        assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
-##                                               [5., 5., 5.],
-##                                               [4.5, 4.5, 0.],
-##                                               [3.0, -1.5, -1.5]])
-##
-##
-##        # Test default
-##        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
-##        assert allclose(quantity.vertex_values,
-##                        [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
-##        assert allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
-##        assert allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
-##                                               [5., 5., 5.],
-##                                               [4.5, 4.5, 0.],
-##                                               [3.0, -1.5, -1.5]])
-##
-##        # Test centroids
-##        quantity.set_values([1,2,3,4], location = 'centroids')
-##        assert allclose(quantity.centroid_values, [1., 2., 3., 4.]) #Centroid
-##
-##        # Test exceptions
-##        try:
-##            quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
-##                                location = 'bas kamel tuba')
-##        except:
-##            pass
-##
-##
-##        try:
-##            quantity.set_values([[1,2,3], [0,0,9]])
-##        except AssertionError:
-##            pass
-##        except:
-##            raise 'should have raised Assertionerror'
-##
-##
-##
-##    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])
-##
-##
-##    def test_set_values_func(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        def f(x, y):
-##            return x+y
-##
-##        quantity.set_values(f, location = 'vertices')
-##        #print "quantity.vertex_values",quantity.vertex_values
-##        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_integral(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Try constants first
-##        const = 5
-##        quantity.set_values(const, location = 'vertices')
-##        #print 'Q', quantity.get_integral()
-##
-##        assert allclose(quantity.get_integral(), self.mesh4.get_area() * const)
-##
-##        #Try with a linear function
-##        def f(x, y):
-##            return x+y
-##
-##        quantity.set_values(f, location = 'vertices')
-##
-##
-##        ref_integral = (4.0/3 + 8.0/3 + 10.0/3 + 10.0/3) * 2
-##
-##        assert allclose (quantity.get_integral(), ref_integral)
-##
-##
-##
-##    def test_set_vertex_values(self):
-##        quantity = Quantity(self.mesh4)
-##        quantity.set_vertex_values([0,1,2,3,4,5])
-##
-##        assert allclose(quantity.vertex_values,
-##                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
-##        assert allclose(quantity.centroid_values,
-##                        [1., 7./3, 11./3, 8./3]) #Centroid
-##        assert allclose(quantity.edge_values, [[1., 1.5, 0.5],
-##                                               [3., 2.5, 1.5],
-##                                               [3.5, 4.5, 3.],
-##                                               [2.5, 3.5, 2]])
-##
-##
-##    def test_set_vertex_values_subset(self):
-##        quantity = Quantity(self.mesh4)
-##        quantity.set_vertex_values([0,1,2,3,4,5])
-##        quantity.set_vertex_values([0,20,30,50], indices = [0,2,3,5])
-##
-##        assert allclose(quantity.vertex_values,
-##                        [[1,0,20], [1,20,4], [4,20,50], [30,1,4]])
-##
-##
-##    def test_set_vertex_values_using_general_interface(self):
-##        quantity = Quantity(self.mesh4)
-##
-##
-##        quantity.set_values([0,1,2,3,4,5])
-##
-##
-##        assert allclose(quantity.vertex_values,
-##                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
-##
-##        #Centroid
-##        assert allclose(quantity.centroid_values, [1., 7./3, 11./3, 8./3])
-##
-##        assert allclose(quantity.edge_values, [[1., 1.5, 0.5],
-##                                               [3., 2.5, 1.5],
-##                                               [3.5, 4.5, 3.],
-##                                               [2.5, 3.5, 2]])
-##
-##
-##
-##    def test_set_vertex_values_using_general_interface_with_subset(self):
-##        """test_set_vertex_values_using_general_interface_with_subset(self):
-##        
-##        Test that indices and polygon works (for constants values)
-##        """
-##        
-##        quantity = Quantity(self.mesh4)
-##
-##
-##        quantity.set_values([0,2,3,5], indices=[0,2,3,5])
-##        assert allclose(quantity.vertex_values,
-##                        [[0,0,2], [0,2,0], [0,2,5], [3,0,0]])
-##
-##
-##        # Constant
-##        quantity.set_values(0.0)
-##        quantity.set_values(3.14, indices=[0,2], location='vertices')
-##
-##        # Indices refer to triangle numbers
-##        assert allclose(quantity.vertex_values,
-##                        [[3.14,3.14,3.14], [0,0,0],
-##                         [3.14,3.14,3.14], [0,0,0]])        
-##        
-##
-##
-##        # Now try with polygon (pick points where y>2)
-##        polygon = [[0,2.1], [4,2.1], [4,7], [0,7]]
-##        quantity.set_values(0.0)
-##        quantity.set_values(3.14, polygon=polygon)
-##        
-##        assert allclose(quantity.vertex_values,
-##                        [[0,0,0], [0,0,0], [0,0,0],
-##                         [3.14,3.14,3.14]])                
-##
-##
-##        # Another polygon (pick triangle 1 and 2 (rightmost triangles) 
-##        # using centroids
-##        polygon = [[2.1, 0.0], [3.5,0.1], [2,2.2], [0.2,2]]
-##        quantity.set_values(0.0)
-##        quantity.set_values(3.14, location='centroids', polygon=polygon)
-##        assert allclose(quantity.vertex_values,
-##                        [[0,0,0],
-##                         [3.14,3.14,3.14],
-##                         [3.14,3.14,3.14],                         
-##                         [0,0,0]])                
-##
-##
-##        # Same polygon now use vertices (default)
-##        polygon = [[2.1, 0.0], [3.5,0.1], [2,2.2], [0.2,2]]
-##        quantity.set_values(0.0)
-##        #print 'Here 2'
-##        quantity.set_values(3.14, polygon=polygon)
-##        assert allclose(quantity.vertex_values,
-##                        [[0,0,0],
-##                         [3.14,3.14,3.14],
-##                         [3.14,3.14,3.14],                         
-##                         [0,0,0]])                
-##        
-##
-##        # Test input checking
-##        try:
-##            quantity.set_values(3.14, polygon=polygon, indices = [0,2])
-##        except:
-##            pass
-##        else:
-##            msg = 'Should have caught this'
-##            raise msg
-##
-##
-##
-##
-##
-##    def test_set_vertex_values_using_general_interface_subset_and_geo(self):
-##        """test_set_vertex_values_using_general_interface_with_subset(self):
-##        Test that indices and polygon works using georeferencing
-##        """
-##        
-##        quantity = Quantity(self.mesh4)
-##        G = Geo_reference(56, 10, 100)
-##        quantity.domain.geo_reference = G
-##
-##        #print quantity.domain.get_nodes(absolute=True)
-##
-##
-##        # Constant
-##        quantity.set_values(0.0)
-##        quantity.set_values(3.14, indices=[0,2], location='vertices')
-##
-##        # Indices refer to triangle numbers here - not vertices (why?)
-##        assert allclose(quantity.vertex_values,
-##                        [[3.14,3.14,3.14], [0,0,0],
-##                         [3.14,3.14,3.14], [0,0,0]])        
-##        
-##
-##
-##        # Now try with polygon (pick points where y>2)
-##        polygon = array([[0,2.1], [4,2.1], [4,7], [0,7]])
-##        polygon += [G.xllcorner, G.yllcorner]
-##        
-##        quantity.set_values(0.0)
-##        quantity.set_values(3.14, polygon=polygon, location='centroids')
-##        
-##        assert allclose(quantity.vertex_values,
-##                        [[0,0,0], [0,0,0], [0,0,0],
-##                         [3.14,3.14,3.14]])                
-##
-##
-##        # Another polygon (pick triangle 1 and 2 (rightmost triangles)
-##        polygon = array([[2.1, 0.0], [3.5,0.1], [2,2.2], [0.2,2]])
-##        polygon += [G.xllcorner, G.yllcorner]
-##        
-##        quantity.set_values(0.0)
-##        quantity.set_values(3.14, polygon=polygon)
-##
-##        assert allclose(quantity.vertex_values,
-##                        [[0,0,0],
-##                         [3.14,3.14,3.14],
-##                         [3.14,3.14,3.14],                         
-##                         [0,0,0]])                
-##
-##
-##
-##    def test_set_values_using_fit(self):
-##
-##
-##        quantity = Quantity(self.mesh4)
-##
-##        #Get (enough) datapoints
-##        data_points = [[ 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],
-##                       [ 1.0, 2.0],
-##                       [ 1.0, 3.0],
-##                       [ 2.0, 1.0],
-##                       [ 3.0, 0.0],
-##                       [ 3.0, 1.0]]
-##
-##        z = linear_function(data_points)
-##
-##        #Use built-in fit_interpolate.fit
-##        quantity.set_values( Geospatial_data(data_points, z), alpha = 0 )
-##        #quantity.set_values(points = data_points, values = z, alpha = 0)
-##
-##
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##        #print quantity.vertex_values, answer
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        #Now try by setting the same values directly
-##        vertex_attributes = fit_to_mesh(data_points,
-##                                        quantity.domain.get_nodes(),
-##                                        quantity.domain.triangles, #FIXME
-##                                        point_attributes=z,
-##                                        alpha = 0,
-##                                        verbose=False)
-##
-##        #print vertex_attributes
-##        quantity.set_values(vertex_attributes)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##
-##
-##
-##    def test_test_set_values_using_fit_w_geo(self):
-##
-##
-##        #Mesh
-##        vertex_coordinates = [[0.76, 0.76],
-##                              [0.76, 5.76],
-##                              [5.76, 0.76]]
-##        triangles = [[0,2,1]]
-##
-##        mesh_georef = Geo_reference(56,-0.76,-0.76)
-##        mesh1 = Domain(vertex_coordinates, triangles,
-##                       geo_reference = mesh_georef)
-##        mesh1.check_integrity()
-##
-##        #Quantity
-##        quantity = Quantity(mesh1)
-##
-##        #Data
-##        data_points = [[ 201.0, 401.0],
-##                       [ 201.0, 403.0],
-##                       [ 203.0, 401.0]]
-##
-##        z = [2, 4, 4]
-##
-##        data_georef = Geo_reference(56,-200,-400)
-##
-##
-##        #Reference
-##        ref = fit_to_mesh(data_points, vertex_coordinates, triangles,
-##                          point_attributes=z,
-##                          data_origin = data_georef.get_origin(),
-##                          mesh_origin = mesh_georef.get_origin(),
-##                          alpha = 0)
-##
-##        assert allclose( ref, [0,5,5] )
-##
-##
-##        #Test set_values
-##
-##        quantity.set_values( Geospatial_data(data_points, z, data_georef), alpha = 0 )
-##
-##        #quantity.set_values(points = data_points,
-##        #                    values = z,
-##        #                    data_georef = data_georef,
-##        #                    alpha = 0)
-##
-##
-##        #quantity.set_values(points = data_points,
-##        #                    values = z,
-##        #                    data_georef = data_georef,
-##        #                    alpha = 0)
-##        assert allclose(quantity.vertex_values.ravel(), ref)
-##
-##
-##
-##        #Test set_values using geospatial data object
-##        quantity.vertex_values[:] = 0.0
-##
-##        geo = Geospatial_data(data_points, z, data_georef)
-##
-##
-##        quantity.set_values(geospatial_data = geo, alpha = 0)
-##        assert allclose(quantity.vertex_values.ravel(), ref)
-##
-##
-##
-##    def test_set_values_from_file1(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Get (enough) datapoints
-##        data_points = [[ 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],
-##                       [ 1.0, 2.0],
-##                       [ 1.0, 3.0],
-##                       [ 2.0, 1.0],
-##                       [ 3.0, 0.0],
-##                       [ 3.0, 1.0]]
-##
-##        data_geo_spatial = Geospatial_data(data_points,
-##                         geo_reference = Geo_reference(56, 0, 0))
-##        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(data_points_absolute)
-##        att = 'spam_and_eggs'
-##        
-##        #Create .txt file
-##        ptsfile = tempfile.mktemp(".txt")
-##        file = open(ptsfile,"w")
-##        file.write(" x,y," + att + " \n")
-##        for data_point, attribute in map(None, data_points_absolute
-##                                         ,attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            file.write(row + "\n")
-##        file.close()
-##
-##
-##        #Check that values can be set from file
-##        quantity.set_values(filename = ptsfile,
-##                            attribute_name = att, alpha = 0)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##
-##        #print quantity.vertex_values.ravel()
-##        #print answer
-##
-##
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        #Check that values can be set from file using default attribute
-##        quantity.set_values(filename = ptsfile, alpha = 0)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Cleanup
-##        import os
-##        os.remove(ptsfile)
-##
-##
-##
-##    def Xtest_set_values_from_file_using_polygon(self):
-##        """test_set_values_from_file_using_polygon(self):
-##        
-##        Test that polygon restriction works for general points data
-##        """
-##        
-##        quantity = Quantity(self.mesh4)
-##
-##        #Get (enough) datapoints
-##        data_points = [[ 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],
-##                       [ 1.0, 2.0],
-##                       [ 1.0, 3.0],
-##                       [ 2.0, 1.0],
-##                       [ 3.0, 0.0],
-##                       [ 3.0, 1.0]]
-##
-##        data_geo_spatial = Geospatial_data(data_points,
-##                         geo_reference = Geo_reference(56, 0, 0))
-##        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(data_points_absolute)
-##        att = 'spam_and_eggs'
-##        
-##        #Create .txt file
-##        ptsfile = tempfile.mktemp(".txt")
-##        file = open(ptsfile,"w")
-##        file.write(" x,y," + att + " \n")
-##        for data_point, attribute in map(None, data_points_absolute
-##                                         ,attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            file.write(row + "\n")
-##        file.close()
-##
-##        # Create restricting polygon (containing node #4 (2,2) and 
-##        # centroid of triangle #1 (bce)
-##        polygon = [[1.0, 1.0], [4.0, 1.0],
-##                   [4.0, 4.0], [1.0, 4.0]]
-##
-##        #print self.mesh4.nodes
-##        #print inside_polygon(self.mesh4.nodes, polygon)
-##        assert allclose(inside_polygon(self.mesh4.nodes, polygon), 4)
-##
-##        #print quantity.domain.get_vertex_coordinates()
-##        #print quantity.domain.get_nodes()        
-##        
-##        # Check that values can be set from file
-##        quantity.set_values(filename=ptsfile,
-##                            polygon=polygon,
-##                            location='unique vertices',
-##                            alpha=0)
-##
-##        # Get indices for vertex coordinates in polygon
-##        indices = inside_polygon(quantity.domain.get_vertex_coordinates(), 
-##                                 polygon)
-##        points = take(quantity.domain.get_vertex_coordinates(), indices)
-##        
-##        answer = linear_function(points)
-##
-##        #print quantity.vertex_values.ravel()
-##        #print answer
-##
-##        # Check vertices in polygon have been set
-##        assert allclose(take(quantity.vertex_values.ravel(), indices),
-##                             answer)
-##
-##        # Check vertices outside polygon are zero
-##        indices = outside_polygon(quantity.domain.get_vertex_coordinates(), 
-##                                  polygon)        
-##        assert allclose(take(quantity.vertex_values.ravel(), indices),
-##                             0.0)        
-##
-##        #Cleanup
-##        import os
-##        os.remove(ptsfile)
-##
-##
-##        
-##
-##    def test_cache_test_set_values_from_file(self):
-##        # FIXME (Ole): What is this about?
-##        # I don't think it checks anything new
-##        quantity = Quantity(self.mesh4)
-##
-##        #Get (enough) datapoints
-##        data_points = [[ 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],
-##                       [ 1.0, 2.0],
-##                       [ 1.0, 3.0],
-##                       [ 2.0, 1.0],
-##                       [ 3.0, 0.0],
-##                       [ 3.0, 1.0]]
-##
-##        georef = Geo_reference(56, 0, 0)
-##        data_geo_spatial = Geospatial_data(data_points,
-##                                           geo_reference=georef)
-##                                           
-##        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(data_points_absolute)
-##        att = 'spam_and_eggs'
-##        
-##        # Create .txt file
-##        ptsfile = tempfile.mktemp(".txt")
-##        file = open(ptsfile,"w")
-##        file.write(" x,y," + att + " \n")
-##        for data_point, attribute in map(None, data_points_absolute
-##                                         ,attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            file.write(row + "\n")
-##        file.close()
-##
-##
-##        # Check that values can be set from file
-##        quantity.set_values(filename=ptsfile,
-##                            attribute_name=att, 
-##                            alpha=0, 
-##                            use_cache=True,
-##                            verbose=False)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        # Check that values can be set from file using default attribute
-##        quantity.set_values(filename=ptsfile, 
-##                            alpha=0)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        # Check cache
-##        quantity.set_values(filename=ptsfile,
-##                            attribute_name=att, 
-##                            alpha=0, 
-##                            use_cache=True,
-##                            verbose=False)
-##        
-##        
-##        #Cleanup
-##        import os
-##        os.remove(ptsfile)
-##
-##    def test_set_values_from_lat_long(self):
-##        quantity = Quantity(self.mesh_onslow)
-##
-##        #Get (enough) datapoints
-##        data_points = [[-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6]]
-##
-##        data_geo_spatial = Geospatial_data(data_points,
-##                                           points_are_lats_longs=True)
-##        points_UTM = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(points_UTM)
-##        att = 'elevation'
-##        
-##        #Create .txt file
-##        txt_file = tempfile.mktemp(".txt")
-##        file = open(txt_file,"w")
-##        file.write(" lat,long," + att + " \n")
-##        for data_point, attribute in map(None, data_points, attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            #print "row", row 
-##            file.write(row + "\n")
-##        file.close()
-##
-##
-##        #Check that values can be set from file
-##        quantity.set_values(filename=txt_file,
-##                            attribute_name=att, 
-##                            alpha=0)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##
-##        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
-##        #print "answer",answer
-##
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        #Check that values can be set from file using default attribute
-##        quantity.set_values(filename=txt_file, alpha=0)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Cleanup
-##        import os
-##        os.remove(txt_file)
-##         
-##    def test_set_values_from_lat_long(self):
-##        quantity = Quantity(self.mesh_onslow)
-##
-##        #Get (enough) datapoints
-##        data_points = [[-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6]]
-##
-##        data_geo_spatial = Geospatial_data(data_points,
-##                                           points_are_lats_longs=True)
-##        points_UTM = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(points_UTM)
-##        att = 'elevation'
-##        
-##        #Create .txt file
-##        txt_file = tempfile.mktemp(".txt")
-##        file = open(txt_file,"w")
-##        file.write(" lat,long," + att + " \n")
-##        for data_point, attribute in map(None, data_points, attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            #print "row", row 
-##            file.write(row + "\n")
-##        file.close()
-##
-##
-##        #Check that values can be set from file
-##        quantity.set_values(filename=txt_file,
-##                            attribute_name=att, alpha=0)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##
-##        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
-##        #print "answer",answer
-##
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        #Check that values can be set from file using default attribute
-##        quantity.set_values(filename=txt_file, alpha=0)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Cleanup
-##        import os
-##        os.remove(txt_file)
-##        
-##    def test_set_values_from_UTM_pts(self):
-##        quantity = Quantity(self.mesh_onslow)
-##
-##        #Get (enough) datapoints
-##        data_points = [[-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6]]
-##
-##        data_geo_spatial = Geospatial_data(data_points,
-##                                           points_are_lats_longs=True)
-##        points_UTM = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(points_UTM)
-##        att = 'elevation'
-##        
-##        #Create .txt file
-##        txt_file = tempfile.mktemp(".txt")
-##        file = open(txt_file,"w")
-##        file.write(" x,y," + att + " \n")
-##        for data_point, attribute in map(None, points_UTM, attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            #print "row", row 
-##            file.write(row + "\n")
-##        file.close()
-##
-##
-##        pts_file = tempfile.mktemp(".pts")        
-##        convert = Geospatial_data(txt_file)
-##        convert.export_points_file(pts_file)
-##
-##        #Check that values can be set from file
-##        quantity.set_values_from_file(pts_file, att, 0,
-##                                      'vertices', None)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
-##        #print "answer",answer
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Check that values can be set from file
-##        quantity.set_values(filename=pts_file,
-##                            attribute_name=att, alpha=0)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
-##        #print "answer",answer
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        #Check that values can be set from file using default attribute
-##        quantity.set_values(filename=txt_file, alpha=0)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Cleanup
-##        import os
-##        os.remove(txt_file)
-##        os.remove(pts_file)
-##        
-##    def verbose_test_set_values_from_UTM_pts(self):
-##        quantity = Quantity(self.mesh_onslow)
-##
-##        #Get (enough) datapoints
-##        data_points = [[-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
-##                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
-##                       ]
-##
-##        data_geo_spatial = Geospatial_data(data_points,
-##                                           points_are_lats_longs=True)
-##        points_UTM = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(points_UTM)
-##        att = 'elevation'
-##        
-##        #Create .txt file
-##        txt_file = tempfile.mktemp(".txt")
-##        file = open(txt_file,"w")
-##        file.write(" x,y," + att + " \n")
-##        for data_point, attribute in map(None, points_UTM, attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            #print "row", row 
-##            file.write(row + "\n")
-##        file.close()
-##
-##
-##        pts_file = tempfile.mktemp(".pts")        
-##        convert = Geospatial_data(txt_file)
-##        convert.export_points_file(pts_file)
-##
-##        #Check that values can be set from file
-##        quantity.set_values_from_file(pts_file, att, 0,
-##                                      'vertices', None, verbose = True,
-##                                      max_read_lines=2)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
-##        #print "answer",answer
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Check that values can be set from file
-##        quantity.set_values(filename=pts_file,
-##                            attribute_name=att, alpha=0)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
-##        #print "answer",answer
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        #Check that values can be set from file using default attribute
-##        quantity.set_values(filename=txt_file, alpha=0)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Cleanup
-##        import os
-##        os.remove(txt_file)
-##        os.remove(pts_file)
-##        
-##    def test_set_values_from_file_with_georef1(self):
-##
-##        #Mesh in zone 56 (absolute coords)
-##
-##        x0 = 314036.58727982
-##        y0 = 6224951.2960092
-##
-##        a = [x0+0.0, y0+0.0]
-##        b = [x0+0.0, y0+2.0]
-##        c = [x0+2.0, y0+0.0]
-##        d = [x0+0.0, y0+4.0]
-##        e = [x0+2.0, y0+2.0]
-##        f = [x0+4.0, y0+0.0]
-##
-##        points = [a, b, c, d, e, f]
-##
-##        #bac, bce, ecf, dbe
-##        elements = [ [1,0,2], [1,2,4], [4,2,5], [3,1,4] ]
-##
-##        #absolute going in ..
-##        mesh4 = Domain(points, elements,
-##                       geo_reference = Geo_reference(56, 0, 0))
-##        mesh4.check_integrity()
-##        quantity = Quantity(mesh4)
-##
-##        #Get (enough) datapoints (relative to georef)
-##        data_points_rel = [[ 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],
-##                       [ 1.0, 2.0],
-##                       [ 1.0, 3.0],
-##                       [ 2.0, 1.0],
-##                       [ 3.0, 0.0],
-##                       [ 3.0, 1.0]]
-##
-##        data_geo_spatial = Geospatial_data(data_points_rel,
-##                         geo_reference = Geo_reference(56, x0, y0))
-##        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(data_points_absolute)
-##        att = 'spam_and_eggs'
-##        
-##        #Create .txt file
-##        ptsfile = tempfile.mktemp(".txt")
-##        file = open(ptsfile,"w")
-##        file.write(" x,y," + att + " \n")
-##        for data_point, attribute in map(None, data_points_absolute
-##                                         ,attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            file.write(row + "\n")
-##        file.close()
-##
-##        #file = open(ptsfile, 'r')
-##        #lines = file.readlines()
-##        #file.close()
-##     
-##
-##        #Check that values can be set from file
-##        quantity.set_values(filename=ptsfile,
-##                            attribute_name=att, alpha=0)
-##        answer = linear_function(quantity.domain.get_vertex_coordinates())
-##
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        #Check that values can be set from file using default attribute
-##        quantity.set_values(filename=ptsfile, alpha=0)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Cleanup
-##        import os
-##        os.remove(ptsfile)
-##
-##
-##    def test_set_values_from_file_with_georef2(self):
-##
-##        #Mesh in zone 56 (relative coords)
-##
-##        x0 = 314036.58727982
-##        y0 = 6224951.2960092
-##        #x0 = 0.0
-##        #y0 = 0.0
-##
-##        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
-##        elements = [ [1,0,2], [1,2,4], [4,2,5], [3,1,4] ]
-##
-##        mesh4 = Domain(points, elements,
-##                       geo_reference = Geo_reference(56, x0, y0))
-##        mesh4.check_integrity()
-##        quantity = Quantity(mesh4)
-##
-##        #Get (enough) datapoints
-##        data_points = [[ x0+0.66666667, y0+0.66666667],
-##                       [ x0+1.33333333, y0+1.33333333],
-##                       [ x0+2.66666667, y0+0.66666667],
-##                       [ x0+0.66666667, y0+2.66666667],
-##                       [ x0+0.0, y0+1.0],
-##                       [ x0+0.0, y0+3.0],
-##                       [ x0+1.0, y0+0.0],
-##                       [ x0+1.0, y0+1.0],
-##                       [ x0+1.0, y0+2.0],
-##                       [ x0+1.0, y0+3.0],
-##                       [ x0+2.0, y0+1.0],
-##                       [ x0+3.0, y0+0.0],
-##                       [ x0+3.0, y0+1.0]]
-##
-##
-##        data_geo_spatial = Geospatial_data(data_points,
-##                         geo_reference = Geo_reference(56, 0, 0))
-##        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
-##        attributes = linear_function(data_points_absolute)
-##        att = 'spam_and_eggs'
-##        
-##        #Create .txt file
-##        ptsfile = tempfile.mktemp(".txt")
-##        file = open(ptsfile,"w")
-##        file.write(" x,y," + att + " \n")
-##        for data_point, attribute in map(None, data_points_absolute
-##                                         ,attributes):
-##            row = str(data_point[0]) + ',' + str(data_point[1]) \
-##                  + ',' + str(attribute)
-##            file.write(row + "\n")
-##        file.close()
-##
-##
-##        #Check that values can be set from file
-##        quantity.set_values(filename=ptsfile,
-##                            attribute_name=att, alpha=0)
-##        answer = linear_function(quantity.domain. \
-##                                 get_vertex_coordinates(absolute=True))
-##
-##
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##
-##        #Check that values can be set from file using default attribute
-##        quantity.set_values(filename=ptsfile, alpha=0)
-##        assert allclose(quantity.vertex_values.ravel(), answer)
-##
-##        #Cleanup
-##        import os
-##        os.remove(ptsfile)
-##
-##
-##
-##
-##    def test_set_values_from_quantity(self):
-##
-##        quantity1 = Quantity(self.mesh4)
-##        quantity1.set_vertex_values([0,1,2,3,4,5])
-##
-##        assert allclose(quantity1.vertex_values,
-##                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
-##
-##
-##        quantity2 = Quantity(self.mesh4)
-##        quantity2.set_values(quantity=quantity1)
-##        assert allclose(quantity2.vertex_values,
-##                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
-##
-##        quantity2.set_values(quantity = 2*quantity1)
-##        assert allclose(quantity2.vertex_values,
-##                        [[2,0,4], [2,4,8], [8,4,10], [6,2,8]])
-##
-##        quantity2.set_values(quantity = 2*quantity1 + 3)
-##        assert allclose(quantity2.vertex_values,
-##                        [[5,3,7], [5,7,11], [11,7,13], [9,5,11]])
-##
-##
-##        #Check detection of quantity as first orgument
-##        quantity2.set_values(2*quantity1 + 3)
-##        assert allclose(quantity2.vertex_values,
-##                        [[5,3,7], [5,7,11], [11,7,13], [9,5,11]])
-##
-##
-##
-##    def Xtest_set_values_from_quantity_using_polygon(self):
-##        """test_set_values_from_quantity_using_polygon(self):
-##        
-##        Check that polygon can be used to restrict set_values when
-##        using another quantity as argument.
-##        """
-##        
-##        # Create restricting polygon (containing node #4 (2,2) and 
-##        # centroid of triangle #1 (bce)
-##        polygon = [[1.0, 1.0], [4.0, 1.0],
-##                   [4.0, 4.0], [1.0, 4.0]]
-##        assert allclose(inside_polygon(self.mesh4.nodes, polygon), 4)                   
-##        
-##        quantity1 = Quantity(self.mesh4)
-##        quantity1.set_vertex_values([0,1,2,3,4,5])
-##
-##        assert allclose(quantity1.vertex_values,
-##                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
-##
-##
-##        quantity2 = Quantity(self.mesh4)
-##        quantity2.set_values(quantity=quantity1,
-##                             polygon=polygon)
-##                             
-##        msg = 'Only node #4(e) at (2,2) should have values applied '
-##        assert allclose(quantity2.vertex_values,
-##                        [[0,0,0], [0,0,4], [4,0,0], [0,0,4]]), msg        
-##                        #bac,     bce,     ecf,     dbe
-##                        
-##
-##
-##    def test_overloading(self):
-##
-##        quantity1 = Quantity(self.mesh4)
-##        quantity1.set_vertex_values([0,1,2,3,4,5])
-##
-##        assert allclose(quantity1.vertex_values,
-##                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
-##
-##
-##        quantity2 = Quantity(self.mesh4)
-##        quantity2.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
-##                             location = 'vertices')
-##
-##
-##
-##        quantity3 = Quantity(self.mesh4)
-##        quantity3.set_values([[2,2,2], [7,8,9], [7,6,3], [3, 8, -8]],
-##                             location = 'vertices')
-##
-##
-##        # Negation
-##        Q = -quantity1
-##        assert allclose(Q.vertex_values, -quantity1.vertex_values)
-##        assert allclose(Q.centroid_values, -quantity1.centroid_values)
-##        assert allclose(Q.edge_values, -quantity1.edge_values)
-##
-##        # Addition
-##        Q = quantity1 + 7
-##        assert allclose(Q.vertex_values, quantity1.vertex_values + 7)
-##        assert allclose(Q.centroid_values, quantity1.centroid_values + 7)
-##        assert allclose(Q.edge_values, quantity1.edge_values + 7)
-##
-##        Q = 7 + quantity1
-##        assert allclose(Q.vertex_values, quantity1.vertex_values + 7)
-##        assert allclose(Q.centroid_values, quantity1.centroid_values + 7)
-##        assert allclose(Q.edge_values, quantity1.edge_values + 7)
-##
-##        Q = quantity1 + quantity2
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values + quantity2.vertex_values)
-##        assert allclose(Q.centroid_values,
-##                        quantity1.centroid_values + quantity2.centroid_values)
-##        assert allclose(Q.edge_values,
-##                        quantity1.edge_values + quantity2.edge_values)
-##
-##
-##        Q = quantity1 + quantity2 - 3
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values + quantity2.vertex_values - 3)
-##
-##        Q = quantity1 - quantity2
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values - quantity2.vertex_values)
-##
-##        #Scaling
-##        Q = quantity1*3
-##        assert allclose(Q.vertex_values, quantity1.vertex_values*3)
-##        assert allclose(Q.centroid_values, quantity1.centroid_values*3)
-##        assert allclose(Q.edge_values, quantity1.edge_values*3)
-##        Q = 3*quantity1
-##        assert allclose(Q.vertex_values, quantity1.vertex_values*3)
-##
-##        #Multiplication
-##        Q = quantity1 * quantity2
-##        #print Q.vertex_values
-##        #print Q.centroid_values
-##        #print quantity1.centroid_values
-##        #print quantity2.centroid_values
-##
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values * quantity2.vertex_values)
-##
-##        #Linear combinations
-##        Q = 4*quantity1 + 2
-##        assert allclose(Q.vertex_values,
-##                        4*quantity1.vertex_values + 2)
-##
-##        Q = quantity1*quantity2 + 2
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values * quantity2.vertex_values + 2)
-##
-##        Q = quantity1*quantity2 + quantity3
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values * quantity2.vertex_values +
-##                        quantity3.vertex_values)
-##        Q = quantity1*quantity2 + 3*quantity3
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values * quantity2.vertex_values +
-##                        3*quantity3.vertex_values)
-##        Q = quantity1*quantity2 + 3*quantity3 + 5.0
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values * quantity2.vertex_values +
-##                        3*quantity3.vertex_values + 5)
-##
-##        Q = quantity1*quantity2 - quantity3
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values * quantity2.vertex_values -
-##                        quantity3.vertex_values)
-##        Q = 1.5*quantity1*quantity2 - 3*quantity3 + 5.0
-##        assert allclose(Q.vertex_values,
-##                        1.5*quantity1.vertex_values * quantity2.vertex_values -
-##                        3*quantity3.vertex_values + 5)
-##
-##        #Try combining quantities and arrays and scalars
-##        Q = 1.5*quantity1*quantity2.vertex_values -\
-##            3*quantity3.vertex_values + 5.0
-##        assert allclose(Q.vertex_values,
-##                        1.5*quantity1.vertex_values * quantity2.vertex_values -
-##                        3*quantity3.vertex_values + 5)
-##
-##
-##        #Powers
-##        Q = quantity1**2
-##        assert allclose(Q.vertex_values, quantity1.vertex_values**2)
-##
-##        Q = quantity1**2 +quantity2**2
-##        assert allclose(Q.vertex_values,
-##                        quantity1.vertex_values**2 + \
-##                        quantity2.vertex_values**2)
-##
-##        Q = (quantity1**2 +quantity2**2)**0.5
-##        assert allclose(Q.vertex_values,
-##                        (quantity1.vertex_values**2 + \
-##                        quantity2.vertex_values**2)**0.5)
-##
-##
-##
-##
-##
-##
-##
-##    def test_compute_gradient(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Set up for a gradient of (2,0) at mid triangle
-##        quantity.set_values([2.0, 4.0, 6.0, 2.0],
-##                            location = 'centroids')
-##
-##
-##        #Gradients
-##        quantity.compute_gradients()
-##
-##        a = quantity.x_gradient
-##        b = quantity.y_gradient
-##        #print self.mesh4.centroid_coordinates
-##        #print a, b
-##
-##        #The central triangle (1)
-##        #(using standard gradient based on neigbours controid values)
-##        assert allclose(a[1], 2.0)
-##        assert allclose(b[1], 0.0)
-##
-##
-##        #Left triangle (0) using two point gradient
-##        #q0 = q1 + a*(x0-x1) + b*(y0-y1)  <=>
-##        #2  = 4  + a*(-2/3)  + b*(-2/3)
-##        assert allclose(a[0] + b[0], 3)
-##        #From orthogonality (a*(y0-y1) + b*(x0-x1) == 0)
-##        assert allclose(a[0] - b[0], 0)
-##
-##
-##        #Right triangle (2) using two point gradient
-##        #q2 = q1 + a*(x2-x1) + b*(y2-y1)  <=>
-##        #6  = 4  + a*(4/3)  + b*(-2/3)
-##        assert allclose(2*a[2] - b[2], 3)
-##        #From orthogonality (a*(y1-y2) + b*(x2-x1) == 0)
-##        assert allclose(a[2] + 2*b[2], 0)
-##
-##
-##        #Top triangle (3) using two point gradient
-##        #q3 = q1 + a*(x3-x1) + b*(y3-y1)  <=>
-##        #2  = 4  + a*(-2/3)  + b*(4/3)
-##        assert allclose(a[3] - 2*b[3], 3)
-##        #From orthogonality (a*(y1-y3) + b*(x3-x1) == 0)
-##        assert allclose(2*a[3] + b[3], 0)
-##
-##
-##
-##        #print a, b
-##        quantity.extrapolate_second_order()
-##
-##        #Apply q(x,y) = qc + a*(x-xc) + b*(y-yc)
-##        assert allclose(quantity.vertex_values[0,:], [3., 0.,  3.])
-##        assert allclose(quantity.vertex_values[1,:], [4./3, 16./3,  16./3])
-##
-##
-##        #a = 1.2, b=-0.6
-##        #q(4,0) = 6 + a*(4 - 8/3) + b*(-2/3)
-##        assert allclose(quantity.vertex_values[2,2], 8)
-##
-##    def test_get_gradients(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Set up for a gradient of (2,0) at mid triangle
-##        quantity.set_values([2.0, 4.0, 6.0, 2.0],
-##                            location = 'centroids')
-##
-##
-##        #Gradients
-##        quantity.compute_gradients()
-##
-##        a, b = quantity.get_gradients()
-##        #print self.mesh4.centroid_coordinates
-##        #print a, b
-##
-##        #The central triangle (1)
-##        #(using standard gradient based on neigbours controid values)
-##        assert allclose(a[1], 2.0)
-##        assert allclose(b[1], 0.0)
-##
-##
-##        #Left triangle (0) using two point gradient
-##        #q0 = q1 + a*(x0-x1) + b*(y0-y1)  <=>
-##        #2  = 4  + a*(-2/3)  + b*(-2/3)
-##        assert allclose(a[0] + b[0], 3)
-##        #From orthogonality (a*(y0-y1) + b*(x0-x1) == 0)
-##        assert allclose(a[0] - b[0], 0)
-##
-##
-##        #Right triangle (2) using two point gradient
-##        #q2 = q1 + a*(x2-x1) + b*(y2-y1)  <=>
-##        #6  = 4  + a*(4/3)  + b*(-2/3)
-##        assert allclose(2*a[2] - b[2], 3)
-##        #From orthogonality (a*(y1-y2) + b*(x2-x1) == 0)
-##        assert allclose(a[2] + 2*b[2], 0)
-##
-##
-##        #Top triangle (3) using two point gradient
-##        #q3 = q1 + a*(x3-x1) + b*(y3-y1)  <=>
-##        #2  = 4  + a*(-2/3)  + b*(4/3)
-##        assert allclose(a[3] - 2*b[3], 3)
-##        #From orthogonality (a*(y1-y3) + b*(x3-x1) == 0)
-##        assert allclose(2*a[3] + b[3], 0)
-##
-##
-##    def test_second_order_extrapolation2(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Set up for a gradient of (3,1), f(x) = 3x+y
-##        quantity.set_values([2.0+2.0/3, 4.0+4.0/3, 8.0+2.0/3, 2.0+8.0/3],
-##                            location = 'centroids')
-##
-##        #Gradients
-##        quantity.compute_gradients()
-##
-##        a = quantity.x_gradient
-##        b = quantity.y_gradient
-##        
-##        #print a, b
-##
-##        assert allclose(a[1], 3.0)
-##        assert allclose(b[1], 1.0)
-##
-##        #Work out the others
-##
-##        quantity.extrapolate_second_order()
-##
-##        #print quantity.vertex_values
-##        assert allclose(quantity.vertex_values[1,0], 2.0)
-##        assert allclose(quantity.vertex_values[1,1], 6.0)
-##        assert allclose(quantity.vertex_values[1,2], 8.0)
-##
-##
-##
-##    def test_backup_saxpy_centroid_values(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Set up for a gradient of (3,1), f(x) = 3x+y
-##        c_values = array([2.0+2.0/3, 4.0+4.0/3, 8.0+2.0/3, 2.0+8.0/3])
-##        d_values = array([1.0, 2.0, 3.0, 4.0])
-##        quantity.set_values(c_values, location = 'centroids')
-##
-##        #Backup
-##        quantity.backup_centroid_values()
-##
-##        #print quantity.vertex_values
-##        assert allclose(quantity.centroid_values, quantity.centroid_backup_values)
-##
-##
-##        quantity.set_values(d_values, location = 'centroids')
-##
-##        quantity.saxpy_centroid_values(2.0, 3.0)
-##
-##        assert(quantity.centroid_values, 2.0*d_values + 3.0*c_values)
-##
-##
-##
-##    def test_first_order_extrapolator(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Test centroids
-##        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
-##        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
-##
-##        #Extrapolate
-##        quantity.extrapolate_first_order()
-##
-##        #Check that gradient is zero
-##        a,b = quantity.get_gradients()
-##        assert allclose(a, [0,0,0,0])
-##        assert allclose(b, [0,0,0,0])
-##
-##        #Check vertices but not edge values
-##        assert allclose(quantity.vertex_values,
-##                        [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
-##
-##
-##    def test_second_order_extrapolator(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Set up for a gradient of (3,0) at mid triangle
-##        quantity.set_values([2.0, 4.0, 8.0, 2.0],
-##                            location = 'centroids')
-##
-##
-##
-##        quantity.extrapolate_second_order()
-##        quantity.limit()
-##
-##
-##        #Assert that central triangle is limited by neighbours
-##        assert quantity.vertex_values[1,0] >= quantity.vertex_values[0,0]
-##        assert quantity.vertex_values[1,0] >= quantity.vertex_values[3,1]
-##
-##        assert quantity.vertex_values[1,1] <= quantity.vertex_values[2,1]
-##        assert quantity.vertex_values[1,1] >= quantity.vertex_values[0,2]
-##
-##        assert quantity.vertex_values[1,2] <= quantity.vertex_values[2,0]
-##        assert quantity.vertex_values[1,2] >= quantity.vertex_values[3,1]
-##
-##
-##        #Assert that quantities are conserved
-###        from numpy.oldnumeric import sum
-##        from numpy import sum
-##        for k in range(quantity.centroid_values.shape[0]):
-##            assert allclose (quantity.centroid_values[k],
-##                             sum(quantity.vertex_values[k,:])/3)
-##
-##
-##
-##
-##
-##    def test_limit_vertices_by_all_neighbours(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Create a deliberate overshoot (e.g. from gradient computation)
-##        quantity.set_values([[3,0,3], [2,2,6], [5,3,8], [8,3,5]])
-##
-##
-##        #Limit
-##        quantity.limit_vertices_by_all_neighbours()
-##
-##        #Assert that central triangle is limited by neighbours
-##        assert quantity.vertex_values[1,0] >= quantity.vertex_values[0,0]
-##        assert quantity.vertex_values[1,0] <= quantity.vertex_values[3,1]
-##
-##        assert quantity.vertex_values[1,1] <= quantity.vertex_values[2,1]
-##        assert quantity.vertex_values[1,1] >= quantity.vertex_values[0,2]
-##
-##        assert quantity.vertex_values[1,2] <= quantity.vertex_values[2,0]
-##        assert quantity.vertex_values[1,2] <= quantity.vertex_values[3,1]
-##
-##
-##
-##        #Assert that quantities are conserved
-###        from numpy.oldnumeric import sum
-##        from numpy import sum
-##        for k in range(quantity.centroid_values.shape[0]):
-##            assert allclose (quantity.centroid_values[k],
-##                             sum(quantity.vertex_values[k,:])/3)
-##
-##
-##
-##    def test_limit_edges_by_all_neighbours(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Create a deliberate overshoot (e.g. from gradient computation)
-##        quantity.set_values([[3,0,3], [2,2,6], [5,3,8], [8,3,5]])
-##
-##
-##        #Limit
-##        quantity.limit_edges_by_all_neighbours()
-##
-##        #Assert that central triangle is limited by neighbours
-##        assert quantity.edge_values[1,0] <= quantity.centroid_values[2]
-##        assert quantity.edge_values[1,0] >= quantity.centroid_values[0]
-##
-##        assert quantity.edge_values[1,1] <= quantity.centroid_values[2]
-##        assert quantity.edge_values[1,1] >= quantity.centroid_values[0]
-##
-##        assert quantity.edge_values[1,2] <= quantity.centroid_values[2]
-##        assert quantity.edge_values[1,2] >= quantity.centroid_values[0]
-##
-##
-##
-##        #Assert that quantities are conserved
-###        from numpy.oldnumeric import sum
-##        from numpy import sum
-##        for k in range(quantity.centroid_values.shape[0]):
-##            assert allclose (quantity.centroid_values[k],
-##                             sum(quantity.vertex_values[k,:])/3)
-##
-##
-##    def test_limit_edges_by_neighbour(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Create a deliberate overshoot (e.g. from gradient computation)
-##        quantity.set_values([[3,0,3], [2,2,6], [5,3,8], [8,3,5]])
-##
-##
-##        #Limit
-##        quantity.limit_edges_by_neighbour()
-##
-##        #Assert that central triangle is limited by neighbours
-##        assert quantity.edge_values[1,0] <= quantity.centroid_values[3]
-##        assert quantity.edge_values[1,0] >= quantity.centroid_values[1]
-##
-##        assert quantity.edge_values[1,1] <= quantity.centroid_values[2]
-##        assert quantity.edge_values[1,1] >= quantity.centroid_values[1]
-##
-##        assert quantity.edge_values[1,2] <= quantity.centroid_values[1]
-##        assert quantity.edge_values[1,2] >= quantity.centroid_values[0]
-##
-##
-##
-##        #Assert that quantities are conserved
-###        from numpy.oldnumeric import sum
-##        from numpy import sum
-##        for k in range(quantity.centroid_values.shape[0]):
-##            assert allclose (quantity.centroid_values[k],
-##                             sum(quantity.vertex_values[k,:])/3)
-##
-##    def test_limiter2(self):
-##        """Taken from test_shallow_water
-##        """
-##        quantity = Quantity(self.mesh4)
-##        quantity.domain.beta_w = 0.9
-##        
-##        #Test centroids
-##        quantity.set_values([2.,4.,8.,2.], location = 'centroids')
-##        assert allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
-##
-##
-##        #Extrapolate
-##        quantity.extrapolate_second_order()
-##
-##        assert allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
-##
-##        #Limit
-##        quantity.limit()
-##
-##        # limited value for beta_w = 0.9
-##        
-##        assert allclose(quantity.vertex_values[1,:], [2.2, 4.9, 4.9])
-##        # limited values for beta_w = 0.5
-##        #assert allclose(quantity.vertex_values[1,:], [3.0, 4.5, 4.5])
-##
-##
-##        #Assert that quantities are conserved
-###        from numpy.oldnumeric import sum
-##        from numpy import sum
-##        for k in range(quantity.centroid_values.shape[0]):
-##            assert allclose (quantity.centroid_values[k],
-##                             sum(quantity.vertex_values[k,:])/3)
-##
-##
-##
-##
-##
-##    def test_distribute_first_order(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Test centroids
-##        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
-##        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
-##
-##
-##        #Extrapolate from centroid to vertices and edges
-##        quantity.extrapolate_first_order()
-##
-##        #Interpolate
-##        #quantity.interpolate_from_vertices_to_edges()
-##
-##        assert allclose(quantity.vertex_values,
-##                        [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
-##        assert allclose(quantity.edge_values, [[1,1,1], [2,2,2],
-##                                               [3,3,3], [4, 4, 4]])
-##
-##
-##    def test_interpolate_from_vertices_to_edges(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        quantity.vertex_values = array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]],float)
-##
-##        quantity.interpolate_from_vertices_to_edges()
-##
-##        assert allclose(quantity.edge_values, [[1., 1.5, 0.5],
-##                                               [3., 2.5, 1.5],
-##                                               [3.5, 4.5, 3.],
-##                                               [2.5, 3.5, 2]])
-##
-##
-##    def test_interpolate_from_edges_to_vertices(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        quantity.edge_values = array([[1., 1.5, 0.5],
-##                                [3., 2.5, 1.5],
-##                                [3.5, 4.5, 3.],
-##                                [2.5, 3.5, 2]],float)
-##
-##        quantity.interpolate_from_edges_to_vertices()
-##
-##        assert allclose(quantity.vertex_values,
-##                        [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
-##
-##
-##
-##    def test_distribute_second_order(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Test centroids
-##        quantity.set_values([2.,4.,8.,2.], location = 'centroids')
-##        assert allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
-##
-##
-##        #Extrapolate
-##        quantity.extrapolate_second_order()
-##
-##        assert allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
-##
-##
-##    def test_update_explicit(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Test centroids
-##        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
-##        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
-##
-##        #Set explicit_update
-##        quantity.explicit_update = array( [1.,1.,1.,1.] )
-##
-##        #Update with given timestep
-##        quantity.update(0.1)
-##
-##        x = array([1, 2, 3, 4]) + array( [.1,.1,.1,.1] )
-##        assert allclose( quantity.centroid_values, x)
-##
-##    def test_update_semi_implicit(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Test centroids
-##        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
-##        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
-##
-##        #Set semi implicit update
-##        quantity.semi_implicit_update = array([1.,1.,1.,1.])
-##
-##        #Update with given timestep
-##        timestep = 0.1
-##        quantity.update(timestep)
-##
-##        sem = array([1.,1.,1.,1.])/array([1, 2, 3, 4])
-##        denom = ones(4, float)-timestep*sem
-##
-##        x = array([1, 2, 3, 4])/denom
-##        assert allclose( quantity.centroid_values, x)
-##
-##
-##    def test_both_updates(self):
-##        quantity = Quantity(self.mesh4)
-##
-##        #Test centroids
-##        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
-##        assert allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
-##
-##        #Set explicit_update
-##        quantity.explicit_update = array( [4.,3.,2.,1.] )
-##
-##        #Set semi implicit update
-##        quantity.semi_implicit_update = array( [1.,1.,1.,1.] )
-##
-##        #Update with given timestep
-##        timestep = 0.1
-##        quantity.update(0.1)
-##
-##        sem = array([1.,1.,1.,1.])/array([1, 2, 3, 4])
-##        denom = ones(4, float)-timestep*sem
-##
-##        x = array([1., 2., 3., 4.])
-##        x /= denom
-##        x += timestep*array( [4.0, 3.0, 2.0, 1.0] )
-##
-##        assert allclose( quantity.centroid_values, x)
-##
-##
-##
-##
-##    #Test smoothing
-##    def test_smoothing(self):
-##
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain, Transmissive_boundary
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##        from anuga.utilities.numerical_tools import mean
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(2, 2)
-##
-##        #Create shallow water domain
-##        domain = Domain(points, vertices, boundary)
-##        domain.default_order=2
-##        domain.reduction = mean
-##
-##
-##        #Set some field values
-##        domain.set_quantity('elevation', lambda x,y: x)
-##        domain.set_quantity('friction', 0.03)
-##
-##
-##        ######################
-##        # Boundary conditions
-##        B = Transmissive_boundary(domain)
-##        domain.set_boundary( {'left': B, 'right': B, 'top': B, 'bottom': B})
-##
-##
-##        ######################
-##        #Initial condition - with jumps
-##
-##        bed = domain.quantities['elevation'].vertex_values
-##        stage = zeros(bed.shape, float)
-##
-##        h = 0.03
-##        for i in range(stage.shape[0]):
-##            if i % 2 == 0:
-##                stage[i,:] = bed[i,:] + h
-##            else:
-##                stage[i,:] = bed[i,:]
-##
-##        domain.set_quantity('stage', stage)
-##
-##        stage = domain.quantities['stage']
-##
-##        #Get smoothed stage
-##        A, V = stage.get_vertex_values(xy=False, smooth=True)
-##        Q = stage.vertex_values
-##
-##
-##        assert A.shape[0] == 9
-##        assert V.shape[0] == 8
-##        assert V.shape[1] == 3
-##
-##        #First four points
-##        assert allclose(A[0], (Q[0,2] + Q[1,1])/2)
-##        assert allclose(A[1], (Q[1,0] + Q[3,1] + Q[2,2])/3)
-##        assert allclose(A[2], Q[3,0])
-##        assert allclose(A[3], (Q[0,0] + Q[5,1] + Q[4,2])/3)
-##
-##        #Center point
-##        assert allclose(A[4], (Q[0,1] + Q[1,2] + Q[2,0] +\
-##                               Q[5,0] + Q[6,2] + Q[7,1])/6)
-##
-##
-##        #Check V
-##        assert allclose(V[0,:], [3,4,0])
-##        assert allclose(V[1,:], [1,0,4])
-##        assert allclose(V[2,:], [4,5,1])
-##        assert allclose(V[3,:], [2,1,5])
-##        assert allclose(V[4,:], [6,7,3])
-##        assert allclose(V[5,:], [4,3,7])
-##        assert allclose(V[6,:], [7,8,4])
-##        assert allclose(V[7,:], [5,4,8])
-##
-##        #Get smoothed stage with XY
-##        X, Y, A1, V1 = stage.get_vertex_values(xy=True, smooth=True)
-##
-##        assert allclose(A, A1)
-##        assert allclose(V, V1)
-##
-##        #Check XY
-##        assert allclose(X[4], 0.5)
-##        assert allclose(Y[4], 0.5)
-##
-##        assert allclose(X[7], 1.0)
-##        assert allclose(Y[7], 0.5)
-##
-##
-##
-##
-##    def test_vertex_values_no_smoothing(self):
-##
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain, Transmissive_boundary
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##        from anuga.utilities.numerical_tools import mean
-##
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(2, 2)
-##
-##        #Create shallow water domain
-##        domain = Domain(points, vertices, boundary)
-##        domain.default_order=2
-##        domain.reduction = mean
-##
-##
-##        #Set some field values
-##        domain.set_quantity('elevation', lambda x,y: x)
-##        domain.set_quantity('friction', 0.03)
-##
-##
-##        ######################
-##        #Initial condition - with jumps
-##
-##        bed = domain.quantities['elevation'].vertex_values
-##        stage = zeros(bed.shape, float)
-##
-##        h = 0.03
-##        for i in range(stage.shape[0]):
-##            if i % 2 == 0:
-##                stage[i,:] = bed[i,:] + h
-##            else:
-##                stage[i,:] = bed[i,:]
-##
-##        domain.set_quantity('stage', stage)
-##
-##        #Get stage
-##        stage = domain.quantities['stage']
-##        A, V = stage.get_vertex_values(xy=False, smooth=False)
-##        Q = stage.vertex_values.ravel()
-##
-##        for k in range(8):
-##            assert allclose(A[k], Q[k])
-##
-##
-##        for k in range(8):
-##            assert V[k, 0] == 3*k
-##            assert V[k, 1] == 3*k+1
-##            assert V[k, 2] == 3*k+2
-##
-##
-##
-##        X, Y, A1, V1 = stage.get_vertex_values(xy=True, smooth=False)
-##
-##
-##        assert allclose(A, A1)
-##        assert allclose(V, V1)
-##
-##        #Check XY
-##        assert allclose(X[1], 0.5)
-##        assert allclose(Y[1], 0.5)
-##        assert allclose(X[4], 0.0)
-##        assert allclose(Y[4], 0.0)
-##        assert allclose(X[12], 1.0)
-##        assert allclose(Y[12], 0.0)
-##
-##
-##
-##    def set_array_values_by_index(self):
-##
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(1, 1)
-##
-##        #Create shallow water domain
-##        domain = Domain(points, vertices, boundary)
-##        #print "domain.number_of_elements ",domain.number_of_elements
-##        quantity = Quantity(domain,[[1,1,1],[2,2,2]])
-##        value = [7]
-##        indices = [1]
-##        quantity.set_array_values_by_index(value,
-##                                           location = 'centroids',
-##                                           indices = indices)
-##        #print "quantity.centroid_values",quantity.centroid_values
-##
-##        assert allclose(quantity.centroid_values, [1,7])
-##
-##        quantity.set_array_values([15,20,25], indices = indices)
-##        assert allclose(quantity.centroid_values, [1,20])
-##
-##        quantity.set_array_values([15,20,25], indices = indices)
-##        assert allclose(quantity.centroid_values, [1,20])
-##
-##    def test_setting_some_vertex_values(self):
-##        """
-##        set values based on triangle lists.
-##        """
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(1, 3)
-##        #print "vertices",vertices
-##        #Create shallow water domain
-##        domain = Domain(points, vertices, boundary)
-##        #print "domain.number_of_elements ",domain.number_of_elements
-##        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5],[6,6,6]])
-##
-##
-##        # Check that constants work
-##        value = 7
-##        indices = [1]
-##        quantity.set_values(value,
-##                            location = 'centroids',
-##                            indices = indices)
-##        #print "quantity.centroid_values",quantity.centroid_values
-##        assert allclose(quantity.centroid_values, [1,7,3,4,5,6])
-##        
-##        value = [7]
-##        indices = [1]
-##        quantity.set_values(value,
-##                            location = 'centroids',
-##                            indices = indices)
-##        #print "quantity.centroid_values",quantity.centroid_values
-##        assert allclose(quantity.centroid_values, [1,7,3,4,5,6])
-##
-##        value = [[15,20,25]]
-##        quantity.set_values(value, indices = indices)
-##        #print "1 quantity.vertex_values",quantity.vertex_values
-##        assert allclose(quantity.vertex_values[1], value[0])
-##
-##
-##        #print "quantity",quantity.vertex_values
-##        values = [10,100,50]
-##        quantity.set_values(values, indices = [0,1,5], location = 'centroids')
-##        #print "2 quantity.vertex_values",quantity.vertex_values
-##        assert allclose(quantity.vertex_values[0], [10,10,10])
-##        assert allclose(quantity.vertex_values[5], [50,50,50])
-##        #quantity.interpolate()
-##        #print "quantity.centroid_values",quantity.centroid_values
-##        assert allclose(quantity.centroid_values, [10,100,3,4,5,50])
-##
-##
-##        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5],[6,6,6]])
-##        values = [10,100,50]
-##        #this will be per unique vertex, indexing the vertices
-##        #print "quantity.vertex_values",quantity.vertex_values
-##        quantity.set_values(values, indices = [0,1,5])
-##        #print "quantity.vertex_values",quantity.vertex_values
-##        assert allclose(quantity.vertex_values[0], [1,50,10])
-##        assert allclose(quantity.vertex_values[5], [6,6,6])
-##        assert allclose(quantity.vertex_values[1], [100,10,50])
-##
-##        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5],[6,6,6]])
-##        values = [[31,30,29],[400,400,400],[1000,999,998]]
-##        quantity.set_values(values, indices = [3,3,5])
-##        quantity.interpolate()
-##        assert allclose(quantity.centroid_values, [1,2,3,400,5,999])
-##
-##        values = [[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5],[6,6,6]]
-##        quantity.set_values(values)
-##
-##        # testing the standard set values by vertex
-##        # indexed by vertex_id in general_mesh.coordinates
-##        values = [0,1,2,3,4,5,6,7]
-##
-##        quantity.set_values(values)
-##        #print "1 quantity.vertex_values",quantity.vertex_values
-##        assert allclose(quantity.vertex_values,[[ 4.,  5.,  0.],
-##                                                [ 1.,  0.,  5.],
-##                                                [ 5.,  6.,  1.],
-##                                                [ 2.,  1.,  6.],
-##                                                [ 6.,  7.,  2.],
-##                                                [ 3.,  2.,  7.]])
-##
-##    def test_setting_unique_vertex_values(self):
-##        """
-##        set values based on unique_vertex lists.
-##        """
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(1, 3)
-##        #print "vertices",vertices
-##        #Create shallow water domain
-##        domain = Domain(points, vertices, boundary)
-##        #print "domain.number_of_elements ",domain.number_of_elements
-##        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5]])
-##        value = 7
-##        indices = [1,5]
-##        quantity.set_values(value,
-##                            location = 'unique vertices',
-##                            indices = indices)
-##        #print "quantity.centroid_values",quantity.centroid_values
-##        assert allclose(quantity.vertex_values[0], [0,7,0])
-##        assert allclose(quantity.vertex_values[1], [7,1,7])
-##        assert allclose(quantity.vertex_values[2], [7,2,7])
-##
-##
-##    def test_get_values(self):
-##        """
-##        get values based on triangle lists.
-##        """
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(1, 3)
-##
-##        #print "points",points
-##        #print "vertices",vertices
-##        #print "boundary",boundary
-##
-##        #Create shallow water domain
-##        domain = Domain(points, vertices, boundary)
-##        #print "domain.number_of_elements ",domain.number_of_elements
-##        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5]])
-##
-##        #print "quantity.get_values(location = 'unique vertices')", \
-##        #      quantity.get_values(location = 'unique vertices')
-##
-##        #print "quantity.get_values(location = 'unique vertices')", \
-##        #      quantity.get_values(indices=[0,1,2,3,4,5,6,7], \
-##        #                          location = 'unique vertices')
-##
-##        answer = [0.5,2,4,5,0,1,3,4.5]
-##        assert allclose(answer,
-##                        quantity.get_values(location = 'unique vertices'))
-##
-##        indices = [0,5,3]
-##        answer = [0.5,1,5]
-##        assert allclose(answer,
-##                        quantity.get_values(indices=indices, \
-##                                            location = 'unique vertices'))
-##        #print "quantity.centroid_values",quantity.centroid_values
-##        #print "quantity.get_values(location = 'centroids') ",\
-##        #      quantity.get_values(location = 'centroids')
-##
-##
-##
-##
-##    def test_get_values_2(self):
-##        """Different mesh (working with domain object) - also check centroids.
-##        """
-##
-##        
-##        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)
-##
-##        quantity = Quantity(domain)
-##        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
-##        
-##        assert allclose(quantity.get_values(location='centroids'), [2,4,4,6])
-##        assert allclose(quantity.get_values(location='centroids', indices=[1,3]), [4,6])
-##
-##
-##        assert allclose(quantity.get_values(location='vertices'), [[4,0,2],
-##                                                                   [4,2,6],
-##                                                                   [6,2,4],
-##                                                                   [8,4,6]])
-##        
-##        assert allclose(quantity.get_values(location='vertices', indices=[1,3]), [[4,2,6],
-##                                                                                  [8,4,6]])
-##
-##
-##        assert allclose(quantity.get_values(location='edges'), [[1,3,2],
-##                                                                [4,5,3],
-##                                                                [3,5,4],
-##                                                                [5,7,6]])
-##        assert allclose(quantity.get_values(location='edges', indices=[1,3]),
-##                        [[4,5,3],
-##                         [5,7,6]])        
-##
-##        # Check averaging over vertices
-##        #a: 0
-##        #b: (4+4+4)/3
-##        #c: (2+2+2)/3
-##        #d: 8
-##        #e: (6+6+6)/3        
-##        #f: 4
-##        assert(quantity.get_values(location='unique vertices'), [0, 4, 2, 8, 6, 4])        
-##                                                                                  
-##        
-##
-##
-##
-##
-##    def test_get_interpolated_values(self):
-##
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(1, 3)
-##        domain = Domain(points, vertices, boundary)
-##
-##        #Constant values
-##        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5]])
-##
-##        
-##
-##        # Get interpolated values at centroids
-##        interpolation_points = domain.get_centroid_coordinates()
-##        answer = quantity.get_values(location='centroids')
-##
-##        
-##        #print quantity.get_values(points=interpolation_points)
-##        assert allclose(answer, quantity.get_values(interpolation_points=interpolation_points))
-##
-##
-##        #Arbitrary values
-##        quantity = Quantity(domain,[[0,1,2],[3,1,7],[2,1,2],[3,3,7],
-##                                    [1,4,-9],[2,5,0]])
-##
-##
-##        # Get interpolated values at centroids
-##        interpolation_points = domain.get_centroid_coordinates()
-##        answer = quantity.get_values(location='centroids')
-##        #print answer
-##        #print quantity.get_values(interpolation_points=interpolation_points)
-##        assert allclose(answer, quantity.get_values(interpolation_points=interpolation_points,
-##                                                    verbose=False))        
-##                        
-##
-##        #FIXME TODO
-##        #indices = [0,5,3]
-##        #answer = [0.5,1,5]
-##        #assert allclose(answer,
-##        #                quantity.get_values(indices=indices, \
-##        #                                    location = 'unique vertices'))
-##
-##
-##
-##
-##    def test_get_interpolated_values_2(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
-##        vertices = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
-##
-##        domain = Domain(points, vertices)
-##
-##        quantity = Quantity(domain)
-##        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
-##
-##        #First pick one point
-##        x, y = 2.0/3, 8.0/3
-##        v = quantity.get_values(interpolation_points = [[x,y]])
-##        assert allclose(v, 6)        
-##
-##        # Then another to test that algorithm won't blindly
-##        # reuse interpolation matrix
-##        x, y = 4.0/3, 4.0/3
-##        v = quantity.get_values(interpolation_points = [[x,y]])
-##        assert allclose(v, 4)        
-##
-##
-##
-##    def test_get_interpolated_values_with_georef(self):
-##    
-##        zone = 56
-##        xllcorner = 308500
-##        yllcorner = 6189000
-##        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,
-##                        geo_reference=Geo_reference(zone,xllcorner,yllcorner))
-##
-##        quantity = Quantity(domain)
-##        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
-##
-##        #First pick one point (and turn it into absolute coordinates)
-##        x, y = 2.0/3, 8.0/3
-##        v = quantity.get_values(interpolation_points = [[x+xllcorner,y+yllcorner]])
-##        assert allclose(v, 6)
-##        
-##
-##        # Then another to test that algorithm won't blindly
-##        # reuse interpolation matrix 
-##        x, y = 4.0/3, 4.0/3
-##        v = quantity.get_values(interpolation_points = [[x+xllcorner,y+yllcorner]])
-##        assert allclose(v, 4)        
-##        
-##        # Try two points
-##        pts = [[2.0/3 + xllcorner, 8.0/3 + yllcorner], 
-##               [4.0/3 + xllcorner, 4.0/3 + yllcorner]]         
-##        v = quantity.get_values(interpolation_points=pts)
-##        assert allclose(v, [6, 4])               
-##        
-##        # Test it using the geospatial data format with absolute input points and default georef
-##        pts = Geospatial_data(data_points=pts)
-##        v = quantity.get_values(interpolation_points=pts)
-##        assert allclose(v, [6, 4])                                
-##        
-##        
-##        # Test it using the geospatial data format with relative input points
-##        pts = Geospatial_data(data_points=[[2.0/3, 8.0/3], [4.0/3, 4.0/3]], 
-##                              geo_reference=Geo_reference(zone,xllcorner,yllcorner))
-##        v = quantity.get_values(interpolation_points=pts)
-##        assert allclose(v, [6, 4])                        
-##        
-##        
-##        
-##
-##    def test_getting_some_vertex_values(self):
-##        """
-##        get values based on triangle lists.
-##        """
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(1, 3)
-##
-##        #print "points",points
-##        #print "vertices",vertices
-##        #print "boundary",boundary
-##
-##        #Create shallow water domain
-##        domain = Domain(points, vertices, boundary)
-##        #print "domain.number_of_elements ",domain.number_of_elements
-##        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5],[6,6,6]])
-##        value = [7]
-##        indices = [1]
-##        quantity.set_values(value,
-##                            location = 'centroids',
-##                            indices = indices)
-##        #print "quantity.centroid_values",quantity.centroid_values
-##        #print "quantity.get_values(location = 'centroids') ",\
-##        #      quantity.get_values(location = 'centroids')
-##        assert allclose(quantity.centroid_values,
-##                        quantity.get_values(location = 'centroids'))
-##
-##
-##        value = [[15,20,25]]
-##        quantity.set_values(value, indices = indices)
-##        #print "1 quantity.vertex_values",quantity.vertex_values
-##        assert allclose(quantity.vertex_values, quantity.get_values())
-##
-##        assert allclose(quantity.edge_values,
-##                        quantity.get_values(location = 'edges'))
-##
-##        # get a subset of elements
-##        subset = quantity.get_values(location='centroids', indices=[0,5])
-##        answer = [quantity.centroid_values[0],quantity.centroid_values[5]]
-##        assert allclose(subset, answer)
-##
-##
-##        subset = quantity.get_values(location='edges', indices=[0,5])
-##        answer = [quantity.edge_values[0],quantity.edge_values[5]]
-##        #print "subset",subset
-##        #print "answer",answer
-##        assert allclose(subset, answer)
-##
-##        subset = quantity.get_values( indices=[1,5])
-##        answer = [quantity.vertex_values[1],quantity.vertex_values[5]]
-##        #print "subset",subset
-##        #print "answer",answer
-##        assert allclose(subset, answer)
-##
-##    def test_smooth_vertex_values(self):
-##        """
-##        get values based on triangle lists.
-##        """
-##        from mesh_factory import rectangular
-##        from shallow_water import Domain
-###        from numpy.oldnumeric import zeros, Float
-##        from numpy import zeros, float
-##
-##        #Create basic mesh
-##        points, vertices, boundary = rectangular(2, 2)
-##
-##        #print "points",points
-##        #print "vertices",vertices
-##        #print "boundary",boundary
-##
-##        #Create shallow water domain
-##        domain = Domain(points, vertices, boundary)
-##        #print "domain.number_of_elements ",domain.number_of_elements
-##        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
-##                                    [4,4,4],[5,5,5],[6,6,6],[7,7,7]])
-##
-##        #print "quantity.get_values(location = 'unique vertices')", \
-##        #      quantity.get_values(location = 'unique vertices')
-##
-##        #print "quantity.get_values(location = 'unique vertices')", \
-##        #      quantity.get_values(indices=[0,1,2,3,4,5,6,7], \
-##        #                          location = 'unique vertices')
-##
-##        #print quantity.get_values(location = 'unique vertices')
-##        #print quantity.domain.number_of_triangles_per_node
-##        #print quantity.vertex_values
-##        
-##        #answer = [0.5, 2, 3, 3, 3.5, 4, 4, 5, 6.5]
-##        #assert allclose(answer,
-##        #                quantity.get_values(location = 'unique vertices'))
-##
-##        quantity.smooth_vertex_values()
-##
-##        #print quantity.vertex_values
-##
-##
-##        answer_vertex_values = [[3,3.5,0.5],[2,0.5,3.5],[3.5,4,2],[3,2,4],
-##                                [4,5,3],[3.5,3,5],[5,6.5,3.5],[4,3.5,6.5]]
-##        
-##        assert allclose(answer_vertex_values,
-##                        quantity.vertex_values)
-##        #print "quantity.centroid_values",quantity.centroid_values
-##        #print "quantity.get_values(location = 'centroids') ",\
-##        #      quantity.get_values(location = 'centroids')
+        assert numpy.allclose(v, 0)
+
+
+    def test_get_maximum_2(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
+        vertices = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
+
+        domain = Domain(points, vertices)
+
+        quantity = Quantity(domain)
+        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
+        
+        v = quantity.get_maximum_value()
+        assert v == 6
+
+        v = quantity.get_minimum_value()
+        assert v == 2        
+
+        i = quantity.get_maximum_index()
+        assert i == 3
+
+        i = quantity.get_minimum_index()
+        assert i == 0        
+        
+        x,y = quantity.get_maximum_location()
+        xref, yref = 2.0/3, 8.0/3
+        assert x == xref
+        assert y == yref
+
+        v = quantity.get_values(interpolation_points = [[x,y]])
+        assert numpy.allclose(v, 6)
+
+        x,y = quantity.get_minimum_location()        
+        v = quantity.get_values(interpolation_points = [[x,y]])
+        assert numpy.allclose(v, 2)
+
+        #Multiple locations for maximum -
+        #Test that the algorithm picks the first occurrence        
+        v = quantity.get_maximum_value(indices=[0,1,2])
+        assert numpy.allclose(v, 4)
+
+        i = quantity.get_maximum_index(indices=[0,1,2])
+        assert i == 1
+        
+        x,y = quantity.get_maximum_location(indices=[0,1,2])
+        xref, yref = 4.0/3, 4.0/3
+        assert x == xref
+        assert y == yref
+
+        v = quantity.get_values(interpolation_points = [[x,y]])
+        assert numpy.allclose(v, 4)        
+
+        # More test of indices......
+        v = quantity.get_maximum_value(indices=[2,3])
+        assert numpy.allclose(v, 6)
+
+        i = quantity.get_maximum_index(indices=[2,3])
+        assert i == 3
+        
+        x,y = quantity.get_maximum_location(indices=[2,3])
+        xref, yref = 2.0/3, 8.0/3
+        assert x == xref
+        assert y == yref
+
+        v = quantity.get_values(interpolation_points = [[x,y]])
+        assert numpy.allclose(v, 6)        
+
+        
+
+    def test_boundary_allocation(self):
+        quantity = Quantity(self.mesh4,
+                            [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
+
+        assert quantity.boundary_values.shape[0] == len(self.mesh4.boundary)
+
+
+    def test_set_values(self):
+        quantity = Quantity(self.mesh4)
+
+
+        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
+                            location = 'vertices')
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
+        assert numpy.allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
+        assert numpy.allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
+                                                     [5., 5., 5.],
+                                                     [4.5, 4.5, 0.],
+                                                     [3.0, -1.5, -1.5]])
+
+
+        # Test default
+        quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]])
+        assert numpy.allclose(quantity.centroid_values, [2., 5., 3., 0.]) #Centroid
+        assert numpy.allclose(quantity.edge_values, [[2.5, 2.0, 1.5],
+                                                     [5., 5., 5.],
+                                                     [4.5, 4.5, 0.],
+                                                     [3.0, -1.5, -1.5]])
+
+        # Test centroids
+        quantity.set_values([1,2,3,4], location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [1., 2., 3., 4.]) #Centroid
+
+        # Test exceptions
+        try:
+            quantity.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
+                                location = 'bas kamel tuba')
+        except:
+            pass
+
+
+        try:
+            quantity.set_values([[1,2,3], [0,0,9]])
+        except AssertionError:
+            pass
+        except:
+            raise 'should have raised Assertionerror'
+
+
+
+    def test_set_values_const(self):
+        quantity = Quantity(self.mesh4)
+
+        quantity.set_values(1.0, location = 'vertices')
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,1,1], [1,1,1], [1,1,1], [1, 1, 1]])
+
+        assert numpy.allclose(quantity.centroid_values, [1, 1, 1, 1]) #Centroid
+        assert numpy.allclose(quantity.edge_values, [[1, 1, 1],
+                                                     [1, 1, 1],
+                                                     [1, 1, 1],
+                                                     [1, 1, 1]])
+
+
+        quantity.set_values(2.0, location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [2, 2, 2, 2])
+
+
+    def test_set_values_func(self):
+        quantity = Quantity(self.mesh4)
+
+        def f(x, y):
+            return x+y
+
+        quantity.set_values(f, location = 'vertices')
+        #print "quantity.vertex_values",quantity.vertex_values
+        assert numpy.allclose(quantity.vertex_values,
+                              [[2,0,2], [2,2,4], [4,2,4], [4,2,4]])
+        assert numpy.allclose(quantity.centroid_values,
+                              [4.0/3, 8.0/3, 10.0/3, 10.0/3])
+        assert numpy.allclose(quantity.edge_values,
+                              [[1,2,1], [3,3,2], [3,4,3], [3,4,3]])
+
+
+        quantity.set_values(f, location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values,
+                              [4.0/3, 8.0/3, 10.0/3, 10.0/3])
+
+
+    def test_integral(self):
+        quantity = Quantity(self.mesh4)
+
+        #Try constants first
+        const = 5
+        quantity.set_values(const, location = 'vertices')
+        #print 'Q', quantity.get_integral()
+
+        assert numpy.allclose(quantity.get_integral(), self.mesh4.get_area() * const)
+
+        #Try with a linear function
+        def f(x, y):
+            return x+y
+
+        quantity.set_values(f, location = 'vertices')
+
+
+        ref_integral = (4.0/3 + 8.0/3 + 10.0/3 + 10.0/3) * 2
+
+        assert numpy.allclose (quantity.get_integral(), ref_integral)
+
+
+
+    def test_set_vertex_values(self):
+        quantity = Quantity(self.mesh4)
+        quantity.set_vertex_values([0,1,2,3,4,5])
+
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+        assert numpy.allclose(quantity.centroid_values,
+                              [1., 7./3, 11./3, 8./3]) #Centroid
+        assert numpy.allclose(quantity.edge_values, [[1., 1.5, 0.5],
+                                                     [3., 2.5, 1.5],
+                                                     [3.5, 4.5, 3.],
+                                                     [2.5, 3.5, 2]])
+
+
+    def test_set_vertex_values_subset(self):
+        quantity = Quantity(self.mesh4)
+        quantity.set_vertex_values([0,1,2,3,4,5])
+        quantity.set_vertex_values([0,20,30,50], indices = [0,2,3,5])
+
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,0,20], [1,20,4], [4,20,50], [30,1,4]])
+
+
+    def test_set_vertex_values_using_general_interface(self):
+        quantity = Quantity(self.mesh4)
+
+
+        quantity.set_values([0,1,2,3,4,5])
+
+
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+
+        #Centroid
+        assert numpy.allclose(quantity.centroid_values, [1., 7./3, 11./3, 8./3])
+
+        assert numpy.allclose(quantity.edge_values, [[1., 1.5, 0.5],
+                                                     [3., 2.5, 1.5],
+                                                     [3.5, 4.5, 3.],
+                                                     [2.5, 3.5, 2]])
+
+
+
+    def test_set_vertex_values_using_general_interface_with_subset(self):
+        """test_set_vertex_values_using_general_interface_with_subset(self):
+        
+        Test that indices and polygon works (for constants values)
+        """
+        
+        quantity = Quantity(self.mesh4)
+
+
+        quantity.set_values([0,2,3,5], indices=[0,2,3,5])
+        assert numpy.allclose(quantity.vertex_values,
+                              [[0,0,2], [0,2,0], [0,2,5], [3,0,0]])
+
+
+        # Constant
+        quantity.set_values(0.0)
+        quantity.set_values(3.14, indices=[0,2], location='vertices')
+
+        # Indices refer to triangle numbers
+        assert numpy.allclose(quantity.vertex_values,
+                              [[3.14,3.14,3.14], [0,0,0],
+                               [3.14,3.14,3.14], [0,0,0]])        
+        
+
+
+        # Now try with polygon (pick points where y>2)
+        polygon = [[0,2.1], [4,2.1], [4,7], [0,7]]
+        quantity.set_values(0.0)
+        quantity.set_values(3.14, polygon=polygon)
+        
+        assert numpy.allclose(quantity.vertex_values,
+                              [[0,0,0], [0,0,0], [0,0,0],
+                               [3.14,3.14,3.14]])                
+
+
+        # Another polygon (pick triangle 1 and 2 (rightmost triangles) 
+        # using centroids
+        polygon = [[2.1, 0.0], [3.5,0.1], [2,2.2], [0.2,2]]
+        quantity.set_values(0.0)
+        quantity.set_values(3.14, location='centroids', polygon=polygon)
+        assert numpy.allclose(quantity.vertex_values,
+                              [[0,0,0],
+                               [3.14,3.14,3.14],
+                               [3.14,3.14,3.14],                         
+                               [0,0,0]])                
+
+
+        # Same polygon now use vertices (default)
+        polygon = [[2.1, 0.0], [3.5,0.1], [2,2.2], [0.2,2]]
+        quantity.set_values(0.0)
+        #print 'Here 2'
+        quantity.set_values(3.14, polygon=polygon)
+        assert numpy.allclose(quantity.vertex_values,
+                              [[0,0,0],
+                               [3.14,3.14,3.14],
+                               [3.14,3.14,3.14],                         
+                               [0,0,0]])                
+        
+
+        # Test input checking
+        try:
+            quantity.set_values(3.14, polygon=polygon, indices = [0,2])
+        except:
+            pass
+        else:
+            msg = 'Should have caught this'
+            raise msg
+
+
+
+
+
+    def test_set_vertex_values_using_general_interface_subset_and_geo(self):
+        """test_set_vertex_values_using_general_interface_with_subset(self):
+        Test that indices and polygon works using georeferencing
+        """
+        
+        quantity = Quantity(self.mesh4)
+        G = Geo_reference(56, 10, 100)
+        quantity.domain.geo_reference = G
+
+        #print quantity.domain.get_nodes(absolute=True)
+
+
+        # Constant
+        quantity.set_values(0.0)
+        quantity.set_values(3.14, indices=[0,2], location='vertices')
+
+        # Indices refer to triangle numbers here - not vertices (why?)
+        assert numpy.allclose(quantity.vertex_values,
+                              [[3.14,3.14,3.14], [0,0,0],
+                               [3.14,3.14,3.14], [0,0,0]])        
+        
+
+
+        # Now try with polygon (pick points where y>2)
+        polygon = numpy.array([[0,2.1], [4,2.1], [4,7], [0,7]])
+        polygon += [G.xllcorner, G.yllcorner]
+        
+        quantity.set_values(0.0)
+        quantity.set_values(3.14, polygon=polygon, location='centroids')
+        
+        assert numpy.allclose(quantity.vertex_values,
+                              [[0,0,0], [0,0,0], [0,0,0],
+                               [3.14,3.14,3.14]])                
+
+
+        # Another polygon (pick triangle 1 and 2 (rightmost triangles)
+        polygon = numpy.array([[2.1, 0.0], [3.5,0.1], [2,2.2], [0.2,2]])
+        polygon += [G.xllcorner, G.yllcorner]
+        
+        quantity.set_values(0.0)
+        quantity.set_values(3.14, polygon=polygon)
+
+        assert numpy.allclose(quantity.vertex_values,
+                              [[0,0,0],
+                               [3.14,3.14,3.14],
+                               [3.14,3.14,3.14],                         
+                               [0,0,0]])                
+
+
+
+    def test_set_values_using_fit(self):
+
+
+        quantity = Quantity(self.mesh4)
+
+        #Get (enough) datapoints
+        data_points = [[ 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],
+                       [ 1.0, 2.0],
+                       [ 1.0, 3.0],
+                       [ 2.0, 1.0],
+                       [ 3.0, 0.0],
+                       [ 3.0, 1.0]]
+
+        z = linear_function(data_points)
+
+        #Use built-in fit_interpolate.fit
+        quantity.set_values( Geospatial_data(data_points, z), alpha = 0 )
+        #quantity.set_values(points = data_points, values = z, alpha = 0)
+
+
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+        #print quantity.vertex_values, answer
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        #Now try by setting the same values directly
+        vertex_attributes = fit_to_mesh(data_points,
+                                        quantity.domain.get_nodes(),
+                                        quantity.domain.triangles, #FIXME
+                                        point_attributes=z,
+                                        alpha = 0,
+                                        verbose=False)
+
+        #print vertex_attributes
+        quantity.set_values(vertex_attributes)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+
+
+
+    def test_test_set_values_using_fit_w_geo(self):
+
+
+        #Mesh
+        vertex_coordinates = [[0.76, 0.76],
+                              [0.76, 5.76],
+                              [5.76, 0.76]]
+        triangles = [[0,2,1]]
+
+        mesh_georef = Geo_reference(56,-0.76,-0.76)
+        mesh1 = Domain(vertex_coordinates, triangles,
+                       geo_reference = mesh_georef)
+        mesh1.check_integrity()
+
+        #Quantity
+        quantity = Quantity(mesh1)
+
+        #Data
+        data_points = [[ 201.0, 401.0],
+                       [ 201.0, 403.0],
+                       [ 203.0, 401.0]]
+
+        z = [2, 4, 4]
+
+        data_georef = Geo_reference(56,-200,-400)
+
+
+        #Reference
+        ref = fit_to_mesh(data_points, vertex_coordinates, triangles,
+                          point_attributes=z,
+                          data_origin = data_georef.get_origin(),
+                          mesh_origin = mesh_georef.get_origin(),
+                          alpha = 0)
+
+        assert numpy.allclose( ref, [0,5,5] )
+
+
+        #Test set_values
+
+        quantity.set_values( Geospatial_data(data_points, z, data_georef), alpha = 0 )
+
+        #quantity.set_values(points = data_points,
+        #                    values = z,
+        #                    data_georef = data_georef,
+        #                    alpha = 0)
+
+
+        #quantity.set_values(points = data_points,
+        #                    values = z,
+        #                    data_georef = data_georef,
+        #                    alpha = 0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), ref)
+
+
+
+        #Test set_values using geospatial data object
+        quantity.vertex_values[:] = 0.0
+
+        geo = Geospatial_data(data_points, z, data_georef)
+
+
+        quantity.set_values(geospatial_data = geo, alpha = 0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), ref)
+
+
+
+    def test_set_values_from_file1(self):
+        quantity = Quantity(self.mesh4)
+
+        #Get (enough) datapoints
+        data_points = [[ 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],
+                       [ 1.0, 2.0],
+                       [ 1.0, 3.0],
+                       [ 2.0, 1.0],
+                       [ 3.0, 0.0],
+                       [ 3.0, 1.0]]
+
+        data_geo_spatial = Geospatial_data(data_points,
+                         geo_reference = Geo_reference(56, 0, 0))
+        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(data_points_absolute)
+        att = 'spam_and_eggs'
+        
+        #Create .txt file
+        ptsfile = tempfile.mktemp(".txt")
+        file = open(ptsfile,"w")
+        file.write(" x,y," + att + " \n")
+        for data_point, attribute in map(None, data_points_absolute
+                                         ,attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            file.write(row + "\n")
+        file.close()
+
+
+        #Check that values can be set from file
+        quantity.set_values(filename = ptsfile,
+                            attribute_name = att, alpha = 0)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+
+        #print quantity.vertex_values.ravel()
+        #print answer
+
+
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        #Check that values can be set from file using default attribute
+        quantity.set_values(filename = ptsfile, alpha = 0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Cleanup
+        import os
+        os.remove(ptsfile)
+
+
+
+    def Xtest_set_values_from_file_using_polygon(self):
+        """test_set_values_from_file_using_polygon(self):
+        
+        Test that polygon restriction works for general points data
+        """
+        
+        quantity = Quantity(self.mesh4)
+
+        #Get (enough) datapoints
+        data_points = [[ 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],
+                       [ 1.0, 2.0],
+                       [ 1.0, 3.0],
+                       [ 2.0, 1.0],
+                       [ 3.0, 0.0],
+                       [ 3.0, 1.0]]
+
+        data_geo_spatial = Geospatial_data(data_points,
+                         geo_reference = Geo_reference(56, 0, 0))
+        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(data_points_absolute)
+        att = 'spam_and_eggs'
+        
+        #Create .txt file
+        ptsfile = tempfile.mktemp(".txt")
+        file = open(ptsfile,"w")
+        file.write(" x,y," + att + " \n")
+        for data_point, attribute in map(None, data_points_absolute
+                                         ,attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            file.write(row + "\n")
+        file.close()
+
+        # Create restricting polygon (containing node #4 (2,2) and 
+        # centroid of triangle #1 (bce)
+        polygon = [[1.0, 1.0], [4.0, 1.0],
+                   [4.0, 4.0], [1.0, 4.0]]
+
+        #print self.mesh4.nodes
+        #print inside_polygon(self.mesh4.nodes, polygon)
+        assert numpy.allclose(inside_polygon(self.mesh4.nodes, polygon), 4)
+
+        #print quantity.domain.get_vertex_coordinates()
+        #print quantity.domain.get_nodes()        
+        
+        # Check that values can be set from file
+        quantity.set_values(filename=ptsfile,
+                            polygon=polygon,
+                            location='unique vertices',
+                            alpha=0)
+
+        # Get indices for vertex coordinates in polygon
+        indices = inside_polygon(quantity.domain.get_vertex_coordinates(), 
+                                 polygon)
+        points = take(quantity.domain.get_vertex_coordinates(), indices)
+        
+        answer = linear_function(points)
+
+        #print quantity.vertex_values.ravel()
+        #print answer
+
+        # Check vertices in polygon have been set
+        assert numpy.allclose(take(quantity.vertex_values.ravel(), indices),
+                                   answer)
+
+        # Check vertices outside polygon are zero
+        indices = outside_polygon(quantity.domain.get_vertex_coordinates(), 
+                                  polygon)        
+        assert numpy.allclose(take(quantity.vertex_values.ravel(), indices),
+                                   0.0)        
+
+        #Cleanup
+        import os
+        os.remove(ptsfile)
+
+
+        
+
+    def test_cache_test_set_values_from_file(self):
+        # FIXME (Ole): What is this about?
+        # I don't think it checks anything new
+        quantity = Quantity(self.mesh4)
+
+        #Get (enough) datapoints
+        data_points = [[ 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],
+                       [ 1.0, 2.0],
+                       [ 1.0, 3.0],
+                       [ 2.0, 1.0],
+                       [ 3.0, 0.0],
+                       [ 3.0, 1.0]]
+
+        georef = Geo_reference(56, 0, 0)
+        data_geo_spatial = Geospatial_data(data_points,
+                                           geo_reference=georef)
+                                           
+        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(data_points_absolute)
+        att = 'spam_and_eggs'
+        
+        # Create .txt file
+        ptsfile = tempfile.mktemp(".txt")
+        file = open(ptsfile,"w")
+        file.write(" x,y," + att + " \n")
+        for data_point, attribute in map(None, data_points_absolute
+                                         ,attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            file.write(row + "\n")
+        file.close()
+
+
+        # Check that values can be set from file
+        quantity.set_values(filename=ptsfile,
+                            attribute_name=att, 
+                            alpha=0, 
+                            use_cache=True,
+                            verbose=False)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        # Check that values can be set from file using default attribute
+        quantity.set_values(filename=ptsfile, 
+                            alpha=0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        # Check cache
+        quantity.set_values(filename=ptsfile,
+                            attribute_name=att, 
+                            alpha=0, 
+                            use_cache=True,
+                            verbose=False)
+        
+        
+        #Cleanup
+        import os
+        os.remove(ptsfile)
+
+    def test_set_values_from_lat_long(self):
+        quantity = Quantity(self.mesh_onslow)
+
+        #Get (enough) datapoints
+        data_points = [[-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6]]
+
+        data_geo_spatial = Geospatial_data(data_points,
+                                           points_are_lats_longs=True)
+        points_UTM = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(points_UTM)
+        att = 'elevation'
+        
+        #Create .txt file
+        txt_file = tempfile.mktemp(".txt")
+        file = open(txt_file,"w")
+        file.write(" lat,long," + att + " \n")
+        for data_point, attribute in map(None, data_points, attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            #print "row", row 
+            file.write(row + "\n")
+        file.close()
+
+
+        #Check that values can be set from file
+        quantity.set_values(filename=txt_file,
+                            attribute_name=att, 
+                            alpha=0)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+
+        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
+        #print "answer",answer
+
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        #Check that values can be set from file using default attribute
+        quantity.set_values(filename=txt_file, alpha=0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Cleanup
+        import os
+        os.remove(txt_file)
+         
+    def test_set_values_from_lat_long(self):
+        quantity = Quantity(self.mesh_onslow)
+
+        #Get (enough) datapoints
+        data_points = [[-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6]]
+
+        data_geo_spatial = Geospatial_data(data_points,
+                                           points_are_lats_longs=True)
+        points_UTM = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(points_UTM)
+        att = 'elevation'
+        
+        #Create .txt file
+        txt_file = tempfile.mktemp(".txt")
+        file = open(txt_file,"w")
+        file.write(" lat,long," + att + " \n")
+        for data_point, attribute in map(None, data_points, attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            #print "row", row 
+            file.write(row + "\n")
+        file.close()
+
+
+        #Check that values can be set from file
+        quantity.set_values(filename=txt_file,
+                            attribute_name=att, alpha=0)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+
+        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
+        #print "answer",answer
+
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        #Check that values can be set from file using default attribute
+        quantity.set_values(filename=txt_file, alpha=0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Cleanup
+        import os
+        os.remove(txt_file)
+        
+    def test_set_values_from_UTM_pts(self):
+        quantity = Quantity(self.mesh_onslow)
+
+        #Get (enough) datapoints
+        data_points = [[-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6]]
+
+        data_geo_spatial = Geospatial_data(data_points,
+                                           points_are_lats_longs=True)
+        points_UTM = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(points_UTM)
+        att = 'elevation'
+        
+        #Create .txt file
+        txt_file = tempfile.mktemp(".txt")
+        file = open(txt_file,"w")
+        file.write(" x,y," + att + " \n")
+        for data_point, attribute in map(None, points_UTM, attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            #print "row", row 
+            file.write(row + "\n")
+        file.close()
+
+
+        pts_file = tempfile.mktemp(".pts")        
+        convert = Geospatial_data(txt_file)
+        convert.export_points_file(pts_file)
+
+        #Check that values can be set from file
+        quantity.set_values_from_file(pts_file, att, 0,
+                                      'vertices', None)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
+        #print "answer",answer
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Check that values can be set from file
+        quantity.set_values(filename=pts_file,
+                            attribute_name=att, alpha=0)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
+        #print "answer",answer
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        #Check that values can be set from file using default attribute
+        quantity.set_values(filename=txt_file, alpha=0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Cleanup
+        import os
+        os.remove(txt_file)
+        os.remove(pts_file)
+        
+    def verbose_test_set_values_from_UTM_pts(self):
+        quantity = Quantity(self.mesh_onslow)
+
+        #Get (enough) datapoints
+        data_points = [[-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       [-21.5, 114.5],[-21.4, 114.6],[-21.45,114.65],
+                       [-21.35, 114.65],[-21.45, 114.55],[-21.45,114.6],
+                       ]
+
+        data_geo_spatial = Geospatial_data(data_points,
+                                           points_are_lats_longs=True)
+        points_UTM = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(points_UTM)
+        att = 'elevation'
+        
+        #Create .txt file
+        txt_file = tempfile.mktemp(".txt")
+        file = open(txt_file,"w")
+        file.write(" x,y," + att + " \n")
+        for data_point, attribute in map(None, points_UTM, attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            #print "row", row 
+            file.write(row + "\n")
+        file.close()
+
+
+        pts_file = tempfile.mktemp(".pts")        
+        convert = Geospatial_data(txt_file)
+        convert.export_points_file(pts_file)
+
+        #Check that values can be set from file
+        quantity.set_values_from_file(pts_file, att, 0,
+                                      'vertices', None, verbose = True,
+                                      max_read_lines=2)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
+        #print "answer",answer
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Check that values can be set from file
+        quantity.set_values(filename=pts_file,
+                            attribute_name=att, alpha=0)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+        #print "quantity.vertex_values.ravel()", quantity.vertex_values.ravel()
+        #print "answer",answer
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        #Check that values can be set from file using default attribute
+        quantity.set_values(filename=txt_file, alpha=0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Cleanup
+        import os
+        os.remove(txt_file)
+        os.remove(pts_file)
+        
+    def test_set_values_from_file_with_georef1(self):
+
+        #Mesh in zone 56 (absolute coords)
+
+        x0 = 314036.58727982
+        y0 = 6224951.2960092
+
+        a = [x0+0.0, y0+0.0]
+        b = [x0+0.0, y0+2.0]
+        c = [x0+2.0, y0+0.0]
+        d = [x0+0.0, y0+4.0]
+        e = [x0+2.0, y0+2.0]
+        f = [x0+4.0, y0+0.0]
+
+        points = [a, b, c, d, e, f]
+
+        #bac, bce, ecf, dbe
+        elements = [ [1,0,2], [1,2,4], [4,2,5], [3,1,4] ]
+
+        #absolute going in ..
+        mesh4 = Domain(points, elements,
+                       geo_reference = Geo_reference(56, 0, 0))
+        mesh4.check_integrity()
+        quantity = Quantity(mesh4)
+
+        #Get (enough) datapoints (relative to georef)
+        data_points_rel = [[ 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],
+                       [ 1.0, 2.0],
+                       [ 1.0, 3.0],
+                       [ 2.0, 1.0],
+                       [ 3.0, 0.0],
+                       [ 3.0, 1.0]]
+
+        data_geo_spatial = Geospatial_data(data_points_rel,
+                         geo_reference = Geo_reference(56, x0, y0))
+        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(data_points_absolute)
+        att = 'spam_and_eggs'
+        
+        #Create .txt file
+        ptsfile = tempfile.mktemp(".txt")
+        file = open(ptsfile,"w")
+        file.write(" x,y," + att + " \n")
+        for data_point, attribute in map(None, data_points_absolute
+                                         ,attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            file.write(row + "\n")
+        file.close()
+
+        #file = open(ptsfile, 'r')
+        #lines = file.readlines()
+        #file.close()
+     
+
+        #Check that values can be set from file
+        quantity.set_values(filename=ptsfile,
+                            attribute_name=att, alpha=0)
+        answer = linear_function(quantity.domain.get_vertex_coordinates())
+
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        #Check that values can be set from file using default attribute
+        quantity.set_values(filename=ptsfile, alpha=0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Cleanup
+        import os
+        os.remove(ptsfile)
+
+
+    def test_set_values_from_file_with_georef2(self):
+
+        #Mesh in zone 56 (relative coords)
+
+        x0 = 314036.58727982
+        y0 = 6224951.2960092
+        #x0 = 0.0
+        #y0 = 0.0
+
+        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
+        elements = [ [1,0,2], [1,2,4], [4,2,5], [3,1,4] ]
+
+        mesh4 = Domain(points, elements,
+                       geo_reference = Geo_reference(56, x0, y0))
+        mesh4.check_integrity()
+        quantity = Quantity(mesh4)
+
+        #Get (enough) datapoints
+        data_points = [[ x0+0.66666667, y0+0.66666667],
+                       [ x0+1.33333333, y0+1.33333333],
+                       [ x0+2.66666667, y0+0.66666667],
+                       [ x0+0.66666667, y0+2.66666667],
+                       [ x0+0.0, y0+1.0],
+                       [ x0+0.0, y0+3.0],
+                       [ x0+1.0, y0+0.0],
+                       [ x0+1.0, y0+1.0],
+                       [ x0+1.0, y0+2.0],
+                       [ x0+1.0, y0+3.0],
+                       [ x0+2.0, y0+1.0],
+                       [ x0+3.0, y0+0.0],
+                       [ x0+3.0, y0+1.0]]
+
+
+        data_geo_spatial = Geospatial_data(data_points,
+                         geo_reference = Geo_reference(56, 0, 0))
+        data_points_absolute = data_geo_spatial.get_data_points(absolute=True)
+        attributes = linear_function(data_points_absolute)
+        att = 'spam_and_eggs'
+        
+        #Create .txt file
+        ptsfile = tempfile.mktemp(".txt")
+        file = open(ptsfile,"w")
+        file.write(" x,y," + att + " \n")
+        for data_point, attribute in map(None, data_points_absolute
+                                         ,attributes):
+            row = str(data_point[0]) + ',' + str(data_point[1]) \
+                  + ',' + str(attribute)
+            file.write(row + "\n")
+        file.close()
+
+
+        #Check that values can be set from file
+        quantity.set_values(filename=ptsfile,
+                            attribute_name=att, alpha=0)
+        answer = linear_function(quantity.domain. \
+                                 get_vertex_coordinates(absolute=True))
+
+
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+
+        #Check that values can be set from file using default attribute
+        quantity.set_values(filename=ptsfile, alpha=0)
+        assert numpy.allclose(quantity.vertex_values.ravel(), answer)
+
+        #Cleanup
+        import os
+        os.remove(ptsfile)
+
+
+
+
+    def test_set_values_from_quantity(self):
+
+        quantity1 = Quantity(self.mesh4)
+        quantity1.set_vertex_values([0,1,2,3,4,5])
+
+        assert numpy.allclose(quantity1.vertex_values,
+                              [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+
+
+        quantity2 = Quantity(self.mesh4)
+        quantity2.set_values(quantity=quantity1)
+        assert numpy.allclose(quantity2.vertex_values,
+                              [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+
+        quantity2.set_values(quantity = 2*quantity1)
+        assert numpy.allclose(quantity2.vertex_values,
+                              [[2,0,4], [2,4,8], [8,4,10], [6,2,8]])
+
+        quantity2.set_values(quantity = 2*quantity1 + 3)
+        assert numpy.allclose(quantity2.vertex_values,
+                              [[5,3,7], [5,7,11], [11,7,13], [9,5,11]])
+
+
+        #Check detection of quantity as first orgument
+        quantity2.set_values(2*quantity1 + 3)
+        assert numpy.allclose(quantity2.vertex_values,
+                              [[5,3,7], [5,7,11], [11,7,13], [9,5,11]])
+
+
+
+    def Xtest_set_values_from_quantity_using_polygon(self):
+        """test_set_values_from_quantity_using_polygon(self):
+        
+        Check that polygon can be used to restrict set_values when
+        using another quantity as argument.
+        """
+        
+        # Create restricting polygon (containing node #4 (2,2) and 
+        # centroid of triangle #1 (bce)
+        polygon = [[1.0, 1.0], [4.0, 1.0],
+                   [4.0, 4.0], [1.0, 4.0]]
+        assert numpy.allclose(inside_polygon(self.mesh4.nodes, polygon), 4)                   
+        
+        quantity1 = Quantity(self.mesh4)
+        quantity1.set_vertex_values([0,1,2,3,4,5])
+
+        assert numpy.allclose(quantity1.vertex_values,
+                              [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+
+
+        quantity2 = Quantity(self.mesh4)
+        quantity2.set_values(quantity=quantity1,
+                             polygon=polygon)
+                             
+        msg = 'Only node #4(e) at (2,2) should have values applied '
+        assert numpy.allclose(quantity2.vertex_values,
+                              [[0,0,0], [0,0,4], [4,0,0], [0,0,4]]), msg        
+                              #bac,     bce,     ecf,     dbe
+                        
+
+
+    def test_overloading(self):
+
+        quantity1 = Quantity(self.mesh4)
+        quantity1.set_vertex_values([0,1,2,3,4,5])
+
+        assert numpy.allclose(quantity1.vertex_values,
+                              [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+
+
+        quantity2 = Quantity(self.mesh4)
+        quantity2.set_values([[1,2,3], [5,5,5], [0,0,9], [-6, 3, 3]],
+                             location = 'vertices')
+
+
+
+        quantity3 = Quantity(self.mesh4)
+        quantity3.set_values([[2,2,2], [7,8,9], [7,6,3], [3, 8, -8]],
+                             location = 'vertices')
+
+
+        # Negation
+        Q = -quantity1
+        assert numpy.allclose(Q.vertex_values, -quantity1.vertex_values)
+        assert numpy.allclose(Q.centroid_values, -quantity1.centroid_values)
+        assert numpy.allclose(Q.edge_values, -quantity1.edge_values)
+
+        # Addition
+        Q = quantity1 + 7
+        assert numpy.allclose(Q.vertex_values, quantity1.vertex_values + 7)
+        assert numpy.allclose(Q.centroid_values, quantity1.centroid_values + 7)
+        assert numpy.allclose(Q.edge_values, quantity1.edge_values + 7)
+
+        Q = 7 + quantity1
+        assert numpy.allclose(Q.vertex_values, quantity1.vertex_values + 7)
+        assert numpy.allclose(Q.centroid_values, quantity1.centroid_values + 7)
+        assert numpy.allclose(Q.edge_values, quantity1.edge_values + 7)
+
+        Q = quantity1 + quantity2
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values + quantity2.vertex_values)
+        assert numpy.allclose(Q.centroid_values,
+                              quantity1.centroid_values + quantity2.centroid_values)
+        assert numpy.allclose(Q.edge_values,
+                              quantity1.edge_values + quantity2.edge_values)
+
+
+        Q = quantity1 + quantity2 - 3
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values + quantity2.vertex_values - 3)
+
+        Q = quantity1 - quantity2
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values - quantity2.vertex_values)
+
+        #Scaling
+        Q = quantity1*3
+        assert numpy.allclose(Q.vertex_values, quantity1.vertex_values*3)
+        assert numpy.allclose(Q.centroid_values, quantity1.centroid_values*3)
+        assert numpy.allclose(Q.edge_values, quantity1.edge_values*3)
+        Q = 3*quantity1
+        assert numpy.allclose(Q.vertex_values, quantity1.vertex_values*3)
+
+        #Multiplication
+        Q = quantity1 * quantity2
+        #print Q.vertex_values
+        #print Q.centroid_values
+        #print quantity1.centroid_values
+        #print quantity2.centroid_values
+
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values * quantity2.vertex_values)
+
+        #Linear combinations
+        Q = 4*quantity1 + 2
+        assert numpy.allclose(Q.vertex_values,
+                              4*quantity1.vertex_values + 2)
+
+        Q = quantity1*quantity2 + 2
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values * quantity2.vertex_values + 2)
+
+        Q = quantity1*quantity2 + quantity3
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values * quantity2.vertex_values +
+                              quantity3.vertex_values)
+        Q = quantity1*quantity2 + 3*quantity3
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values * quantity2.vertex_values +
+                             3*quantity3.vertex_values)
+        Q = quantity1*quantity2 + 3*quantity3 + 5.0
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values * quantity2.vertex_values +
+                              3*quantity3.vertex_values + 5)
+
+        Q = quantity1*quantity2 - quantity3
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values * quantity2.vertex_values -
+                              quantity3.vertex_values)
+        Q = 1.5*quantity1*quantity2 - 3*quantity3 + 5.0
+        assert numpy.allclose(Q.vertex_values,
+                              1.5*quantity1.vertex_values * quantity2.vertex_values -
+                              3*quantity3.vertex_values + 5)
+
+        #Try combining quantities and arrays and scalars
+        Q = 1.5*quantity1*quantity2.vertex_values - \
+            3*quantity3.vertex_values + 5.0
+        assert numpy.allclose(Q.vertex_values,
+                              1.5*quantity1.vertex_values * quantity2.vertex_values -
+                              3*quantity3.vertex_values + 5)
+
+
+        #Powers
+        Q = quantity1**2
+        assert numpy.allclose(Q.vertex_values, quantity1.vertex_values**2)
+
+        Q = quantity1**2 +quantity2**2
+        assert numpy.allclose(Q.vertex_values,
+                              quantity1.vertex_values**2 +
+                              quantity2.vertex_values**2)
+
+        Q = (quantity1**2 +quantity2**2)**0.5
+        assert numpy.allclose(Q.vertex_values,
+                              (quantity1.vertex_values**2 + 
+                               quantity2.vertex_values**2)**0.5)
+
+
+
+
+
+
+
+    def test_compute_gradient(self):
+        quantity = Quantity(self.mesh4)
+
+        #Set up for a gradient of (2,0) at mid triangle
+        quantity.set_values([2.0, 4.0, 6.0, 2.0],
+                            location = 'centroids')
+
+
+        #Gradients
+        quantity.compute_gradients()
+
+        a = quantity.x_gradient
+        b = quantity.y_gradient
+        #print self.mesh4.centroid_coordinates
+        #print a, b
+
+        #The central triangle (1)
+        #(using standard gradient based on neigbours controid values)
+        assert numpy.allclose(a[1], 2.0)
+        assert numpy.allclose(b[1], 0.0)
+
+
+        #Left triangle (0) using two point gradient
+        #q0 = q1 + a*(x0-x1) + b*(y0-y1)  <=>
+        #2  = 4  + a*(-2/3)  + b*(-2/3)
+        assert numpy.allclose(a[0] + b[0], 3)
+        #From orthogonality (a*(y0-y1) + b*(x0-x1) == 0)
+        assert numpy.allclose(a[0] - b[0], 0)
+
+
+        #Right triangle (2) using two point gradient
+        #q2 = q1 + a*(x2-x1) + b*(y2-y1)  <=>
+        #6  = 4  + a*(4/3)  + b*(-2/3)
+        assert numpy.allclose(2*a[2] - b[2], 3)
+        #From orthogonality (a*(y1-y2) + b*(x2-x1) == 0)
+        assert numpy.allclose(a[2] + 2*b[2], 0)
+
+
+        #Top triangle (3) using two point gradient
+        #q3 = q1 + a*(x3-x1) + b*(y3-y1)  <=>
+        #2  = 4  + a*(-2/3)  + b*(4/3)
+        assert numpy.allclose(a[3] - 2*b[3], 3)
+        #From orthogonality (a*(y1-y3) + b*(x3-x1) == 0)
+        assert numpy.allclose(2*a[3] + b[3], 0)
+
+
+
+        #print a, b
+        quantity.extrapolate_second_order()
+
+        #Apply q(x,y) = qc + a*(x-xc) + b*(y-yc)
+        assert numpy.allclose(quantity.vertex_values[0,:], [3., 0.,  3.])
+        assert numpy.allclose(quantity.vertex_values[1,:], [4./3, 16./3,  16./3])
+
+
+        #a = 1.2, b=-0.6
+        #q(4,0) = 6 + a*(4 - 8/3) + b*(-2/3)
+        assert numpy.allclose(quantity.vertex_values[2,2], 8)
+
+    def test_get_gradients(self):
+        quantity = Quantity(self.mesh4)
+
+        #Set up for a gradient of (2,0) at mid triangle
+        quantity.set_values([2.0, 4.0, 6.0, 2.0],
+                            location = 'centroids')
+
+
+        #Gradients
+        quantity.compute_gradients()
+
+        a, b = quantity.get_gradients()
+        #print self.mesh4.centroid_coordinates
+        #print a, b
+
+        #The central triangle (1)
+        #(using standard gradient based on neigbours controid values)
+        assert numpy.allclose(a[1], 2.0)
+        assert numpy.allclose(b[1], 0.0)
+
+
+        #Left triangle (0) using two point gradient
+        #q0 = q1 + a*(x0-x1) + b*(y0-y1)  <=>
+        #2  = 4  + a*(-2/3)  + b*(-2/3)
+        assert numpy.allclose(a[0] + b[0], 3)
+        #From orthogonality (a*(y0-y1) + b*(x0-x1) == 0)
+        assert numpy.allclose(a[0] - b[0], 0)
+
+
+        #Right triangle (2) using two point gradient
+        #q2 = q1 + a*(x2-x1) + b*(y2-y1)  <=>
+        #6  = 4  + a*(4/3)  + b*(-2/3)
+        assert numpy.allclose(2*a[2] - b[2], 3)
+        #From orthogonality (a*(y1-y2) + b*(x2-x1) == 0)
+        assert numpy.allclose(a[2] + 2*b[2], 0)
+
+
+        #Top triangle (3) using two point gradient
+        #q3 = q1 + a*(x3-x1) + b*(y3-y1)  <=>
+        #2  = 4  + a*(-2/3)  + b*(4/3)
+        assert numpy.allclose(a[3] - 2*b[3], 3)
+        #From orthogonality (a*(y1-y3) + b*(x3-x1) == 0)
+        assert numpy.allclose(2*a[3] + b[3], 0)
+
+
+    def test_second_order_extrapolation2(self):
+        quantity = Quantity(self.mesh4)
+
+        #Set up for a gradient of (3,1), f(x) = 3x+y
+        quantity.set_values([2.0+2.0/3, 4.0+4.0/3, 8.0+2.0/3, 2.0+8.0/3],
+                            location = 'centroids')
+
+        #Gradients
+        quantity.compute_gradients()
+
+        a = quantity.x_gradient
+        b = quantity.y_gradient
+        
+        #print a, b
+
+        assert numpy.allclose(a[1], 3.0)
+        assert numpy.allclose(b[1], 1.0)
+
+        #Work out the others
+
+        quantity.extrapolate_second_order()
+
+        #print quantity.vertex_values
+        assert numpy.allclose(quantity.vertex_values[1,0], 2.0)
+        assert numpy.allclose(quantity.vertex_values[1,1], 6.0)
+        assert numpy.allclose(quantity.vertex_values[1,2], 8.0)
+
+
+
+    def test_backup_saxpy_centroid_values(self):
+        quantity = Quantity(self.mesh4)
+
+        #Set up for a gradient of (3,1), f(x) = 3x+y
+        c_values = numpy.array([2.0+2.0/3, 4.0+4.0/3, 8.0+2.0/3, 2.0+8.0/3])
+        d_values = numpy.array([1.0, 2.0, 3.0, 4.0])
+        quantity.set_values(c_values, location = 'centroids')
+
+        #Backup
+        quantity.backup_centroid_values()
+
+        #print quantity.vertex_values
+        assert numpy.allclose(quantity.centroid_values, quantity.centroid_backup_values)
+
+
+        quantity.set_values(d_values, location = 'centroids')
+
+        quantity.saxpy_centroid_values(2.0, 3.0)
+
+        assert(quantity.centroid_values, 2.0*d_values + 3.0*c_values)
+
+
+
+    def test_first_order_extrapolator(self):
+        quantity = Quantity(self.mesh4)
+
+        #Test centroids
+        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
+
+        #Extrapolate
+        quantity.extrapolate_first_order()
+
+        #Check that gradient is zero
+        a,b = quantity.get_gradients()
+        assert numpy.allclose(a, [0,0,0,0])
+        assert numpy.allclose(b, [0,0,0,0])
+
+        #Check vertices but not edge values
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
+
+
+    def test_second_order_extrapolator(self):
+        quantity = Quantity(self.mesh4)
+
+        #Set up for a gradient of (3,0) at mid triangle
+        quantity.set_values([2.0, 4.0, 8.0, 2.0],
+                            location = 'centroids')
+
+
+
+        quantity.extrapolate_second_order()
+        quantity.limit()
+
+
+        #Assert that central triangle is limited by neighbours
+        assert quantity.vertex_values[1,0] >= quantity.vertex_values[0,0]
+        assert quantity.vertex_values[1,0] >= quantity.vertex_values[3,1]
+
+        assert quantity.vertex_values[1,1] <= quantity.vertex_values[2,1]
+        assert quantity.vertex_values[1,1] >= quantity.vertex_values[0,2]
+
+        assert quantity.vertex_values[1,2] <= quantity.vertex_values[2,0]
+        assert quantity.vertex_values[1,2] >= quantity.vertex_values[3,1]
+
+
+        #Assert that quantities are conserved
+        for k in range(quantity.centroid_values.shape[0]):
+            assert numpy.allclose (quantity.centroid_values[k],
+                                   numpy.sum(quantity.vertex_values[k,:])/3)
+
+
+
+
+
+    def test_limit_vertices_by_all_neighbours(self):
+        quantity = Quantity(self.mesh4)
+
+        #Create a deliberate overshoot (e.g. from gradient computation)
+        quantity.set_values([[3,0,3], [2,2,6], [5,3,8], [8,3,5]])
+
+
+        #Limit
+        quantity.limit_vertices_by_all_neighbours()
+
+        #Assert that central triangle is limited by neighbours
+        assert quantity.vertex_values[1,0] >= quantity.vertex_values[0,0]
+        assert quantity.vertex_values[1,0] <= quantity.vertex_values[3,1]
+
+        assert quantity.vertex_values[1,1] <= quantity.vertex_values[2,1]
+        assert quantity.vertex_values[1,1] >= quantity.vertex_values[0,2]
+
+        assert quantity.vertex_values[1,2] <= quantity.vertex_values[2,0]
+        assert quantity.vertex_values[1,2] <= quantity.vertex_values[3,1]
+
+
+
+        #Assert that quantities are conserved
+        for k in range(quantity.centroid_values.shape[0]):
+            assert numpy.allclose (quantity.centroid_values[k],
+                                   numpy.sum(quantity.vertex_values[k,:])/3)
+
+
+
+    def test_limit_edges_by_all_neighbours(self):
+        quantity = Quantity(self.mesh4)
+
+        #Create a deliberate overshoot (e.g. from gradient computation)
+        quantity.set_values([[3,0,3], [2,2,6], [5,3,8], [8,3,5]])
+
+
+        #Limit
+        quantity.limit_edges_by_all_neighbours()
+
+        #Assert that central triangle is limited by neighbours
+        assert quantity.edge_values[1,0] <= quantity.centroid_values[2]
+        assert quantity.edge_values[1,0] >= quantity.centroid_values[0]
+
+        assert quantity.edge_values[1,1] <= quantity.centroid_values[2]
+        assert quantity.edge_values[1,1] >= quantity.centroid_values[0]
+
+        assert quantity.edge_values[1,2] <= quantity.centroid_values[2]
+        assert quantity.edge_values[1,2] >= quantity.centroid_values[0]
+
+
+
+        #Assert that quantities are conserved
+        for k in range(quantity.centroid_values.shape[0]):
+            assert numpy.allclose (quantity.centroid_values[k],
+                                   numpy.sum(quantity.vertex_values[k,:])/3)
+
+
+    def test_limit_edges_by_neighbour(self):
+        quantity = Quantity(self.mesh4)
+
+        #Create a deliberate overshoot (e.g. from gradient computation)
+        quantity.set_values([[3,0,3], [2,2,6], [5,3,8], [8,3,5]])
+
+
+        #Limit
+        quantity.limit_edges_by_neighbour()
+
+        #Assert that central triangle is limited by neighbours
+        assert quantity.edge_values[1,0] <= quantity.centroid_values[3]
+        assert quantity.edge_values[1,0] >= quantity.centroid_values[1]
+
+        assert quantity.edge_values[1,1] <= quantity.centroid_values[2]
+        assert quantity.edge_values[1,1] >= quantity.centroid_values[1]
+
+        assert quantity.edge_values[1,2] <= quantity.centroid_values[1]
+        assert quantity.edge_values[1,2] >= quantity.centroid_values[0]
+
+
+
+        #Assert that quantities are conserved
+        for k in range(quantity.centroid_values.shape[0]):
+            assert numpy.allclose (quantity.centroid_values[k],
+                                   numpy.sum(quantity.vertex_values[k,:])/3)
+
+    def test_limiter2(self):
+        """Taken from test_shallow_water
+        """
+        quantity = Quantity(self.mesh4)
+        quantity.domain.beta_w = 0.9
+        
+        #Test centroids
+        quantity.set_values([2.,4.,8.,2.], location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
+
+
+        #Extrapolate
+        quantity.extrapolate_second_order()
+
+        assert numpy.allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
+
+        #Limit
+        quantity.limit()
+
+        # limited value for beta_w = 0.9
+        
+        assert numpy.allclose(quantity.vertex_values[1,:], [2.2, 4.9, 4.9])
+        # limited values for beta_w = 0.5
+        #assert numpy.allclose(quantity.vertex_values[1,:], [3.0, 4.5, 4.5])
+
+
+        #Assert that quantities are conserved
+        for k in range(quantity.centroid_values.shape[0]):
+            assert numpy.allclose (quantity.centroid_values[k],
+                                   numpy.sum(quantity.vertex_values[k,:])/3)
+
+
+
+
+
+    def test_distribute_first_order(self):
+        quantity = Quantity(self.mesh4)
+
+        #Test centroids
+        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
+
+
+        #Extrapolate from centroid to vertices and edges
+        quantity.extrapolate_first_order()
+
+        #Interpolate
+        #quantity.interpolate_from_vertices_to_edges()
+
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,1,1], [2,2,2], [3,3,3], [4, 4, 4]])
+        assert numpy.allclose(quantity.edge_values, [[1,1,1], [2,2,2],
+                                                     [3,3,3], [4, 4, 4]])
+
+
+    def test_interpolate_from_vertices_to_edges(self):
+        quantity = Quantity(self.mesh4)
+
+        quantity.vertex_values = numpy.array([[1,0,2], [1,2,4], [4,2,5], [3,1,4]], numpy.float)
+
+        quantity.interpolate_from_vertices_to_edges()
+
+        assert numpy.allclose(quantity.edge_values, [[1., 1.5, 0.5],
+                                                     [3., 2.5, 1.5],
+                                                     [3.5, 4.5, 3.],
+                                                     [2.5, 3.5, 2]])
+
+
+    def test_interpolate_from_edges_to_vertices(self):
+        quantity = Quantity(self.mesh4)
+
+        quantity.edge_values = numpy.array([[1., 1.5, 0.5],
+                                            [3., 2.5, 1.5],
+                                            [3.5, 4.5, 3.],
+                                            [2.5, 3.5, 2]], numpy.float)
+
+        quantity.interpolate_from_edges_to_vertices()
+
+        assert numpy.allclose(quantity.vertex_values,
+                              [[1,0,2], [1,2,4], [4,2,5], [3,1,4]])
+
+
+
+    def test_distribute_second_order(self):
+        quantity = Quantity(self.mesh4)
+
+        #Test centroids
+        quantity.set_values([2.,4.,8.,2.], location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [2, 4, 8, 2]) #Centroid
+
+
+        #Extrapolate
+        quantity.extrapolate_second_order()
+
+        assert numpy.allclose(quantity.vertex_values[1,:], [0.0, 6, 6])
+
+
+    def test_update_explicit(self):
+        quantity = Quantity(self.mesh4)
+
+        #Test centroids
+        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
+
+        #Set explicit_update
+        quantity.explicit_update = numpy.array( [1.,1.,1.,1.] )
+
+        #Update with given timestep
+        quantity.update(0.1)
+
+        x = numpy.array([1, 2, 3, 4]) + numpy.array( [.1,.1,.1,.1] )
+        assert numpy.allclose( quantity.centroid_values, x)
+
+    def test_update_semi_implicit(self):
+        quantity = Quantity(self.mesh4)
+
+        #Test centroids
+        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
+
+        #Set semi implicit update
+        quantity.semi_implicit_update = numpy.array([1.,1.,1.,1.])
+
+        #Update with given timestep
+        timestep = 0.1
+        quantity.update(timestep)
+
+        sem = numpy.array([1.,1.,1.,1.])/numpy.array([1, 2, 3, 4])
+        denom = numpy.ones(4, numpy.float)-timestep*sem
+
+        x = numpy.array([1, 2, 3, 4])/denom
+        assert numpy.allclose( quantity.centroid_values, x)
+
+
+    def test_both_updates(self):
+        quantity = Quantity(self.mesh4)
+
+        #Test centroids
+        quantity.set_values([1.,2.,3.,4.], location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values, [1, 2, 3, 4]) #Centroid
+
+        #Set explicit_update
+        quantity.explicit_update = numpy.array( [4.,3.,2.,1.] )
+
+        #Set semi implicit update
+        quantity.semi_implicit_update = numpy.array( [1.,1.,1.,1.] )
+
+        #Update with given timestep
+        timestep = 0.1
+        quantity.update(0.1)
+
+        sem = numpy.array([1.,1.,1.,1.])/numpy.array([1, 2, 3, 4])
+        denom = numpy.ones(4, numpy.float)-timestep*sem
+
+        x = numpy.array([1., 2., 3., 4.])
+        x /= denom
+        x += timestep*numpy.array( [4.0, 3.0, 2.0, 1.0] )
+
+        assert numpy.allclose( quantity.centroid_values, x)
+
+
+
+
+    #Test smoothing
+    def test_smoothing(self):
+
+        from mesh_factory import rectangular
+        from shallow_water import Domain, Transmissive_boundary
+        from anuga.utilities.numerical_tools import mean
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(2, 2)
+
+        #Create shallow water domain
+        domain = Domain(points, vertices, boundary)
+        domain.default_order=2
+        domain.reduction = mean
+
+
+        #Set some field values
+        domain.set_quantity('elevation', lambda x,y: x)
+        domain.set_quantity('friction', 0.03)
+
+
+        ######################
+        # Boundary conditions
+        B = Transmissive_boundary(domain)
+        domain.set_boundary( {'left': B, 'right': B, 'top': B, 'bottom': B})
+
+
+        ######################
+        #Initial condition - with jumps
+
+        bed = domain.quantities['elevation'].vertex_values
+        stage = numpy.zeros(bed.shape, numpy.float)
+
+        h = 0.03
+        for i in range(stage.shape[0]):
+            if i % 2 == 0:
+                stage[i,:] = bed[i,:] + h
+            else:
+                stage[i,:] = bed[i,:]
+
+        domain.set_quantity('stage', stage)
+
+        stage = domain.quantities['stage']
+
+        #Get smoothed stage
+        A, V = stage.get_vertex_values(xy=False, smooth=True)
+        Q = stage.vertex_values
+
+
+        assert A.shape[0] == 9
+        assert V.shape[0] == 8
+        assert V.shape[1] == 3
+
+        #First four points
+        assert numpy.allclose(A[0], (Q[0,2] + Q[1,1])/2)
+        assert numpy.allclose(A[1], (Q[1,0] + Q[3,1] + Q[2,2])/3)
+        assert numpy.allclose(A[2], Q[3,0])
+        assert numpy.allclose(A[3], (Q[0,0] + Q[5,1] + Q[4,2])/3)
+
+        #Center point
+        assert numpy.allclose(A[4], (Q[0,1] + Q[1,2] + Q[2,0] +\
+                                     Q[5,0] + Q[6,2] + Q[7,1])/6)
+
+
+        #Check V
+        assert numpy.allclose(V[0,:], [3,4,0])
+        assert numpy.allclose(V[1,:], [1,0,4])
+        assert numpy.allclose(V[2,:], [4,5,1])
+        assert numpy.allclose(V[3,:], [2,1,5])
+        assert numpy.allclose(V[4,:], [6,7,3])
+        assert numpy.allclose(V[5,:], [4,3,7])
+        assert numpy.allclose(V[6,:], [7,8,4])
+        assert numpy.allclose(V[7,:], [5,4,8])
+
+        #Get smoothed stage with XY
+        X, Y, A1, V1 = stage.get_vertex_values(xy=True, smooth=True)
+
+        assert numpy.allclose(A, A1)
+        assert numpy.allclose(V, V1)
+
+        #Check XY
+        assert numpy.allclose(X[4], 0.5)
+        assert numpy.allclose(Y[4], 0.5)
+
+        assert numpy.allclose(X[7], 1.0)
+        assert numpy.allclose(Y[7], 0.5)
+
+
+
+
+    def test_vertex_values_no_smoothing(self):
+
+        from mesh_factory import rectangular
+        from shallow_water import Domain, Transmissive_boundary
+        from anuga.utilities.numerical_tools import mean
+
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(2, 2)
+
+        #Create shallow water domain
+        domain = Domain(points, vertices, boundary)
+        domain.default_order=2
+        domain.reduction = mean
+
+
+        #Set some field values
+        domain.set_quantity('elevation', lambda x,y: x)
+        domain.set_quantity('friction', 0.03)
+
+
+        ######################
+        #Initial condition - with jumps
+
+        bed = domain.quantities['elevation'].vertex_values
+        stage = numpy.zeros(bed.shape, numpy.float)
+
+        h = 0.03
+        for i in range(stage.shape[0]):
+            if i % 2 == 0:
+                stage[i,:] = bed[i,:] + h
+            else:
+                stage[i,:] = bed[i,:]
+
+        domain.set_quantity('stage', stage)
+
+        #Get stage
+        stage = domain.quantities['stage']
+        A, V = stage.get_vertex_values(xy=False, smooth=False)
+        Q = stage.vertex_values.ravel()
+
+        for k in range(8):
+            assert numpy.allclose(A[k], Q[k])
+
+
+        for k in range(8):
+            assert V[k, 0] == 3*k
+            assert V[k, 1] == 3*k+1
+            assert V[k, 2] == 3*k+2
+
+
+
+        X, Y, A1, V1 = stage.get_vertex_values(xy=True, smooth=False)
+
+
+        assert numpy.allclose(A, A1)
+        assert numpy.allclose(V, V1)
+
+        #Check XY
+        assert numpy.allclose(X[1], 0.5)
+        assert numpy.allclose(Y[1], 0.5)
+        assert numpy.allclose(X[4], 0.0)
+        assert numpy.allclose(Y[4], 0.0)
+        assert numpy.allclose(X[12], 1.0)
+        assert numpy.allclose(Y[12], 0.0)
+
+
+
+    def set_array_values_by_index(self):
+
+        from mesh_factory import rectangular
+        from shallow_water import Domain
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(1, 1)
+
+        #Create shallow water domain
+        domain = Domain(points, vertices, boundary)
+        #print "domain.number_of_elements ",domain.number_of_elements
+        quantity = Quantity(domain,[[1,1,1],[2,2,2]])
+        value = [7]
+        indices = [1]
+        quantity.set_array_values_by_index(value,
+                                           location = 'centroids',
+                                           indices = indices)
+        #print "quantity.centroid_values",quantity.centroid_values
+
+        assert numpy.allclose(quantity.centroid_values, [1,7])
+
+        quantity.set_array_values([15,20,25], indices = indices)
+        assert numpy.allclose(quantity.centroid_values, [1,20])
+
+        quantity.set_array_values([15,20,25], indices = indices)
+        assert numpy.allclose(quantity.centroid_values, [1,20])
+
+    def test_setting_some_vertex_values(self):
+        """
+        set values based on triangle lists.
+        """
+        from mesh_factory import rectangular
+        from shallow_water import Domain
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(1, 3)
+        #print "vertices",vertices
+        #Create shallow water domain
+        domain = Domain(points, vertices, boundary)
+        #print "domain.number_of_elements ",domain.number_of_elements
+        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5],[6,6,6]])
+
+
+        # Check that constants work
+        value = 7
+        indices = [1]
+        quantity.set_values(value,
+                            location = 'centroids',
+                            indices = indices)
+        #print "quantity.centroid_values",quantity.centroid_values
+        assert numpy.allclose(quantity.centroid_values, [1,7,3,4,5,6])
+        
+        value = [7]
+        indices = [1]
+        quantity.set_values(value,
+                            location = 'centroids',
+                            indices = indices)
+        #print "quantity.centroid_values",quantity.centroid_values
+        assert numpy.allclose(quantity.centroid_values, [1,7,3,4,5,6])
+
+        value = [[15,20,25]]
+        quantity.set_values(value, indices = indices)
+        #print "1 quantity.vertex_values",quantity.vertex_values
+        assert numpy.allclose(quantity.vertex_values[1], value[0])
+
+
+        #print "quantity",quantity.vertex_values
+        values = [10,100,50]
+        quantity.set_values(values, indices = [0,1,5], location = 'centroids')
+        #print "2 quantity.vertex_values",quantity.vertex_values
+        assert numpy.allclose(quantity.vertex_values[0], [10,10,10])
+        assert numpy.allclose(quantity.vertex_values[5], [50,50,50])
+        #quantity.interpolate()
+        #print "quantity.centroid_values",quantity.centroid_values
+        assert numpy.allclose(quantity.centroid_values, [10,100,3,4,5,50])
+
+
+        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5],[6,6,6]])
+        values = [10,100,50]
+        #this will be per unique vertex, indexing the vertices
+        #print "quantity.vertex_values",quantity.vertex_values
+        quantity.set_values(values, indices = [0,1,5])
+        #print "quantity.vertex_values",quantity.vertex_values
+        assert numpy.allclose(quantity.vertex_values[0], [1,50,10])
+        assert numpy.allclose(quantity.vertex_values[5], [6,6,6])
+        assert numpy.allclose(quantity.vertex_values[1], [100,10,50])
+
+        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5],[6,6,6]])
+        values = [[31,30,29],[400,400,400],[1000,999,998]]
+        quantity.set_values(values, indices = [3,3,5])
+        quantity.interpolate()
+        assert numpy.allclose(quantity.centroid_values, [1,2,3,400,5,999])
+
+        values = [[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5],[6,6,6]]
+        quantity.set_values(values)
+
+        # testing the standard set values by vertex
+        # indexed by vertex_id in general_mesh.coordinates
+        values = [0,1,2,3,4,5,6,7]
+
+        quantity.set_values(values)
+        #print "1 quantity.vertex_values",quantity.vertex_values
+        assert numpy.allclose(quantity.vertex_values,[[ 4.,  5.,  0.],
+                                                      [ 1.,  0.,  5.],
+                                                      [ 5.,  6.,  1.],
+                                                      [ 2.,  1.,  6.],
+                                                      [ 6.,  7.,  2.],
+                                                      [ 3.,  2.,  7.]])
+
+    def test_setting_unique_vertex_values(self):
+        """
+        set values based on unique_vertex lists.
+        """
+        from mesh_factory import rectangular
+        from shallow_water import Domain
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(1, 3)
+        #print "vertices",vertices
+        #Create shallow water domain
+        domain = Domain(points, vertices, boundary)
+        #print "domain.number_of_elements ",domain.number_of_elements
+        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5]])
+        value = 7
+        indices = [1,5]
+        quantity.set_values(value,
+                            location = 'unique vertices',
+                            indices = indices)
+        #print "quantity.centroid_values",quantity.centroid_values
+        assert numpy.allclose(quantity.vertex_values[0], [0,7,0])
+        assert numpy.allclose(quantity.vertex_values[1], [7,1,7])
+        assert numpy.allclose(quantity.vertex_values[2], [7,2,7])
+
+
+    def test_get_values(self):
+        """
+        get values based on triangle lists.
+        """
+        from mesh_factory import rectangular
+        from shallow_water import Domain
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(1, 3)
+
+        #print "points",points
+        #print "vertices",vertices
+        #print "boundary",boundary
+
+        #Create shallow water domain
+        domain = Domain(points, vertices, boundary)
+        #print "domain.number_of_elements ",domain.number_of_elements
+        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5]])
+
+        #print "quantity.get_values(location = 'unique vertices')", \
+        #      quantity.get_values(location = 'unique vertices')
+
+        #print "quantity.get_values(location = 'unique vertices')", \
+        #      quantity.get_values(indices=[0,1,2,3,4,5,6,7], \
+        #                          location = 'unique vertices')
+
+        answer = [0.5,2,4,5,0,1,3,4.5]
+        assert numpy.allclose(answer,
+                              quantity.get_values(location = 'unique vertices'))
+
+        indices = [0,5,3]
+        answer = [0.5,1,5]
+        assert numpy.allclose(answer,
+                              quantity.get_values(indices=indices, 
+                                                  location = 'unique vertices'))
+        #print "quantity.centroid_values",quantity.centroid_values
+        #print "quantity.get_values(location = 'centroids') ",\
+        #      quantity.get_values(location = 'centroids')
+
+
+
+
+    def test_get_values_2(self):
+        """Different mesh (working with domain object) - also check centroids.
+        """
+
+        
+        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)
+
+        quantity = Quantity(domain)
+        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
+        
+        assert numpy.allclose(quantity.get_values(location='centroids'), [2,4,4,6])
+        assert numpy.allclose(quantity.get_values(location='centroids', indices=[1,3]), [4,6])
+
+
+        assert numpy.allclose(quantity.get_values(location='vertices'), [[4,0,2],
+                                                                         [4,2,6],
+                                                                         [6,2,4],
+                                                                         [8,4,6]])
+        
+        assert numpy.allclose(quantity.get_values(location='vertices', indices=[1,3]), [[4,2,6],
+                                                                                        [8,4,6]])
+
+
+        assert numpy.allclose(quantity.get_values(location='edges'), [[1,3,2],
+                                                                      [4,5,3],
+                                                                      [3,5,4],
+                                                                      [5,7,6]])
+        assert numpy.allclose(quantity.get_values(location='edges', indices=[1,3]),
+                              [[4,5,3],
+                               [5,7,6]])        
+
+        # Check averaging over vertices
+        #a: 0
+        #b: (4+4+4)/3
+        #c: (2+2+2)/3
+        #d: 8
+        #e: (6+6+6)/3        
+        #f: 4
+        assert(quantity.get_values(location='unique vertices'), [0, 4, 2, 8, 6, 4])        
+                                                                                  
+        
+
+
+
+
+    def test_get_interpolated_values(self):
+
+        from mesh_factory import rectangular
+        from shallow_water import Domain
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(1, 3)
+        domain = Domain(points, vertices, boundary)
+
+        #Constant values
+        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5]])
+
+        
+
+        # Get interpolated values at centroids
+        interpolation_points = domain.get_centroid_coordinates()
+        answer = quantity.get_values(location='centroids')
+
+        
+        #print quantity.get_values(points=interpolation_points)
+        assert numpy.allclose(answer, quantity.get_values(interpolation_points=interpolation_points))
+
+
+        #Arbitrary values
+        quantity = Quantity(domain,[[0,1,2],[3,1,7],[2,1,2],[3,3,7],
+                                    [1,4,-9],[2,5,0]])
+
+
+        # Get interpolated values at centroids
+        interpolation_points = domain.get_centroid_coordinates()
+        answer = quantity.get_values(location='centroids')
+        #print answer
+        #print quantity.get_values(interpolation_points=interpolation_points)
+        assert numpy.allclose(answer, quantity.get_values(interpolation_points=interpolation_points,
+                                                          verbose=False))        
+                        
+
+        #FIXME TODO
+        #indices = [0,5,3]
+        #answer = [0.5,1,5]
+        #assert numpy.allclose(answer,
+        #                      quantity.get_values(indices=indices,
+        #                                          location = 'unique vertices'))
+
+
+
+
+    def test_get_interpolated_values_2(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
+        vertices = [[1,0,2], [1,2,4], [4,2,5], [3,1,4]]
+
+        domain = Domain(points, vertices)
+
+        quantity = Quantity(domain)
+        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
+
+        #First pick one point
+        x, y = 2.0/3, 8.0/3
+        v = quantity.get_values(interpolation_points = [[x,y]])
+        assert numpy.allclose(v, 6)        
+
+        # Then another to test that algorithm won't blindly
+        # reuse interpolation matrix
+        x, y = 4.0/3, 4.0/3
+        v = quantity.get_values(interpolation_points = [[x,y]])
+        assert numpy.allclose(v, 4)        
+
+
+
+    def test_get_interpolated_values_with_georef(self):
+    
+        zone = 56
+        xllcorner = 308500
+        yllcorner = 6189000
+        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,
+                        geo_reference=Geo_reference(zone,xllcorner,yllcorner))
+
+        quantity = Quantity(domain)
+        quantity.set_values(lambda x, y: x+2*y) #2 4 4 6
+
+        #First pick one point (and turn it into absolute coordinates)
+        x, y = 2.0/3, 8.0/3
+        v = quantity.get_values(interpolation_points = [[x+xllcorner,y+yllcorner]])
+        assert numpy.allclose(v, 6)
+        
+
+        # Then another to test that algorithm won't blindly
+        # reuse interpolation matrix 
+        x, y = 4.0/3, 4.0/3
+        v = quantity.get_values(interpolation_points = [[x+xllcorner,y+yllcorner]])
+        assert numpy.allclose(v, 4)        
+        
+        # Try two points
+        pts = [[2.0/3 + xllcorner, 8.0/3 + yllcorner], 
+               [4.0/3 + xllcorner, 4.0/3 + yllcorner]]         
+        v = quantity.get_values(interpolation_points=pts)
+        assert numpy.allclose(v, [6, 4])               
+        
+        # Test it using the geospatial data format with absolute input points and default georef
+        pts = Geospatial_data(data_points=pts)
+        v = quantity.get_values(interpolation_points=pts)
+        assert numpy.allclose(v, [6, 4])                                
+        
+        
+        # Test it using the geospatial data format with relative input points
+        pts = Geospatial_data(data_points=[[2.0/3, 8.0/3], [4.0/3, 4.0/3]], 
+                              geo_reference=Geo_reference(zone,xllcorner,yllcorner))
+        v = quantity.get_values(interpolation_points=pts)
+        assert numpy.allclose(v, [6, 4])                        
+        
+        
+        
+
+    def test_getting_some_vertex_values(self):
+        """
+        get values based on triangle lists.
+        """
+        from mesh_factory import rectangular
+        from shallow_water import Domain
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(1, 3)
+
+        #print "points",points
+        #print "vertices",vertices
+        #print "boundary",boundary
+
+        #Create shallow water domain
+        domain = Domain(points, vertices, boundary)
+        #print "domain.number_of_elements ",domain.number_of_elements
+        quantity = Quantity(domain,[[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5],[6,6,6]])
+        value = [7]
+        indices = [1]
+        quantity.set_values(value,
+                            location = 'centroids',
+                            indices = indices)
+        #print "quantity.centroid_values",quantity.centroid_values
+        #print "quantity.get_values(location = 'centroids') ",\
+        #      quantity.get_values(location = 'centroids')
+        assert numpy.allclose(quantity.centroid_values,
+                              quantity.get_values(location = 'centroids'))
+
+
+        value = [[15,20,25]]
+        quantity.set_values(value, indices = indices)
+        #print "1 quantity.vertex_values",quantity.vertex_values
+        assert numpy.allclose(quantity.vertex_values, quantity.get_values())
+
+        assert numpy.allclose(quantity.edge_values,
+                              quantity.get_values(location = 'edges'))
+
+        # get a subset of elements
+        subset = quantity.get_values(location='centroids', indices=[0,5])
+        answer = [quantity.centroid_values[0],quantity.centroid_values[5]]
+        assert numpy.allclose(subset, answer)
+
+
+        subset = quantity.get_values(location='edges', indices=[0,5])
+        answer = [quantity.edge_values[0],quantity.edge_values[5]]
+        #print "subset",subset
+        #print "answer",answer
+        assert numpy.allclose(subset, answer)
+
+        subset = quantity.get_values( indices=[1,5])
+        answer = [quantity.vertex_values[1],quantity.vertex_values[5]]
+        #print "subset",subset
+        #print "answer",answer
+        assert numpy.allclose(subset, answer)
+
+    def test_smooth_vertex_values(self):
+        """
+        get values based on triangle lists.
+        """
+        from mesh_factory import rectangular
+        from shallow_water import Domain
+
+        #Create basic mesh
+        points, vertices, boundary = rectangular(2, 2)
+
+        #print "points",points
+        #print "vertices",vertices
+        #print "boundary",boundary
+
+        #Create shallow water domain
+        domain = Domain(points, vertices, boundary)
+        #print "domain.number_of_elements ",domain.number_of_elements
+        quantity = Quantity(domain,[[0,0,0],[1,1,1],[2,2,2],[3,3,3],
+                                    [4,4,4],[5,5,5],[6,6,6],[7,7,7]])
+
+        #print "quantity.get_values(location = 'unique vertices')", \
+        #      quantity.get_values(location = 'unique vertices')
+
+        #print "quantity.get_values(location = 'unique vertices')", \
+        #      quantity.get_values(indices=[0,1,2,3,4,5,6,7], \
+        #                          location = 'unique vertices')
+
+        #print quantity.get_values(location = 'unique vertices')
+        #print quantity.domain.number_of_triangles_per_node
+        #print quantity.vertex_values
+        
+        #answer = [0.5, 2, 3, 3, 3.5, 4, 4, 5, 6.5]
+        #assert numpy.allclose(answer,
+        #                      quantity.get_values(location = 'unique vertices'))
+
+        quantity.smooth_vertex_values()
+
+        #print quantity.vertex_values
+
+
+        answer_vertex_values = [[3,3.5,0.5],[2,0.5,3.5],[3.5,4,2],[3,2,4],
+                                [4,5,3],[3.5,3,5],[5,6.5,3.5],[4,3.5,6.5]]
+        
+        assert numpy.allclose(answer_vertex_values,
+                              quantity.vertex_values)
+        #print "quantity.centroid_values",quantity.centroid_values
+        #print "quantity.get_values(location = 'centroids') ",\
+        #      quantity.get_values(location = 'centroids')
 
 
@@ -2540 +2509 @@
 if __name__ == "__main__":
     suite = unittest.makeSuite(Test_Quantity, 'test')    
-    #suite = unittest.makeSuite(Test_Quantity, 'test_set_values_from_file_using_polygon')
-
-    #suite = unittest.makeSuite(Test_Quantity, 'test_set_vertex_values_using_general_interface_with_subset')
-    #print "restricted test"
-    #suite = unittest.makeSuite(Test_Quantity,'verbose_test_set_values_from_UTM_pts')
+#    suite = unittest.makeSuite(Test_Quantity, 'test_get_extrema_1')
     runner = unittest.TextTestRunner()
     runner.run(suite)

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_region.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
@@ -8 +6 @@
 from domain import *
 from region import *
-#from anuga.config import epsilon
-from numpy.oldnumeric import allclose, average #, array, ones, Float
+import numpy
+
 """
 This is what the mesh in these tests look like;
@@ -46 +44 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-        from numpy.oldnumeric import zeros, Float
 
         #Create basic mesh
@@ -66 +63 @@
         domain.set_region([a, b])
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),\
-                        [[ 0.09,  0.09,  0.09],
-                         [ 0.09,  0.09,  0.09],
-                         [ 0.07,  0.07,  0.07],
-                         [ 0.07,  0.07,  0.07],
-                         [ 1.0,  1.0,  1.0],
-                         [ 1.0,  1.0,  1.0]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),
+                              [[ 0.09,  0.09,  0.09],
+                               [ 0.09,  0.09,  0.09],
+                               [ 0.07,  0.07,  0.07],
+                               [ 0.07,  0.07,  0.07],
+                               [ 1.0,  1.0,  1.0],
+                               [ 1.0,  1.0,  1.0]])
 
         #c = Add_Value_To_region('all', 'friction', 10.0)
         domain.set_region(Add_value_to_region('all', 'friction', 10.0))
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),
-                        [[ 10.09, 10.09, 10.09],
-                         [ 10.09, 10.09, 10.09],
-                         [ 10.07, 10.07, 10.07],
-                         [ 10.07, 10.07, 10.07],
-                         [ 11.0,  11.0,  11.0],
-                         [ 11.0,  11.0,  11.0]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),
+                              [[ 10.09, 10.09, 10.09],
+                               [ 10.09, 10.09, 10.09],
+                               [ 10.07, 10.07, 10.07],
+                               [ 10.07, 10.07, 10.07],
+                               [ 11.0,  11.0,  11.0],
+                               [ 11.0,  11.0,  11.0]])
 
         # trying a function
         domain.set_region(Set_region('top', 'friction', add_x_y))
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),
-                        [[ 10.09, 10.09, 10.09],
-                         [ 10.09, 10.09, 10.09],
-                         [ 10.07, 10.07, 10.07],
-                         [ 10.07, 10.07, 10.07],
-                         [ 5./3,  2.0,  2./3],
-                         [ 1.0,  2./3,  2.0]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),
+                              [[ 10.09, 10.09, 10.09],
+                               [ 10.09, 10.09, 10.09],
+                               [ 10.07, 10.07, 10.07],
+                               [ 10.07, 10.07, 10.07],
+                               [ 5./3,  2.0,  2./3],
+                               [ 1.0,  2./3,  2.0]])
 
         domain.set_quantity('elevation', 10.0)
@@ -100 +97 @@
         domain.set_region(Add_value_to_region('top', 'stage', 1.0,initial_quantity='elevation'))
         #print domain.quantities['stage'].get_values()
-        assert allclose(domain.quantities['stage'].get_values(),
-                        [[ 10., 10., 10.],
-                         [ 10., 10., 10.],
-                         [ 10., 10., 10.],
-                         [ 10., 10., 10.],
-                         [ 11.0,  11.0,  11.0],
-                         [ 11.0,  11.0,  11.0]])
+        assert numpy.allclose(domain.quantities['stage'].get_values(),
+                              [[ 10., 10., 10.],
+                               [ 10., 10., 10.],
+                               [ 10., 10., 10.],
+                               [ 10., 10., 10.],
+                               [ 11.0,  11.0,  11.0],
+                               [ 11.0,  11.0,  11.0]])
 
         
@@ -117 +114 @@
         domain.set_region(Add_quantities('top', 'elevation','stage'))
         #print domain.quantities['stage'].get_values()
-        assert allclose(domain.quantities['elevation'].get_values(),
-                        [[ 10., 10., 10.],
-                         [ 10., 10., 10.],
-                         [ 10., 10., 10.],
-                         [ 10., 10., 10.],
-                         [ 33.,  33.0,  33.],
-                         [ 33.0,  33.,  33.]])
+        assert numpy.allclose(domain.quantities['elevation'].get_values(),
+                              [[ 10., 10., 10.],
+                               [ 10., 10., 10.],
+                               [ 10., 10., 10.],
+                               [ 10., 10., 10.],
+                               [ 33.,  33.0,  33.],
+                               [ 33.0,  33.,  33.]])
         
     def test_unique_vertices(self):
@@ -131 +128 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-        from numpy.oldnumeric import zeros, Float
 
         #Create basic mesh
@@ -149 +145 @@
         domain.set_region(a)
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),\
-                        [[ 0.09,  0.09,  0.09],
-                         [ 0.09,  0.09,  0.09],
-                         [ 0.09,  0.07,  0.09],
-                         [ 0.07,  0.09,  0.07],
-                         [ 0.07,  0.07,  0.07],
-                         [ 0.07,  0.07,  0.07]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),\
+                              [[ 0.09,  0.09,  0.09],
+                               [ 0.09,  0.09,  0.09],
+                               [ 0.09,  0.07,  0.09],
+                               [ 0.07,  0.09,  0.07],
+                               [ 0.07,  0.07,  0.07],
+                               [ 0.07,  0.07,  0.07]])
 
 
@@ -164 +160 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-        from numpy.oldnumeric import zeros, Float
 
         #Create basic mesh
@@ -182 +177 @@
 
         #print domain.quantities['friction'].get_values()
-        assert allclose(domain.quantities['friction'].get_values(),\
-                        [[ 1.07,  1.07,  1.07],
-                         [ 1.07,  1.07,  1.07],
-                         [ 1.07,  0.07,  1.07],
-                         [ 0.07,  1.07,  0.07],
-                         [ 0.07,  0.07,  0.07],
-                         [ 0.07,  0.07,  0.07]])
+        assert numpy.allclose(domain.quantities['friction'].get_values(),\
+                              [[ 1.07,  1.07,  1.07],
+                               [ 1.07,  1.07,  1.07],
+                               [ 1.07,  0.07,  1.07],
+                               [ 0.07,  1.07,  0.07],
+                               [ 0.07,  0.07,  0.07],
+                               [ 0.07,  0.07,  0.07]])
                          
     def test_unique_vertices_average_loc_vert(self):
@@ -196 +191 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-        from numpy.oldnumeric import zeros, Float
 
         #Create basic mesh
@@ -220 +214 @@
         #print domain.quantities['friction'].get_values()
         frict_points = domain.quantities['friction'].get_values()
-        assert allclose(frict_points[0],\
-                        [ calc_frict, calc_frict, calc_frict])
-        assert allclose(frict_points[1],\
-                        [ calc_frict, calc_frict, calc_frict])
+        assert numpy.allclose(frict_points[0],
+                              [ calc_frict, calc_frict, calc_frict])
+        assert numpy.allclose(frict_points[1],
+                              [ calc_frict, calc_frict, calc_frict])
   
     def test_unique_vertices_average_loc_unique_vert(self):
@@ -231 +225 @@
         from mesh_factory import rectangular
         from shallow_water import Domain
-        from numpy.oldnumeric import zeros, Float
 
         #Create basic mesh
@@ -254 +247 @@
         #print domain.quantities['friction'].get_values()
         frict_points = domain.quantities['friction'].get_values()
-        assert allclose(frict_points[0],\
-                        [ calc_frict, calc_frict, calc_frict])
-        assert allclose(frict_points[1],\
-                        [ calc_frict, calc_frict, calc_frict])
-        assert allclose(frict_points[2],\
-                        [ calc_frict, 1.0 + 2.0/3.0, calc_frict])
-        assert allclose(frict_points[3],\
-                        [ 2.0/3.0,calc_frict, 1.0 + 2.0/3.0])
+        assert numpy.allclose(frict_points[0],
+                              [ calc_frict, calc_frict, calc_frict])
+        assert numpy.allclose(frict_points[1],
+                              [ calc_frict, calc_frict, calc_frict])
+        assert numpy.allclose(frict_points[2],
+                              [ calc_frict, 1.0 + 2.0/3.0, calc_frict])
+        assert numpy.allclose(frict_points[3],
+                              [ 2.0/3.0,calc_frict, 1.0 + 2.0/3.0])
                                                 
                          
 #-------------------------------------------------------------
 if __name__ == "__main__":
-##    suite = unittest.makeSuite(Test_Region,'test')
-    suite = unittest.makeSuite(Test_Region,'test_unique_vertices_average_loc_unique_vert')
+    suite = unittest.makeSuite(Test_Region,'test')
+##    suite = unittest.makeSuite(Test_Region,'test_unique_vertices_average_loc_unique_vert')
     runner = unittest.TextTestRunner()
     runner.run(suite)

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/test_util.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/env python
 
-
 import unittest
-##from numpy.oldnumeric import zeros, array, allclose, Float, alltrue
-from numpy import zeros, array, allclose, float, alltrue
+import numpy
+
 from math import sqrt, pi
 import tempfile, os
@@ -94 +91 @@
 
             #Exact linear intpolation
-            assert allclose(q[0], 2*t)
+            assert numpy.allclose(q[0], 2*t)
             if i%6 == 0:
-                assert allclose(q[1], t**2)
-                assert allclose(q[2], sin(t*pi/600))
+                assert numpy.allclose(q[1], t**2)
+                assert numpy.allclose(q[2], sin(t*pi/600))
 
         #Check non-exact
@@ -103 +100 @@
         t = 90 #Halfway between 60 and 120
         q = F(t)
-        assert allclose( (120**2 + 60**2)/2, q[1] )
-        assert allclose( (sin(120*pi/600) + sin(60*pi/600))/2, q[2] )
+        assert numpy.allclose( (120**2 + 60**2)/2, q[1] )
+        assert numpy.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 allclose( 2*120**2/3 + 60**2/3, q[1] )
-        assert allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
+        assert numpy.allclose( 2*120**2/3 + 60**2/3, q[1] )
+        assert numpy.allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
 
         os.remove(filename + '.txt')
@@ -128 +125 @@
         from shallow_water import Domain, Dirichlet_boundary
         from mesh_factory import rectangular
-        from numpy.oldnumeric import take, concatenate, reshape
 
         #Create basic mesh and shallow water domain
@@ -159 +155 @@
         #Evolution
         t0 = -1
+# crash at following line
         for t in domain1.evolve(yieldstep = 0.1, finaltime = finaltime):
             #print 'Timesteps: %.16f, %.16f' %(t0, t)
@@ -185 +182 @@
 
         last_time_index = len(time)-1 #Last last_time_index
-        d_stage = reshape(take(stage[last_time_index, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[last_time_index, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[last_time_index, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(numpy.take(stage[last_time_index, :], [0,5,10,15], axis=0), (4,1))
+        d_uh = numpy.reshape(numpy.take(xmomentum[last_time_index, :], [0,5,10,15], axis=0), (4,1))
+        d_vh = numpy.reshape(numpy.take(ymomentum[last_time_index, :], [0,5,10,15], axis=0), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -197 +194 @@
 
         #And the midpoints are found now
-        Dx = take(reshape(x, (16,1)), [0,5,10,15])
-        Dy = take(reshape(y, (16,1)), [0,5,10,15])
-
-        diag = concatenate( (Dx, Dy), axis=1)
+        Dx = numpy.take(numpy.reshape(x, (16,1)), [0,5,10,15], axis=0)
+        Dy = numpy.take(numpy.reshape(y, (16,1)), [0,5,10,15], axis=0)
+
+        diag = numpy.concatenate( (Dx, Dy), axis=1)
         d_midpoints = (diag[1:] + diag[:-1])/2
 
@@ -212 +209 @@
         assert not T[-1] == T[-2], msg
         t = time[last_time_index]
-        q = f(t, point_id=0); assert allclose(r0, q)
-        q = f(t, point_id=1); assert allclose(r1, q)
-        q = f(t, point_id=2); assert allclose(r2, q)
+        q = f(t, point_id=0); assert numpy.allclose(r0, q)
+        q = f(t, point_id=1); assert numpy.allclose(r1, q)
+        q = f(t, point_id=2); assert numpy.allclose(r2, q)
 
 
@@ -221 +218 @@
 
         timestep = 0 #First timestep
-        d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(numpy.take(stage[timestep, :], [0,5,10,15], axis=0), (4,1))
+        d_uh = numpy.reshape(numpy.take(xmomentum[timestep, :], [0,5,10,15], axis=0), (4,1))
+        d_vh = numpy.reshape(numpy.take(ymomentum[timestep, :], [0,5,10,15], axis=0), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -234 +231 @@
         #Let us see if the file function can find the correct
         #values
-        q = f(0, point_id=0); assert allclose(r0, q)
-        q = f(0, point_id=1); assert allclose(r1, q)
-        q = f(0, point_id=2); assert allclose(r2, q)
+        q = f(0, point_id=0); assert numpy.allclose(r0, q)
+        q = f(0, point_id=1); assert numpy.allclose(r1, q)
+        q = f(0, point_id=2); assert numpy.allclose(r2, q)
 
 
@@ -243 +240 @@
 
         timestep = 33
-        d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(numpy.take(stage[timestep, :], [0,5,10,15], axis=0), (4,1))
+        d_uh = numpy.reshape(numpy.take(xmomentum[timestep, :], [0,5,10,15], axis=0), (4,1))
+        d_vh = numpy.reshape(numpy.take(ymomentum[timestep, :], [0,5,10,15], axis=0), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -254 +251 @@
         r2 = (D[2] + D[3])/2
 
-        q = f(timestep/10., point_id=0); assert allclose(r0, q)
-        q = f(timestep/10., point_id=1); assert allclose(r1, q)
-        q = f(timestep/10., point_id=2); assert allclose(r2, q)
+        q = f(timestep/10., point_id=0); assert numpy.allclose(r0, q)
+        q = f(timestep/10., point_id=1); assert numpy.allclose(r1, q)
+        q = f(timestep/10., point_id=2); assert numpy.allclose(r2, q)
 
 
@@ -264 +261 @@
 
         timestep = 15
-        d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(numpy.take(stage[timestep, :], [0,5,10,15], axis=0), (4,1))
+        d_uh = numpy.reshape(numpy.take(xmomentum[timestep, :], [0,5,10,15], axis=0), (4,1))
+        d_vh = numpy.reshape(numpy.take(ymomentum[timestep, :], [0,5,10,15], axis=0), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -277 +274 @@
         #
         timestep = 16
-        d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(numpy.take(stage[timestep, :], [0,5,10,15], axis=0), (4,1))
+        d_uh = numpy.reshape(numpy.take(xmomentum[timestep, :], [0,5,10,15], axis=0), (4,1))
+        d_vh = numpy.reshape(numpy.take(ymomentum[timestep, :], [0,5,10,15], axis=0), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -293 +290 @@
         r2 = (r2_0 + r2_1)/2
 
-        q = f((timestep - 0.5)/10., point_id=0); assert allclose(r0, q)
-        q = f((timestep - 0.5)/10., point_id=1); assert allclose(r1, q)
-        q = f((timestep - 0.5)/10., point_id=2); assert allclose(r2, q)
+        q = f((timestep - 0.5)/10., point_id=0); assert numpy.allclose(r0, q)
+        q = f((timestep - 0.5)/10., point_id=1); assert numpy.allclose(r1, q)
+        q = f((timestep - 0.5)/10., point_id=2); assert numpy.allclose(r2, q)
 
         ##################
@@ -307 +304 @@
 
         #And the file function gives
-        q = f((timestep - 1.0/3)/10., point_id=0); assert allclose(r0, q)
-        q = f((timestep - 1.0/3)/10., point_id=1); assert allclose(r1, q)
-        q = f((timestep - 1.0/3)/10., point_id=2); assert allclose(r2, q)
+        q = f((timestep - 1.0/3)/10., point_id=0); assert numpy.allclose(r0, q)
+        q = f((timestep - 1.0/3)/10., point_id=1); assert numpy.allclose(r1, q)
+        q = f((timestep - 1.0/3)/10., point_id=2); assert numpy.allclose(r2, q)
 
         fid.close()
@@ -329 +326 @@
         from shallow_water import Domain, Dirichlet_boundary
         from mesh_factory import rectangular
-        from numpy.oldnumeric import take, concatenate, reshape
 
 
@@ -389 +385 @@
 
         last_time_index = len(time)-1 #Last last_time_index     
-        d_stage = reshape(take(stage[last_time_index, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[last_time_index, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[last_time_index, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(take(stage[last_time_index, :], [0,5,10,15]), (4,1))
+        d_uh = numpy.reshape(take(xmomentum[last_time_index, :], [0,5,10,15]), (4,1))
+        d_vh = numpy.reshape(take(ymomentum[last_time_index, :], [0,5,10,15]), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -401 +397 @@
 
         #And the midpoints are found now
-        Dx = take(reshape(x, (16,1)), [0,5,10,15])
-        Dy = take(reshape(y, (16,1)), [0,5,10,15])
-
-        diag = concatenate( (Dx, Dy), axis=1)
+        Dx = take(numpy.reshape(x, (16,1)), [0,5,10,15])
+        Dy = take(numpy.reshape(y, (16,1)), [0,5,10,15])
+
+        diag = numpy.concatenate( (Dx, Dy), axis=1)
         d_midpoints = (diag[1:] + diag[:-1])/2
 
@@ -418 +414 @@
 
         t = time[last_time_index]                         
-        q = f(t, point_id=0); assert allclose(r0, q)
-        q = f(t, point_id=1); assert allclose(r1, q)
-        q = f(t, point_id=2); assert allclose(r2, q)
+        q = f(t, point_id=0); assert numpy.allclose(r0, q)
+        q = f(t, point_id=1); assert numpy.allclose(r1, q)
+        q = f(t, point_id=2); assert numpy.allclose(r2, q)
 
 
@@ -427 +423 @@
 
         timestep = 0 #First timestep
-        d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
+        d_uh = numpy.reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
+        d_vh = numpy.reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -440 +436 @@
         #Let us see if the file function can find the correct
         #values
-        q = f(0, point_id=0); assert allclose(r0, q)
-        q = f(0, point_id=1); assert allclose(r1, q)
-        q = f(0, point_id=2); assert allclose(r2, q)
+        q = f(0, point_id=0); assert numpy.allclose(r0, q)
+        q = f(0, point_id=1); assert numpy.allclose(r1, q)
+        q = f(0, point_id=2); assert numpy.allclose(r2, q)
 
 
@@ -449 +445 @@
 
         timestep = 33
-        d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
+        d_uh = numpy.reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
+        d_vh = numpy.reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -460 +456 @@
         r2 = (D[2] + D[3])/2
 
-        q = f(timestep/10., point_id=0); assert allclose(r0, q)
-        q = f(timestep/10., point_id=1); assert allclose(r1, q)
-        q = f(timestep/10., point_id=2); assert allclose(r2, q)
+        q = f(timestep/10., point_id=0); assert numpy.allclose(r0, q)
+        q = f(timestep/10., point_id=1); assert numpy.allclose(r1, q)
+        q = f(timestep/10., point_id=2); assert numpy.allclose(r2, q)
 
 
@@ -470 +466 @@
 
         timestep = 15
-        d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
+        d_uh = numpy.reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
+        d_vh = numpy.reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -483 +479 @@
         #
         timestep = 16
-        d_stage = reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
-        d_uh = reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
-        d_vh = reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
-        D = concatenate( (d_stage, d_uh, d_vh), axis=1)
+        d_stage = numpy.reshape(take(stage[timestep, :], [0,5,10,15]), (4,1))
+        d_uh = numpy.reshape(take(xmomentum[timestep, :], [0,5,10,15]), (4,1))
+        d_vh = numpy.reshape(take(ymomentum[timestep, :], [0,5,10,15]), (4,1))
+        D = numpy.concatenate( (d_stage, d_uh, d_vh), axis=1)
 
         #Reference interpolated values at midpoints on diagonal at
@@ -499 +495 @@
         r2 = (r2_0 + r2_1)/2
 
-        q = f((timestep - 0.5)/10., point_id=0); assert allclose(r0, q)
-        q = f((timestep - 0.5)/10., point_id=1); assert allclose(r1, q)
-        q = f((timestep - 0.5)/10., point_id=2); assert allclose(r2, q)
+        q = f((timestep - 0.5)/10., point_id=0); assert numpy.allclose(r0, q)
+        q = f((timestep - 0.5)/10., point_id=1); assert numpy.allclose(r1, q)
+        q = f((timestep - 0.5)/10., point_id=2); assert numpy.allclose(r2, q)
 
         ##################
@@ -513 +509 @@
 
         #And the file function gives
-        q = f((timestep - 1.0/3)/10., point_id=0); assert allclose(r0, q)
-        q = f((timestep - 1.0/3)/10., point_id=1); assert allclose(r1, q)
-        q = f((timestep - 1.0/3)/10., point_id=2); assert allclose(r2, q)
+        q = f((timestep - 1.0/3)/10., point_id=0); assert numpy.allclose(r0, q)
+        q = f((timestep - 1.0/3)/10., point_id=1); assert numpy.allclose(r1, q)
+        q = f((timestep - 1.0/3)/10., point_id=2); assert numpy.allclose(r2, q)
 
         fid.close()
@@ -545 +541 @@
         import os, time
         from anuga.config import time_format
-        from numpy.oldnumeric import sin, pi, exp
         from mesh_factory import rectangular
         from shallow_water import Domain
@@ -587 +582 @@
             domain.set_quantity('xmomentum', f2)
 
-            f3 = lambda x,y: x**2 + y**2 * sin(t*pi/600)
+            f3 = lambda x,y: x**2 + y**2 * numpy.sin(t*numpy.pi/600)
             domain.set_quantity('ymomentum', f3)
 
@@ -607 +602 @@
 
         #Check that FF updates fixes domain starttime
-        assert allclose(domain.starttime, start)
+        assert numpy.allclose(domain.starttime, start)
 
         #Check that domain.starttime isn't updated if later
@@ -614 +609 @@
                           quantities = domain.conserved_quantities,
                           interpolation_points = interpolation_points)
-        assert allclose(domain.starttime, start+1)
+        assert numpy.allclose(domain.starttime, start+1)
         domain.starttime = start
 
@@ -648 +643 @@
                      self.failUnless( q == actual, 'Fail!')
                 else:
-                    assert allclose(q, actual)
+                    assert numpy.allclose(q, actual)
 
 
@@ -658 +653 @@
             t = 90 #Halfway between 60 and 120
             q = F(t, point_id=id)
-            assert allclose( (q120+q60)/2, q )
+            assert numpy.allclose( (q120+q60)/2, q )
 
             t = 100 #Two thirds of the way between between 60 and 120
             q = F(t, point_id=id)
-            assert allclose(q60/3 + 2*q120/3, q)
+            assert numpy.allclose(q60/3 + 2*q120/3, q)
 
 
@@ -673 +668 @@
                           quantities = domain.conserved_quantities,
                           interpolation_points = interpolation_points)
-        assert allclose(domain.starttime, start+delta)
+        assert numpy.allclose(domain.starttime, start+delta)
 
 
@@ -692 +687 @@
 
                 q = F(t-delta, point_id=id)
-                assert allclose(q, (k*q1 + (6-k)*q0)/6)
+                assert numpy.allclose(q, (k*q1 + (6-k)*q0)/6)
 
 
@@ -706 +701 @@
         import os, time
         from anuga.config import time_format
-        from numpy.oldnumeric import sin, pi, exp
         from mesh_factory import rectangular
         from shallow_water import Domain
@@ -754 +748 @@
             domain.set_quantity('xmomentum', f2)
 
-            f3 = lambda x,y: x**2 + y**2 * sin(t*pi/600)
+            f3 = lambda x,y: x**2 + y**2 * numpy.sin(t*numpy.pi/600)
             domain.set_quantity('ymomentum', f3)
 
@@ -777 +771 @@
 
         #Check that FF updates fixes domain starttime
-        assert allclose(domain.starttime, start)
+        assert numpy.allclose(domain.starttime, start)
 
         #Check that domain.starttime isn't updated if later
@@ -784 +778 @@
                           quantities = domain.conserved_quantities,
                           interpolation_points = interpolation_points)
-        assert allclose(domain.starttime, start+1)
+        assert numpy.allclose(domain.starttime, start+1)
         domain.starttime = start
 
@@ -820 +814 @@
                      self.failUnless( q == actual, 'Fail!')
                 else:
-                    assert allclose(q, actual)
+                    assert numpy.allclose(q, actual)
 
         # now lets check points inside the mesh
@@ -866 +860 @@
                      self.failUnless( q == actual, 'Fail!')
                 else:
-                    assert allclose(q, actual)
+                    assert numpy.allclose(q, actual)
 
 
@@ -876 +870 @@
             t = 90 #Halfway between 60 and 120
             q = F(t, point_id=id)
-            assert allclose( (q120+q60)/2, q )
+            assert numpy.allclose( (q120+q60)/2, q )
 
             t = 100 #Two thirds of the way between between 60 and 120
             q = F(t, point_id=id)
-            assert allclose(q60/3 + 2*q120/3, q)
+            assert numpy.allclose(q60/3 + 2*q120/3, q)
 
 
@@ -891 +885 @@
                           quantities = domain.conserved_quantities,
                           interpolation_points = interpolation_points)
-        assert allclose(domain.starttime, start+delta)
+        assert numpy.allclose(domain.starttime, start+delta)
 
 
@@ -910 +904 @@
 
                 q = F(t-delta, point_id=id)
-                assert allclose(q, (k*q1 + (6-k)*q0)/6)
+                assert numpy.allclose(q, (k*q1 + (6-k)*q0)/6)
 
 
@@ -958 +952 @@
                           domain,
                           quantities = ['Attribute0', 'Attribute1', 'Attribute2'])  
-        assert allclose(domain.starttime, start)
+        assert numpy.allclose(domain.starttime, start)
 
         # Check that domain.starttime is updated if too early
@@ -965 +959 @@
                           domain,
                           quantities = ['Attribute0', 'Attribute1', 'Attribute2'])
-        assert allclose(domain.starttime, start)
+        assert numpy.allclose(domain.starttime, start)
 
         # Check that domain.starttime isn't updated if later
@@ -972 +966 @@
                           domain,
                           quantities = ['Attribute0', 'Attribute1', 'Attribute2'])
-        assert allclose(domain.starttime, start+1)
+        assert numpy.allclose(domain.starttime, start+1)
 
         domain.starttime = start
@@ -990 +984 @@
 
             #Exact linear intpolation
-            assert allclose(q[0], 2*t)
+            assert numpy.allclose(q[0], 2*t)
             if i%6 == 0:
-                assert allclose(q[1], t**2)
-                assert allclose(q[2], sin(t*pi/600))
+                assert numpy.allclose(q[1], t**2)
+                assert numpy.allclose(q[2], sin(t*pi/600))
 
         #Check non-exact
@@ -999 +993 @@
         t = 90 #Halfway between 60 and 120
         q = F(t)
-        assert allclose( (120**2 + 60**2)/2, q[1] )
-        assert allclose( (sin(120*pi/600) + sin(60*pi/600))/2, q[2] )
+        assert numpy.allclose( (120**2 + 60**2)/2, q[1] )
+        assert numpy.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 allclose( 2*120**2/3 + 60**2/3, q[1] )
-        assert allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
+        assert numpy.allclose( 2*120**2/3 + 60**2/3, q[1] )
+        assert numpy.allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
 
         os.remove(filename + '.tms')
@@ -1055 +1049 @@
         F = file_function(filename + '.tms', domain,
                           quantities = ['Attribute0', 'Attribute1', 'Attribute2'])        
-        assert allclose(domain.starttime, start+delta)
+        assert numpy.allclose(domain.starttime, start+delta)
 
 
@@ -1066 +1060 @@
 
             #Exact linear intpolation
-            assert allclose(q[0], 2*t)
+            assert numpy.allclose(q[0], 2*t)
             if i%6 == 0:
-                assert allclose(q[1], t**2)
-                assert allclose(q[2], sin(t*pi/600))
+                assert numpy.allclose(q[1], t**2)
+                assert numpy.allclose(q[2], sin(t*pi/600))
 
         #Check non-exact
@@ -1075 +1069 @@
         t = 90 #Halfway between 60 and 120
         q = F(t-delta)
-        assert allclose( (120**2 + 60**2)/2, q[1] )
-        assert allclose( (sin(120*pi/600) + sin(60*pi/600))/2, q[2] )
+        assert numpy.allclose( (120**2 + 60**2)/2, q[1] )
+        assert numpy.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-delta)
-        assert allclose( 2*120**2/3 + 60**2/3, q[1] )
-        assert allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
+        assert numpy.allclose( 2*120**2/3 + 60**2/3, q[1] )
+        assert numpy.allclose( 2*sin(120*pi/600)/3 + sin(60*pi/600)/3, q[2] )
 
 
@@ -1094 +1088 @@
         #FIXME: Division is not expected to work for integers.
         #This must be caught.
-        foo = array([[1,2,3],
-                     [4,5,6]], float)
-
-        bar = array([[-1,0,5],
-                     [6,1,1]], float)                  
+        foo = numpy.array([[1,2,3], [4,5,6]], numpy.float)
+
+        bar = numpy.array([[-1,0,5], [6,1,1]], numpy.float)                  
 
         D = {'X': foo, 'Y': bar}
 
         Z = apply_expression_to_dictionary('X+Y', D)        
-        assert allclose(Z, foo+bar)
+        assert numpy.allclose(Z, foo+bar)
 
         Z = apply_expression_to_dictionary('X*Y', D)        
-        assert allclose(Z, foo*bar)        
+        assert numpy.allclose(Z, foo*bar)        
 
         Z = apply_expression_to_dictionary('4*X+Y', D)        
-        assert allclose(Z, 4*foo+bar)        
+        assert numpy.allclose(Z, 4*foo+bar)        
 
         # test zero division is OK
         Z = apply_expression_to_dictionary('X/Y', D)
-        assert allclose(1/Z, 1/(foo/bar)) # can't compare inf to inf
+        assert numpy.allclose(1/Z, 1/(foo/bar)) # can't compare inf to inf
 
         # make an error for zero on zero
@@ -1271 +1263 @@
         tris = [[0,1,2]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        assert alltrue(new_verts == verts)
-        assert alltrue(new_tris == tris)
+        assert numpy.alltrue(new_verts == verts)
+        assert numpy.alltrue(new_tris == tris)
      
 
@@ -1287 +1279 @@
         new_verts, new_tris = remove_lone_verts(verts, tris)
         #print "new_verts", new_verts
-        assert alltrue(new_verts == [[0,0],[1,0],[0,1]])
-        assert alltrue(new_tris == [[0,1,2]])
+        assert numpy.alltrue(new_verts == [[0,0],[1,0],[0,1]])
+        assert numpy.alltrue(new_tris == [[0,1,2]])
      
     def test_remove_lone_verts_c(self):
@@ -1294 +1286 @@
         tris = [[0,1,3]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        print "new_verts", new_verts
-        assert alltrue(new_verts == [[0,0],[1,0],[0,1]])
-        assert alltrue(new_tris == [[0,1,2]])
+        assert numpy.alltrue(new_verts == [[0,0],[1,0],[0,1]])
+        assert numpy.alltrue(new_tris == [[0,1,2]])
         
     def test_remove_lone_verts_b(self):
@@ -1302 +1293 @@
         tris = [[0,1,2]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        assert alltrue(new_verts == verts[0:3])
-        assert alltrue(new_tris == tris)
+        assert numpy.alltrue(new_verts == verts[0:3])
+        assert numpy.alltrue(new_tris == tris)
      
 
@@ -1310 +1301 @@
         tris = [[0,1,2]]
         new_verts, new_tris = remove_lone_verts(verts, tris)
-        assert alltrue(new_verts == verts[0:3])
-        assert alltrue(new_tris == tris)
+        assert numpy.alltrue(new_verts == verts[0:3])
+        assert numpy.alltrue(new_tris == tris)
         
     def test_get_min_max_values(self):
@@ -1499 +1490 @@
             line.append([float(row[0]),float(row[1]),float(row[2]),float(row[3]),float(row[4]),float(row[5])])
             #print 'assert line',line[i],'point1',point1_answers_array[i]
-            assert allclose(line[i], point1_answers_array[i])
+            assert numpy.allclose(line[i], point1_answers_array[i])
 
         point2_answers_array = [[0.0,1.0,1.5,-0.5,3.0,4.0], [2.0,10.0,10.5,-0.5,3.0,4.0]]
@@ -1512 +1503 @@
             line.append([float(row[0]),float(row[1]),float(row[2]),float(row[3]),float(row[4]),float(row[5])])
             #print 'assert line',line[i],'point1',point1_answers_array[i]
-            assert allclose(line[i], point2_answers_array[i])
+            assert numpy.allclose(line[i], point2_answers_array[i])
                          
         # clean up
@@ -1618 +1609 @@
             line.append([float(row[0]),float(row[1]),float(row[2])])
             #print 'line',line[i],'point1',point1_answers_array[i]
-            assert allclose(line[i], point1_answers_array[i])
+            assert numpy.allclose(line[i], point1_answers_array[i])
 
         point2_answers_array = [[0.0,1.0,-0.5], [2.0,10.0,-0.5]]
@@ -1631 +1622 @@
             line.append([float(row[0]),float(row[1]),float(row[2])])
 #            print 'line',line[i],'point1',point1_answers_array[i]
-            assert allclose(line[i], point2_answers_array[i])
+            assert numpy.allclose(line[i], point2_answers_array[i])
                          
         # clean up
@@ -1737 +1728 @@
             line.append([float(row[0]),float(row[1]),float(row[2]),float(row[3]),float(row[4]),float(row[5])])
             #print 'assert line',line[i],'point1',point1_answers_array[i]
-            assert allclose(line[i], point1_answers_array[i])
+            assert numpy.allclose(line[i], point1_answers_array[i])
 
         point2_answers_array = [[5.0,1.0,1.5,-0.5,3.0,4.0], [7.0,10.0,10.5,-0.5,3.0,4.0]]
@@ -1750 +1741 @@
             line.append([float(row[0]),float(row[1]),float(row[2]),float(row[3]),float(row[4]),float(row[5])])
             #print 'assert line',line[i],'point1',point1_answers_array[i]
-            assert allclose(line[i], point2_answers_array[i])
+            assert numpy.allclose(line[i], point2_answers_array[i])
                          
         # clean up
@@ -1833 +1824 @@
 if __name__ == "__main__":
     suite = unittest.makeSuite(Test_Util,'test')
-#    suite = unittest.makeSuite(Test_Util,'test_sww2csv')
+#    suite = unittest.makeSuite(Test_Util,'test_spatio_temporal_file_function_basic')
 #    runner = unittest.TextTestRunner(verbosity=2)
     runner = unittest.TextTestRunner(verbosity=1)

anuga_core/source_numpy_conversion/anuga/abstract_2d_finite_volumes/util.py

@@ -1 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 """This module contains various auxiliary function used by pyvolution.
 
@@ -17 +15 @@
 
 from anuga.utilities.numerical_tools import ensure_numeric
-from numpy.oldnumeric import arange, choose, zeros, Float, array, allclose, take, compress
+import numpy
     
 from anuga.geospatial_data.geospatial_data import ensure_absolute
@@ -239 +237 @@
     from anuga.config import time_format
     from Scientific.IO.NetCDF import NetCDFFile
-    from numpy.oldnumeric import array, zeros, Float, alltrue, concatenate, reshape
+##    from numpy.oldnumeric import array, zeros, Float, alltrue, concatenate, reshape
 
     # Open NetCDF file
@@ -305 +303 @@
     # Get variables
     # if verbose: print 'Get variables'    
-    time = array(fid.variables['time'][:]    )
+    time = numpy.array(fid.variables['time'][:]    )
 
     # Get time independent stuff
@@ -319 +317 @@
             triangles = fid.variables['volumes'][:]
 
-        x = reshape(x, (len(x),1))
-        y = reshape(y, (len(y),1))
-        vertex_coordinates = concatenate((x,y), axis=1) #m x 2 array
+        x = numpy.reshape(x, (len(x),1))
+        y = numpy.reshape(y, (len(y),1))
+        vertex_coordinates = numpy.concatenate((x,y), axis=1) #m x 2 array
 
         if boundary_polygon is not None:
@@ -333 +331 @@
             for i in range(len(boundary_polygon)):
                 for j in range(len(x)):
-                    if allclose(vertex_coordinates[j],boundary_polygon[i],1e-4):
+                    if numpy.allclose(vertex_coordinates[j],boundary_polygon[i],1e-4):
                         #FIX ME:
                         #currently gauges lat and long is stored as float and
@@ -353 +351 @@
                 gauge_neighbour_id.append(-1)
             gauge_neighbour_id=ensure_numeric(gauge_neighbour_id)
-            if len(compress(gauge_neighbour_id>=0,gauge_neighbour_id))!=len(temp)-1:
+            if len(numpy.compress(gauge_neighbour_id>=0,gauge_neighbour_id))!=len(temp)-1:
                 msg='incorrect number of segments'
                 raise msg
@@ -404 +402 @@
         if boundary_polygon is not None:
             #removes sts points that do not lie on boundary
-            quantities[name] = take(quantities[name],gauge_id,1)
+            quantities[name] = numpy.take(quantities[name], gauge_id, 1)
             
     # Close sww, tms or sts netcdf file         
@@ -526 +524 @@
                 raise 'Illegal input to get_textual_float:', value
         else:
-            return format %float(value)
+            return format % float(value)
 
 
@@ -1042 +1040 @@
     """
 #    from math import sqrt, atan, degrees
-    from numpy.oldnumeric import ones, allclose, zeros, Float, ravel
+##    from numpy.oldnumeric import ones, allclose, zeros, Float, ravel
     from os import sep, altsep, getcwd, mkdir, access, F_OK, environ
 
@@ -1083 +1081 @@
     n0 = int(n0)
     m = len(locations)
-    model_time = zeros((n0,m,p), Float) 
-    stages = zeros((n0,m,p), Float)
-    elevations = zeros((n0,m,p), Float) 
-    momenta = zeros((n0,m,p), Float)
-    xmom = zeros((n0,m,p), Float)
-    ymom = zeros((n0,m,p), Float)
-    speed = zeros((n0,m,p), Float)
-    bearings = zeros((n0,m,p), Float)
-    due_east = 90.0*ones((n0,1), Float)
-    due_west = 270.0*ones((n0,1), Float)
-    depths = zeros((n0,m,p), Float)
-    eastings = zeros((n0,m,p), Float)
+    model_time = numpy.zeros((n0,m,p), numpy.float) 
+    stages = numpy.zeros((n0,m,p), numpy.float)
+    elevations = numpy.zeros((n0,m,p), numpy.float) 
+    momenta = numpy.zeros((n0,m,p), numpy.float)
+    xmom = numpy.zeros((n0,m,p), numpy.float)
+    ymom = numpy.zeros((n0,m,p), numpy.float)
+    speed = numpy.zeros((n0,m,p), numpy.float)
+    bearings = numpy.zeros((n0,m,p), numpy.float)
+    due_east = 90.0*numpy.ones((n0,1), numpy.float)
+    due_west = 270.0*numpy.ones((n0,1), numpy.float)
+    depths = numpy.zeros((n0,m,p), numpy.float)
+    eastings = numpy.zeros((n0,m,p), numpy.float)
     min_stages = []
     max_stages = []
@@ -1106 +1104 @@
     min_speeds = []    
     max_depths = []
-    model_time_plot3d = zeros((n0,m), Float)
-    stages_plot3d = zeros((n0,m), Float)
-    eastings_plot3d = zeros((n0,m),Float)
+    model_time_plot3d = numpy.zeros((n0,m), numpy.float)
+    stages_plot3d = numpy.zeros((n0,m), numpy.float)
+    eastings_plot3d = numpy.zeros((n0,m),numpy.float)
     if time_unit is 'mins': scale = 60.0
     if time_unit is 'hours': scale = 3600.0
@@ -1208 +1206 @@
                 else:
                     #ax.plot_wireframe(model_time[:,:,j],eastings[:,:,j],stages[:,:,j])
-                    ax.plot3D(ravel(eastings[:,:,j]),ravel(model_time[:,:,j]),ravel(stages[:,:,j]))
+                    ax.plot3D(numpy.ravel(eastings[:,:,j]),numpy.ravel(model_time[:,:,j]),numpy.ravel(stages[:,:,j]))
                 ax.set_xlabel('time')
                 ax.set_ylabel('x')
@@ -1507 +1505 @@
     
     # initialise the array to easily find the index of the first loner
-    loners=arange(2*N, N, -1) # if N=3 [6,5,4]
+    loners=numpy.arange(2*N, N, -1) # if N=3 [6,5,4]
     for t in triangles:
         for vert in t:
@@ -1541 +1539 @@
         #print "loners", loners
         #print "triangles before", triangles
-        triangles = choose(triangles,loners)
+        triangles = numpy.choose(triangles,loners)
         #print "triangles after", triangles
     return verts, triangles
@@ -1556 +1554 @@
 
         
-    xc = zeros(triangles.shape[0], Float) # Space for centroid info
+    xc = numpy.zeros(triangles.shape[0], numpy.float) # Space for centroid info
     
     for k in range(triangles.shape[0]):
@@ -1838 +1836 @@
                 #add tide to stage if provided
                 if quantity == 'stage':
-                     quantity_value[quantity]=array(quantity_value[quantity])+directory_add_tide
+                     quantity_value[quantity]=numpy.array(quantity_value[quantity])+directory_add_tide
 
                 #condition to find max and mins for all the plots
@@ -1949 +1947 @@
             #get data from dict in to list
             #do maths to list by changing to array
-            t=(array(directory_quantity_value[directory][filename]['time'])+directory_start_time)/seconds_in_minutes
+            t=(numpy.array(directory_quantity_value[directory][filename]['time'])+directory_start_time)/seconds_in_minutes
 
             #finds the maximum elevation, used only as a test
@@ -2130 +2128 @@
     from csv import reader,writer
     from anuga.utilities.numerical_tools import ensure_numeric, mean, NAN
-    from numpy.oldnumeric import array, resize, shape, Float, zeros, take, argsort, argmin
+##    from numpy.oldnumeric import array, resize, shape, Float, zeros, take, argsort, argmin
     import string
     from anuga.shallow_water.data_manager import get_all_swwfiles
@@ -2171 +2169 @@
         
     #convert to array for file_function
-    points_array = array(points,Float)
+    points_array = numpy.array(points, numpy.float)
         
     points_array = ensure_absolute(points_array)