Index: /anuga_core/source_numpy_conversion/anuga/utilities/cg_solve.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/cg_solve.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/cg_solve.py	(revision 5902)
@@ -4,6 +4,5 @@
 class ConvergenceError(exceptions.Exception): pass
 
-##from numpy.oldnumeric import dot, array, Float, zeros
-from numpy import dot, array, float, zeros
+import numpy
    
 import logging, logging.config
@@ -26,9 +25,9 @@
     
     if x0 is None:
-        x0 = zeros(b.shape, dtype=float)
+        x0 = numpy.zeros(b.shape, dtype=numpy.float)
     else:
-        x0 = array(x0, dtype=float)
+        x0 = numpy.array(x0, dtype=numpy.float)
 
-    b  = array(b, dtype=float)
+    b  = numpy.array(b, dtype=numpy.float)
     if len(b.shape) != 1 :
        
@@ -59,12 +58,12 @@
 
 
-   b  = array(b, dtype=float)
+   b  = numpy.array(b, dtype=numpy.float)
    if len(b.shape) != 1 :
       raise VectorShapeError, 'input vector should consist of only one column'
 
    if x0 is None:
-      x0 = zeros(b.shape, dtype=float)
+      x0 = numpy.zeros(b.shape, dtype=numpy.float)
    else:
-      x0 = array(x0, dtype=float)
+      x0 = numpy.array(x0, dtype=numpy.float)
 
 
@@ -77,10 +76,10 @@
    r = b - A*x
    d = r
-   rTr = dot(r,r)
+   rTr = numpy.dot(r,r)
    rTr0 = rTr
 
    while (i<imax and rTr>tol**2*rTr0):
        q = A*d
-       alpha = rTr/dot(d,q)
+       alpha = rTr/numpy.dot(d,q)
        x = x + alpha*d
        if i%50 :
@@ -89,5 +88,5 @@
            r = r - alpha*q
        rTrOld = rTr
-       rTr = dot(r,r)
+       rTr = numpy.dot(r,r)
        bt = rTr/rTrOld
 
Index: /anuga_core/source_numpy_conversion/anuga/utilities/compile.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/compile.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/compile.py	(revision 5902)
@@ -12,12 +12,8 @@
 
 #NumPy ------------------------------------
-# these lines recommended in "Converting from NUMARRAY to NUMPY"
+# Something like these lines recommended in "Converting from NUMARRAY to NUMPY"
 import numpy
-import numpy.numarray as nn
 numpyincludedirs = numpy.get_include()
-numarrayincludedirs = nn.get_numarray_include_dirs()
 I_dirs = '-I"%s" ' % numpyincludedirs
-for d in numarrayincludedirs:
-    I_dirs += '-I"%s" ' % d
 #NumPy ------------------------------------
 
Index: /anuga_core/source_numpy_conversion/anuga/utilities/interp.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/interp.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/interp.py	(revision 5902)
@@ -1,4 +1,2 @@
-## Automatically adapted for numpy.oldnumeric Oct 28, 2008 by alter_code1.py
-
 #!/usr/bin/python -tt
 #=======================================================================
@@ -140,6 +138,4 @@
     """
     import arrayfns
-##    import numpy.oldnumeric.ma as MA
-##    import numpy.oldnumeric as N
     import numpy.ma as MA
     import numpy as N
Index: /anuga_core/source_numpy_conversion/anuga/utilities/numerical_tools.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/numerical_tools.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/numerical_tools.py	(revision 5902)
@@ -7,22 +7,11 @@
 from warnings import warn
 
-#Establish which Numeric package to use
-#(this should move to somewhere central)
-#try:
-#    from scipy import ArrayType, array, sum, innerproduct, ravel, sqrt,
-# searchsorted, sort, concatenate, Float, arange    
-#except:
-#    #print 'Could not find scipy - using Numeric'
-#    from numpy.oldnumeric import ArrayType, array, sum, innerproduct, ravel, sqrt,
-#searchsorted, sort, concatenate, Float, arange
-
-##from numpy.oldnumeric import ArrayType, array, sum, innerproduct, ravel, sqrt,\
-##     searchsorted, sort, concatenate, Float, arange    
-from numpy import ndarray, array, sum, inner, ravel, sqrt, searchsorted, sort, concatenate, float, arange    
+##from numpy import ndarray, array, sum, inner, ravel, sqrt, searchsorted, sort, concatenate, float, arange
+import numpy
 
 # Getting an infinite number to use when using Numeric
 #INF = (array([1])/0.)[0]
 
-NAN = (array([1])/0.)[0]
+NAN = (numpy.array([1])/0.)[0]
 # Note, INF is used instead of NAN (Not a number), since Numeric has no NAN
 # if we use a package that has NAN, this should be updated to use NAN.
@@ -90,14 +79,14 @@
         v2 = [1.0, 0.0] # Unit vector along the x-axis
 	
-    v1 = ensure_numeric(v1, float)
-    v2 = ensure_numeric(v2, float)    
+    v1 = ensure_numeric(v1, numpy.float)
+    v2 = ensure_numeric(v2, numpy.float)    
     
     # Normalise
-    v1 = v1/sqrt(sum(v1**2))
-    v2 = v2/sqrt(sum(v2**2))
+    v1 = v1/numpy.sqrt(numpy.sum(v1**2))
+    v2 = v2/numpy.sqrt(numpy.sum(v2**2))
 
     # Compute angle
-    p = inner(v1, v2)
-    c = inner(v1, normal_vector(v2)) # Projection onto normal
+    p = numpy.inner(v1, v2)
+    c = numpy.inner(v1, normal_vector(v2)) # Projection onto normal
                                             # (negative cross product)
         
@@ -141,5 +130,5 @@
     """
     
-    return array([-v[1], v[0]], float)
+    return numpy.array([-v[1], v[0]], numpy.float)
 
     
@@ -151,5 +140,5 @@
     """Mean value of a vector
     """
-    return(float(sum(x))/len(x))
+    return(float(numpy.sum(x))/len(x))
 
 
@@ -172,5 +161,5 @@
     cy = y - mean(y)  
 
-    p = inner(cx,cy)/N
+    p = numpy.inner(cx,cy)/N
     return(p)
 
@@ -221,6 +210,6 @@
     """
   
-    y = ravel(x)
-    p = sqrt(inner(y,y))
+    y = numpy.ravel(x)
+    p = numpy.sqrt(numpy.inner(y,y))
     return p
     
@@ -264,22 +253,22 @@
     if typecode is None:
 ##NumPy        if isinstance(A, ArrayType):
-        if type(A) == ndarray:
+        if type(A) == numpy.ndarray:
             return A
         else:
-            return array(A)
+            return numpy.array(A)
     else:
 ##NumPy        if isinstance(A, ArrayType):
-        if type(A) == ndarray:
+        if type(A) == numpy.ndarray:
 ##NumPy            if A.typecode == typecode:
             if A.dtype == typecode:
-                return array(A)  #FIXME: Shouldn't this just return A?
+                return numpy.array(A)  #FIXME: Shouldn't this just return A?
             else:
-                return array(A, typecode)
+                return numpy.array(A, typecode)
         else:
             import types                            ##
             from numpy import str                   ##
             if isinstance(A, types.StringType):     ##
-                return array(A, dtype=int)          ##
-            return array(A, typecode)
+                return numpy.array(A, dtype=int)          ##
+            return numpy.array(A, typecode)
 
 
@@ -292,11 +281,11 @@
     """
 
-    n = searchsorted(sort(a), bins)
-    n = concatenate( [n, [len(a)]] )
+    n = numpy.searchsorted(numpy.sort(a), bins)
+    n = numpy.concatenate( [n, [len(a)]] )
 
     hist = n[1:]-n[:-1]
 
     if relative is True:
-        hist = hist/float(sum(hist))
+        hist = hist/float(numpy.sum(hist))
         
     return hist 
@@ -308,14 +297,14 @@
     """
 
-    mx = max(data)
-    mn = min(data)
+    mx = numpy.max(data)
+    mn = numpy.min(data)
 
     if mx == mn:
-        bins = array([mn])
+        bins = numpy.array([mn])
     else:
         if number_of_bins is None:
             number_of_bins = 10
             
-        bins = arange(mn, mx, (mx-mn)/number_of_bins)
+        bins = numpy.arange(mn, mx, (mx-mn)/number_of_bins)
 
     return bins
Index: /anuga_core/source_numpy_conversion/anuga/utilities/polygon.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/polygon.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/polygon.py	(revision 5902)
@@ -10,5 +10,6 @@
 #    #print 'Could not find scipy - using Numeric'
 
-from numpy import float, int, zeros, ones, array, concatenate, reshape, dot, allclose, newaxis, ascontiguousarray
+##from numpy import float, int, zeros, ones, array, concatenate, reshape, dot, allclose, newaxis, ascontiguousarray
+import numpy
 
 
@@ -76,6 +77,6 @@
     # FIXME (Ole): Write this in C
 
-    line0 = ensure_numeric(line0, float)
-    line1 = ensure_numeric(line1, float)    
+    line0 = ensure_numeric(line0, numpy.float)
+    line1 = ensure_numeric(line1, numpy.float)    
 
     x0 = line0[0,0]; y0 = line0[0,1]
@@ -89,8 +90,8 @@
     u1 = (x2-x0)*(y1-y0) - (y2-y0)*(x1-x0)
         
-    if allclose(denom, 0.0):
+    if numpy.allclose(denom, 0.0):
         # Lines are parallel - check if they coincide on a shared a segment
 
-        if allclose( [u0, u1], 0.0 ):
+        if numpy.allclose( [u0, u1], 0.0 ):
             # We now know that the lines if continued coincide
             # The remaining check will establish if the finite lines share a segment
@@ -120,9 +121,9 @@
             if line0_starts_on_line1 and line0_ends_on_line1:
                 # Shared segment is line0 fully included in line1
-                segment = array([[x0, y0], [x1, y1]])                
+                segment = numpy.array([[x0, y0], [x1, y1]])                
 
             if line1_starts_on_line0 and line1_ends_on_line0:
                 # Shared segment is line1 fully included in line0
-                segment = array([[x2, y2], [x3, y3]])
+                segment = numpy.array([[x2, y2], [x3, y3]])
             
 
@@ -130,9 +131,9 @@
             if line0_starts_on_line1 and line1_ends_on_line0:
                 # Shared segment from line0 start to line 1 end
-                segment = array([[x0, y0], [x3, y3]])
+                segment = numpy.array([[x0, y0], [x3, y3]])
 
             if line1_starts_on_line0 and line0_ends_on_line1:
                 # Shared segment from line1 start to line 0 end
-                segment = array([[x2, y2], [x1, y1]])                                
+                segment = numpy.array([[x2, y2], [x1, y1]])                                
 
 
@@ -140,9 +141,9 @@
             if line0_starts_on_line1 and line1_starts_on_line0:
                 # Shared segment from line0 start to line 1 end
-                segment = array([[x0, y0], [x2, y2]])
+                segment = numpy.array([[x0, y0], [x2, y2]])
 
             if line0_ends_on_line1 and line1_ends_on_line0:
                 # Shared segment from line0 start to line 1 end
-                segment = array([[x3, y3], [x1, y1]])                
+                segment = numpy.array([[x3, y3], [x1, y1]])                
 
                 
@@ -161,6 +162,6 @@
 
         # Sanity check - can be removed to speed up if needed
-        assert allclose(x, x2 + u1*(x3-x2))
-        assert allclose(y, y2 + u1*(y3-y2))        
+        assert numpy.allclose(x, x2 + u1*(x3-x2))
+        assert numpy.allclose(y, y2 + u1*(y3-y2))        
 
         # Check if point found lies within given line segments
@@ -168,5 +169,5 @@
             # We have intersection
 
-            return 1, array([x, y])
+            return 1, numpy.array([x, y])
         else:
             # No intersection
@@ -203,6 +204,6 @@
 
 
-    line0 = ensure_numeric(line0, float)
-    line1 = ensure_numeric(line1, float)    
+    line0 = ensure_numeric(line0, numpy.float)
+    line1 = ensure_numeric(line1, numpy.float)    
 
     status, value = _intersection(line0[0,0], line0[0,1],
@@ -270,5 +271,5 @@
     if len(points.shape) == 1:
         # Only one point was passed in. Convert to array of points
-    	points = reshape(points, (1,2))
+    	points = numpy.reshape(points, (1,2))
 
     indices, count = separate_points_by_polygon(points, polygon,
@@ -312,5 +313,5 @@
     #if verbose: print 'Checking input to outside_polygon'
     try:
-        points = ensure_numeric(points, float)
+        points = ensure_numeric(points, numpy.float)
     except NameError, e:
         raise NameError, e
@@ -320,5 +321,5 @@
 
     try:
-        polygon = ensure_numeric(polygon, float)
+        polygon = ensure_numeric(polygon, numpy.float)
     except NameError, e:
         raise NameError, e
@@ -330,5 +331,5 @@
     if len(points.shape) == 1:
         # Only one point was passed in. Convert to array of points
-    	points = reshape(points, (1,2))
+    	points = numpy.reshape(points, (1,2))
 
     indices, count = separate_points_by_polygon(points, polygon,
@@ -339,5 +340,5 @@
     if count == len(indices):
         # No points are outside
-        return array([])
+        return numpy.array([])
     else:
         return indices[count:][::-1]  #return reversed
@@ -354,5 +355,5 @@
     #if verbose: print 'Checking input to outside_polygon'
     try:
-        points = ensure_numeric(points, float)
+        points = ensure_numeric(points, numpy.float)
     except NameError, e:
         raise NameError, e
@@ -362,5 +363,5 @@
 
     try:
-        polygon = ensure_numeric(polygon, float)
+        polygon = ensure_numeric(polygon, numpy.float)
     except NameError, e:
         raise NameError, e
@@ -371,5 +372,5 @@
     if len(points.shape) == 1:
         # Only one point was passed in. Convert to array of points
-    	points = reshape(points, (1,2))
+    	points = numpy.reshape(points, (1,2))
 
 
@@ -441,6 +442,6 @@
 ##    print 'Before: points=%s, flags=%s' % (type(points), str(points.flags))
     try:
-##        points = ascontiguousarray(ensure_numeric(points, float))
-        points = ensure_numeric(points, float)
+##        points = numpy.ascontiguousarray(ensure_numeric(points, numpy.float))
+        points = ensure_numeric(points, numpy.float)
     except NameError, e:
         raise NameError, e
@@ -452,6 +453,6 @@
     #if verbose: print 'Checking input to separate_points_by_polygon 2'
     try:
-##        polygon = ascontiguousarray(ensure_numeric(polygon, float))
-        polygon = ensure_numeric(polygon, float)
+##        polygon = numpy.ascontiguousarray(ensure_numeric(polygon, numpy.float))
+        polygon = ensure_numeric(polygon, numpy.float)
     except NameError, e:
         raise NameError, e
@@ -475,5 +476,5 @@
         # Only one point was passed in.
         # Convert to array of points
-        points = reshape(points, (1,2))
+        points = numpy.reshape(points, (1,2))
 
     
@@ -494,5 +495,5 @@
 
 
-    indices = zeros( M, int )
+    indices = numpy.zeros( M, numpy.int )
 
     count = _separate_points_by_polygon(points, polygon, indices,
@@ -621,5 +622,5 @@
 
     try:
-        polygon = ensure_numeric(polygon, float)
+        polygon = ensure_numeric(polygon, numpy.float)
     except NameError, e:
         raise NameError, e
@@ -630,6 +631,6 @@
     x = polygon[:,0]
     y = polygon[:,1]
-    x = concatenate((x, [polygon[0,0]]), axis = 0)
-    y = concatenate((y, [polygon[0,1]]), axis = 0)
+    x = numpy.concatenate((x, [polygon[0,0]]), axis = 0)
+    y = numpy.concatenate((y, [polygon[0,1]]), axis = 0)
     
     return x, y
@@ -732,6 +733,6 @@
 
     def __call__(self, x, y):
-	x = array(x).astype(float)
-	y = array(y).astype(float)
+	x = numpy.array(x).astype(numpy.float)
+	y = numpy.array(y).astype(numpy.float)
 
         assert len(x.shape) == 1 and len(y.shape) == 1
@@ -740,10 +741,10 @@
 	assert y.shape[0] == N
 
-	points = ascontiguousarray(concatenate( (x[:,newaxis], y[:,newaxis]), axis=1 ))
+	points = numpy.ascontiguousarray(numpy.concatenate( (x[:,numpy.newaxis], y[:,numpy.newaxis]), axis=1 ))
 	
 	if callable(self.default):
 	    z = self.default(x, y)
 	else:
-	    z = ones(N, float) * self.default
+	    z = numpy.ones(N, numpy.float) * self.default
 
 	for polygon, value in self.regions:
@@ -753,6 +754,6 @@
 	    if callable(value):
 	        for i in indices:
-		    xx = array([x[i]])
-		    yy = array([y[i]])
+		    xx = numpy.array([x[i]])
+		    yy = numpy.array([y[i]])
                     z[i] = value(xx, yy)[0]
 	    else:
Index: /anuga_core/source_numpy_conversion/anuga/utilities/quad.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/quad.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/quad.py	(revision 5902)
@@ -223,8 +223,6 @@
             triangles = {}
             verts = self.retrieve_vertices()
-            print "verts", verts
             for vert in verts:
                 triangle_list = self.mesh.get_triangles_and_vertices_per_node(vert)
-                print 'triangle_list=%s' % str(triangle_list)
                 for k, _ in triangle_list:
                     if not triangles.has_key(k):
@@ -436,7 +434,4 @@
     """
 
-    from numpy import minimum, maximum
-
-
     #Make root cell
     #print mesh.coordinates
Index: /anuga_core/source_numpy_conversion/anuga/utilities/sparse.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/sparse.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/sparse.py	(revision 5902)
@@ -3,4 +3,5 @@
 """
 
+import numpy
 
 class Sparse:
@@ -18,7 +19,6 @@
             
         if len(args) == 1:
-            from numpy import array
             try:
-                A = array(args[0])
+                A = numpy.array(args[0])
             except:
                 raise 'Input must be convertable to a Numeric array'
@@ -93,7 +93,5 @@
 
     def todense(self):
-        from numpy import zeros, float
-
-        D = zeros( (self.M, self.N), float)
+        D = numpy.zeros( (self.M, self.N), numpy.float)
         
         for i in range(self.M):
@@ -110,8 +108,6 @@
         """
 
-        from numpy import array, zeros, float
-        
         try:
-            B = array(other)
+            B = numpy.array(other)
         except:
             msg = 'FIXME: Only Numeric types implemented so far'
@@ -131,5 +127,5 @@
             assert B.shape[0] == self.N, msg
 
-            R = zeros(self.M, float) #Result
+            R = numpy.zeros(self.M, numpy.float) #Result
 	    
             # Multiply nonzero elements
@@ -141,5 +137,5 @@
 	
             
-            R = zeros((self.M, B.shape[1]), float) #Result matrix
+            R = numpy.zeros((self.M, B.shape[1]), numpy.float) #Result matrix
 
             # Multiply nonzero elements
@@ -197,8 +193,6 @@
         """
 
-        from numpy import array, zeros, float
-        
         try:
-            B = array(other)
+            B = numpy.array(other)
         except:
             print 'FIXME: Only Numeric types implemented so far'
@@ -211,5 +205,5 @@
             assert B.shape[0] == self.M, 'Mismatching dimensions'
 
-            R = zeros((self.N,), float) #Result
+            R = numpy.zeros((self.N,), numpy.float) #Result
 
             #Multiply nonzero elements
@@ -248,6 +242,4 @@
         """
 
-        from numpy import zeros, float, int
-
         if isinstance(A,Sparse):
 
@@ -255,7 +247,7 @@
             keys.sort()
             nnz = len(keys)
-            data    = zeros ( (nnz,), float)
-            colind  = zeros ( (nnz,), int)
-            row_ptr = zeros ( (A.M+1,), int)
+            data    = numpy.zeros ( (nnz,), numpy.float)
+            colind  = numpy.zeros ( (nnz,), numpy.int)
+            row_ptr = numpy.zeros ( (A.M+1,), numpy.int)
             current_row = -1
             k = 0
@@ -295,7 +287,6 @@
 
     def todense(self):
-        from numpy.oldnumeric import zeros, Float
-
-        D = zeros( (self.M, self.N), Float)
+
+        D = numpy.zeros( (self.M, self.N), numpy.float)
         
         for i in range(self.M):
@@ -310,8 +301,6 @@
         """
 
-        from numpy.oldnumeric import array, zeros, Float
-        
         try:
-            B = array(other)
+            B = numpy.array(other)
         except:
             print 'FIXME: Only Numeric types implemented so far'
@@ -329,7 +318,4 @@
 if __name__ == '__main__':
     # A little selftest
-    
-    from numpy.oldnumeric import allclose, array, Float 
-    
     A = Sparse(3,3)
 
@@ -362,15 +348,15 @@
     u = A*v
     print u
-    assert allclose(u, [6,14,4])
+    assert numpy.allclose(u, [6,14,4])
 
     u = A.trans_mult(v)
     print u
-    assert allclose(u, [6,6,10])
+    assert numpy.allclose(u, [6,6,10])
 
     #Right hand side column
-    v = array([[2,4],[3,4],[4,4]])
+    v = numpy.array([[2,4],[3,4],[4,4]])
 
     u = A*v[:,0]
-    assert allclose(u, [6,14,4])
+    assert numpy.allclose(u, [6,14,4])
 
     #u = A*v[:,1]
Index: /anuga_core/source_numpy_conversion/anuga/utilities/test_cg_solve.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/test_cg_solve.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/test_cg_solve.py	(revision 5902)
@@ -5,6 +5,5 @@
 import unittest
 
-
-from numpy import dot, allclose, array, transpose, arange, ones, float
+import numpy
 from anuga.utilities.cg_solve import *
 from anuga.utilities.cg_solve import _conjugate_gradient
@@ -30,5 +29,5 @@
         x = conjugate_gradient(A,b,x,iprint=0)
 
-        assert allclose(x,xe)
+        assert numpy.allclose(x,xe)
 
     def test_max_iter(self):
@@ -61,5 +60,5 @@
         A = Sparse(n,n)
 
-        for i in arange(0,n):
+        for i in numpy.arange(0,n):
             A[i,i] = 1.0
             if i > 0 :
@@ -68,10 +67,10 @@
                 A[i,i+1] = -0.5
 
-        xe = ones( (n,), float)
+        xe = numpy.ones( (n,), numpy.float)
 
         b  = A*xe
         x = conjugate_gradient(A,b,b,tol=1.0e-5,iprint=1)
 
-        assert allclose(x,xe)
+        assert numpy.allclose(x,xe)
 
     def test_solve_large_2d(self):
@@ -83,6 +82,6 @@
         A = Sparse(m*n, m*n)
 
-        for i in arange(0,n):
-            for j in arange(0,m):
+        for i in numpy.arange(0,n):
+            for j in numpy.arange(0,m):
                 I = j+m*i
                 A[I,I] = 4.0
@@ -96,10 +95,10 @@
                     A[I,I+1] = -1.0
 
-        xe = ones( (n*m,), float)
+        xe = numpy.ones( (n*m,), numpy.float)
 
         b  = A*xe
         x = conjugate_gradient(A,b,b,iprint=0)
 
-        assert allclose(x,xe)
+        assert numpy.allclose(x,xe)
 
     def test_solve_large_2d_csr_matrix(self):
@@ -112,6 +111,6 @@
         A = Sparse(m*n, m*n)
 
-        for i in arange(0,n):
-            for j in arange(0,m):
+        for i in numpy.arange(0,n):
+            for j in numpy.arange(0,m):
                 I = j+m*i
                 A[I,I] = 4.0
@@ -125,5 +124,5 @@
                     A[I,I+1] = -1.0
 
-        xe = ones( (n*m,), float)
+        xe = numpy.ones( (n*m,), numpy.float)
 
         # Convert to csr format
@@ -134,5 +133,5 @@
         x = conjugate_gradient(A,b,b,iprint=20)
 
-        assert allclose(x,xe)
+        assert numpy.allclose(x,xe)
 
 
@@ -145,6 +144,6 @@
         A = Sparse(m*n, m*n)
 
-        for i in arange(0,n):
-            for j in arange(0,m):
+        for i in numpy.arange(0,n):
+            for j in numpy.arange(0,m):
                 I = j+m*i
                 A[I,I] = 4.0
@@ -158,10 +157,10 @@
                     A[I,I+1] = -1.0
 
-        xe = ones( (n*m,), float)
+        xe = numpy.ones( (n*m,), numpy.float)
 
         b  = A*xe
         x = conjugate_gradient(A,b)
 
-        assert allclose(x,xe)
+        assert numpy.allclose(x,xe)
 
 
@@ -202,5 +201,5 @@
         x = conjugate_gradient(A,b,x,iprint=0)
 
-        assert allclose(x,xe)
+        assert numpy.allclose(x,xe)
 
 #-------------------------------------------------------------
Index: /anuga_core/source_numpy_conversion/anuga/utilities/test_data_audit.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/test_data_audit.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/test_data_audit.py	(revision 5902)
@@ -3,5 +3,4 @@
 
 import unittest
-from numpy.oldnumeric import zeros, array, allclose
 from tempfile import mkstemp
 import os
Index: /anuga_core/source_numpy_conversion/anuga/utilities/test_numerical_tools.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/test_numerical_tools.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/test_numerical_tools.py	(revision 5902)
@@ -3,6 +3,5 @@
 
 import unittest
-from numpy import zeros, array, allclose
-from numpy import ndarray, float, int, array, alltrue
+import numpy
 
 from math import sqrt, pi
@@ -23,12 +22,12 @@
         """Test angles between one vector and the x-axis
 	"""
-        assert allclose(angle([1.0, 0.0])/pi*180, 0.0)	    
-        assert allclose(angle([1.0, 1.0])/pi*180, 45.0)
-        assert allclose(angle([0.0, 1.0])/pi*180, 90.0)		
-        assert allclose(angle([-1.0, 1.0])/pi*180, 135.0)		
-        assert allclose(angle([-1.0, 0.0])/pi*180, 180.0)
-        assert allclose(angle([-1.0, -1.0])/pi*180, 225.0)
-        assert allclose(angle([0.0, -1.0])/pi*180, 270.0)
-        assert allclose(angle([1.0, -1.0])/pi*180, 315.0)
+        assert numpy.allclose(angle([1.0, 0.0])/pi*180, 0.0)	    
+        assert numpy.allclose(angle([1.0, 1.0])/pi*180, 45.0)
+        assert numpy.allclose(angle([0.0, 1.0])/pi*180, 90.0)		
+        assert numpy.allclose(angle([-1.0, 1.0])/pi*180, 135.0)		
+        assert numpy.allclose(angle([-1.0, 0.0])/pi*180, 180.0)
+        assert numpy.allclose(angle([-1.0, -1.0])/pi*180, 225.0)
+        assert numpy.allclose(angle([0.0, -1.0])/pi*180, 270.0)
+        assert numpy.allclose(angle([1.0, -1.0])/pi*180, 315.0)
 		
 							  
@@ -37,30 +36,30 @@
 	"""    
 	
-        assert allclose(angle([1.0, 0.0], [1.0, 1.0])/pi*180, 315.0)
-        assert allclose(angle([1.0, 1.0], [1.0, 0.0])/pi*180, 45.0)
+        assert numpy.allclose(angle([1.0, 0.0], [1.0, 1.0])/pi*180, 315.0)
+        assert numpy.allclose(angle([1.0, 1.0], [1.0, 0.0])/pi*180, 45.0)
 		
-        assert allclose(angle([-1.0, -1.0], [1.0, 1.0])/pi*180, 180)	
-        assert allclose(angle([-1.0, -1.0], [-1.0, 1.0])/pi*180, 90.0)	
+        assert numpy.allclose(angle([-1.0, -1.0], [1.0, 1.0])/pi*180, 180)	
+        assert numpy.allclose(angle([-1.0, -1.0], [-1.0, 1.0])/pi*180, 90.0)	
 	
-        assert allclose(angle([-1.0, 0.0], [1.0, 1.0])/pi*180, 135.0)
-        assert allclose(angle([0.0, -1.0], [1.0, 1.0])/pi*180, 225.0)	
+        assert numpy.allclose(angle([-1.0, 0.0], [1.0, 1.0])/pi*180, 135.0)
+        assert numpy.allclose(angle([0.0, -1.0], [1.0, 1.0])/pi*180, 225.0)	
 	
-        assert allclose(angle([1.0, -1.0], [1.0, 1.0])/pi*180, 270.0)	
-        assert allclose(angle([1.0, 0.0], [0.0, 1.0])/pi*180, 270.0)
+        assert numpy.allclose(angle([1.0, -1.0], [1.0, 1.0])/pi*180, 270.0)	
+        assert numpy.allclose(angle([1.0, 0.0], [0.0, 1.0])/pi*180, 270.0)
 
         #From test_get_boundary_polygon_V
         v_prev = [-0.5, -0.5]
         vc = [ 0.0,  -0.5]
-        assert allclose(angle(vc, v_prev)/pi*180, 45.0)
+        assert numpy.allclose(angle(vc, v_prev)/pi*180, 45.0)
 
         vc = [ 0.5,  0.0]
-        assert allclose(angle(vc, v_prev)/pi*180, 135.0)
+        assert numpy.allclose(angle(vc, v_prev)/pi*180, 135.0)
 
         vc = [ -0.5,  0.5]
-        assert allclose(angle(vc, v_prev)/pi*180, 270.0)                
+        assert numpy.allclose(angle(vc, v_prev)/pi*180, 270.0)                
 
 
     def test_anglediff(self):
-        assert allclose(anglediff([0.0, 1.], [1.0, 1.0])/pi*180, 45.0)
+        assert numpy.allclose(anglediff([0.0, 1.], [1.0, 1.0])/pi*180, 45.0)
 
 	
@@ -68,5 +67,5 @@
         A = [1,2,3,4]
         B = ensure_numeric(A)
-        assert isinstance(B, ndarray)
+        assert isinstance(B, numpy.ndarray)
         assert B.dtype.char == 'l'
         assert B[0] == 1 and B[1] == 2 and B[2] == 3 and B[3] == 4
@@ -74,51 +73,51 @@
         A = [1,2,3.14,4]
         B = ensure_numeric(A)
-        assert isinstance(B, ndarray)
+        assert isinstance(B, numpy.ndarray)
         assert B.dtype.char == 'd'
         assert B[0] == 1 and B[1] == 2 and B[2] == 3.14 and B[3] == 4
 
         A = [1,2,3,4]
-        B = ensure_numeric(A, float)
-        assert isinstance(B, ndarray)
+        B = ensure_numeric(A, numpy.float)
+        assert isinstance(B, numpy.ndarray)
         assert B.dtype.char == 'd'
         assert B[0] == 1.0 and B[1] == 2.0 and B[2] == 3.0 and B[3] == 4.0
 
         A = [1,2,3,4]
-        B = ensure_numeric(A, float)
-        assert isinstance(B, ndarray)
+        B = ensure_numeric(A, numpy.float)
+        assert isinstance(B, numpy.ndarray)
         assert B.dtype.char == 'd'
         assert B[0] == 1.0 and B[1] == 2.0 and B[2] == 3.0 and B[3] == 4.0
 
-        A = array([1,2,3,4])
+        A = numpy.array([1,2,3,4])
         B = ensure_numeric(A)
-        assert isinstance(B, ndarray)
+        assert isinstance(B, numpy.ndarray)
         assert B.dtype.char == 'l'        
-        assert alltrue(A == B)    
+        assert numpy.alltrue(A == B)    
         assert A is B   #Same object
 
-        A = array([1,2,3,4])
-        B = ensure_numeric(A, float)
-        assert isinstance(B, ndarray)
+        A = numpy.array([1,2,3,4])
+        B = ensure_numeric(A, numpy.float)
+        assert isinstance(B, numpy.ndarray)
         assert B.dtype.char == 'd'        
-        assert alltrue(A == B)    
+        assert numpy.alltrue(A == B)    
         assert A is not B   #Not the same object
 
         # Check scalars
         A = 1
-        B = ensure_numeric(A, float)
+        B = ensure_numeric(A, numpy.float)
         #print A, B[0], len(B), type(B) 
         #print B.shape
-        assert alltrue(A == B)
-
-        B = ensure_numeric(A, int)        
+        assert numpy.alltrue(A == B)
+
+        B = ensure_numeric(A, numpy.int)        
         #print A, B
         #print B.shape
-        assert alltrue(A == B)
+        assert numpy.alltrue(A == B)
 
     def NO_test_ensure_numeric_char(self):
         # Error situation
-        B = ensure_numeric('hello', int)
+        B = ensure_numeric('hello', numpy.int)
         print 'B=%s %s' % (str(B), type(B))
-        assert allclose(B, [104, 101, 108, 108, 111])
+        assert numpy.allclose(B, [104, 101, 108, 108, 111])
 
 
@@ -209,39 +208,39 @@
         #There are four elements greater than or equal to 3
         bins = [3]
-        assert allclose(histogram(a, bins), [4])
+        assert numpy.allclose(histogram(a, bins), [4])
 
         bins = [ min(a) ]
-        assert allclose(histogram(a, bins), [len(a)])
+        assert numpy.allclose(histogram(a, bins), [len(a)])
 
         bins = [ max(a)+0.00001 ]
-        assert allclose(histogram(a, bins), [0])        
+        assert numpy.allclose(histogram(a, bins), [0])        
         
         bins = [1,2,3,4]
-        assert allclose(histogram(a, bins), [8,3,3,1])
+        assert numpy.allclose(histogram(a, bins), [8,3,3,1])
 
         bins = [1.1,2,3.1,4]
         #print histogram(a, bins)
-        assert allclose(histogram(a, bins), [0,6,0,1])
+        assert numpy.allclose(histogram(a, bins), [0,6,0,1])
 
         bins = [0,1.5,2,3]
-        assert allclose(histogram(a, bins), [8,0,3,4])
-        assert allclose(histogram(a, [0,3]), histogram(a, [-0.5,3]))
+        assert numpy.allclose(histogram(a, bins), [8,0,3,4])
+        assert numpy.allclose(histogram(a, [0,3]), histogram(a, [-0.5,3]))
 
         # Check situation with #bins >= #datapoints
         a = [1.7]
         bins = [0,1.5,2,3]
-        assert allclose(histogram(a, bins), [0,1,0,0])
+        assert numpy.allclose(histogram(a, bins), [0,1,0,0])
 
         a = [1.7]
         bins = [0]
-        assert allclose(histogram(a, bins), [1])
+        assert numpy.allclose(histogram(a, bins), [1])
 
         a = [-1.7]
         bins = [0]
-        assert allclose(histogram(a, bins), [0])
+        assert numpy.allclose(histogram(a, bins), [0])
 
         a = [-1.7]
         bins = [-1.7]
-        assert allclose(histogram(a, bins), [1])        
+        assert numpy.allclose(histogram(a, bins), [1])        
         
 
Index: /anuga_core/source_numpy_conversion/anuga/utilities/test_polygon.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/test_polygon.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/test_polygon.py	(revision 5902)
@@ -3,5 +3,5 @@
 
 import unittest
-from numpy import zeros, array, allclose, alltrue
+import numpy
 from math import sqrt, pi
 from anuga.utilities.numerical_tools import ensure_numeric
@@ -45,10 +45,10 @@
 	f = Polygon_function( [(p1, 1.0)], verbose=False )
 	z = f([5, 5, 27, 35], [5, 9, 8, -5]) #Two first inside p1
-	assert allclose(z, [1,1,0,0])
+	assert numpy.allclose(z, [1,1,0,0])
 
 
 	f = Polygon_function( [(p2, 2.0)] )
 	z = f([5, 5, 27, 35], [5, 9, 8, -5]) # First and last inside p2
-	assert allclose(z, [2,0,0,2])
+	assert numpy.allclose(z, [2,0,0,2])
 
 
@@ -56,5 +56,5 @@
 	f = Polygon_function( [(p1, 1.0), (p2, 2.0)] )
 	z = f([5, 5, 27, 35], [5, 9, 8, -5])
-	assert allclose(z, [2,1,0,2])
+	assert numpy.allclose(z, [2,1,0,2])
 
 
@@ -79,5 +79,5 @@
         z = f([430000,480000], [490000,7720000]) # first outside, second inside
         
-        assert allclose(z, [0,10])
+        assert numpy.allclose(z, [0,10])
 
     def test_polygon_function_georef(self):
@@ -97,10 +97,10 @@
 	z = f([5, 5, 27, 35], [5, 9, 8, -5]) #Two first inside p1
 
-	assert allclose(z, [1,1,0,0])
+	assert numpy.allclose(z, [1,1,0,0])
 
 
 	f = Polygon_function( [(p2, 2.0)], geo_reference=geo)
 	z = f([5, 5, 27, 35], [5, 9, 8, -5]) #First and last inside p2
-	assert allclose(z, [2,0,0,2])
+	assert numpy.allclose(z, [2,0,0,2])
 
 
@@ -108,5 +108,5 @@
 	f = Polygon_function( [(p1, 1.0), (p2, 2.0)], geo_reference=geo)
 	z = f([5, 5, 27, 35], [5, 9, 8, -5])
-	assert allclose(z, [2,1,0,2])
+	assert numpy.allclose(z, [2,1,0,2])
 
 
@@ -114,5 +114,5 @@
 	f = Polygon_function( [(p1, 1.0), (p2, 2.0)])
 	z = f([5, 5, 27, 35], [5, 9, 8, -5])
-	assert not allclose(z, [2,1,0,2])        
+	assert not numpy.allclose(z, [2,1,0,2])        
 
 
@@ -127,10 +127,10 @@
 	f = Polygon_function( [(p1, test_function)] )
 	z = f([5, 5, 27, 35], [5, 9, 8, -5]) #Two first inside p1
-	assert allclose(z, [10,14,0,0])
+	assert numpy.allclose(z, [10,14,0,0])
 
 	# Combined
 	f = Polygon_function( [(p1, test_function), (p2, 2.0)] )
 	z = f([5, 5, 27, 35], [5, 9, 8, -5])
-	assert allclose(z, [2,14,0,2])
+	assert numpy.allclose(z, [2,14,0,2])
 
 
@@ -138,5 +138,5 @@
 	f = Polygon_function( [(p1, test_function), (p2, 2.0)], default = 3.14)
 	z = f([5, 5, 27, 35], [5, 9, 8, -5])
-	assert allclose(z, [2,14,3.14,2])
+	assert numpy.allclose(z, [2,14,3.14,2])
 
 
@@ -145,5 +145,5 @@
 			      default = test_function)
 	z = f([5, 5, 27, 35], [5, 9, 8, -5])
-	assert allclose(z, [2,14,35,2])
+	assert numpy.allclose(z, [2,14,35,2])
 
 
@@ -217,5 +217,5 @@
 	res = inside_polygon(points, polygon)
 	assert len(res) == 2
-	assert allclose(res, [0,1])     ## alltrue?
+	assert numpy.allclose(res, [0,1])     ## alltrue?
 
 
@@ -312,5 +312,5 @@
 	res = inside_polygon( points, polygon, verbose=False )
 
-	assert allclose( res, [0,1,2] )
+	assert numpy.allclose( res, [0,1,2] )
 
     def test_outside_polygon(self):
@@ -324,5 +324,5 @@
         
         indices = outside_polygon( [[0.5, 0.5], [1, -0.5], [0.3, 0.2]], U )
-        assert allclose( indices, [1] )
+        assert numpy.allclose( indices, [1] )
         
         # One more test of vector formulation returning indices
@@ -331,5 +331,5 @@
 	res = outside_polygon( points, polygon )
 
-	assert allclose( res, [3, 4] )
+	assert numpy.allclose( res, [3, 4] )
 
 
@@ -339,5 +339,5 @@
 	res = outside_polygon( points, polygon )
 
-	assert allclose( res, [0, 4, 5] )        
+	assert numpy.allclose( res, [0, 4, 5] )        
      
     def test_outside_polygon2(self):
@@ -362,11 +362,11 @@
         #print indices, count
         assert count == 0 #None inside
-        assert allclose(indices, [3,2,1,0])
+        assert numpy.allclose(indices, [3,2,1,0])
 
         indices = outside_polygon(points, U, closed = True)
-        assert allclose(indices, [0,1,2,3])
+        assert numpy.allclose(indices, [0,1,2,3])
 
         indices = inside_polygon(points, U, closed = True)
-        assert allclose(indices, [])                
+        assert numpy.allclose(indices, [])                
 
 
@@ -382,11 +382,11 @@
         indices, count = separate_points_by_polygon(points, U)
         assert count == 3 #All inside
-        assert allclose(indices, [0,1,2])
+        assert numpy.allclose(indices, [0,1,2])
 
         indices = outside_polygon(points, U, closed = True)
-        assert allclose(indices, [])
+        assert numpy.allclose(indices, [])
 
         indices = inside_polygon(points, U, closed = True)
-        assert allclose(indices, [0,1,2])
+        assert numpy.allclose(indices, [0,1,2])
         
 
@@ -395,5 +395,5 @@
 
         indices, count = separate_points_by_polygon( [[0.5, 0.5], [1, -0.5], [0.3, 0.2]], U )
-        assert allclose( indices, [0,2,1] )
+        assert numpy.allclose( indices, [0,2,1] )
         assert count == 2
         
@@ -403,5 +403,5 @@
 	res, count = separate_points_by_polygon( points, polygon )
 
-	assert allclose( res, [0,1,2,4,3] )
+	assert numpy.allclose( res, [0,1,2,4,3] )
 	assert count == 3
 
@@ -411,5 +411,5 @@
 	res, count = separate_points_by_polygon( points, polygon )
 
-	assert allclose( res, [1,2,3,5,4,0] )        
+	assert numpy.allclose( res, [1,2,3,5,4,0] )        
      	assert count == 3
 	
@@ -595,5 +595,5 @@
         status, value = intersection(line0, line1)
         assert status == 1
-        assert allclose(value, [0.0, 0.0])
+        assert numpy.allclose(value, [0.0, 0.0])
 
     def test_intersection2(self):
@@ -603,5 +603,5 @@
         status, value = intersection(line0, line1)
         assert status == 1
-        assert allclose(value, [12.0, 6.0])
+        assert numpy.allclose(value, [12.0, 6.0])
 
         # Swap direction of one line
@@ -610,10 +610,10 @@
         status, value = intersection(line0, line1)
         assert status == 1
-        assert allclose(value, [12.0, 6.0])
+        assert numpy.allclose(value, [12.0, 6.0])
 
         # Swap order of lines
         status, value = intersection(line1, line0)
         assert status == 1
-        assert allclose(value, [12.0, 6.0])        
+        assert numpy.allclose(value, [12.0, 6.0])        
         
     def test_intersection3(self):
@@ -623,5 +623,5 @@
         status, value = intersection(line0, line1)
         assert status == 1
-        assert allclose(value, [14.068965517, 7.0344827586])
+        assert numpy.allclose(value, [14.068965517, 7.0344827586])
 
         # Swap direction of one line
@@ -630,10 +630,10 @@
         status, value = intersection(line0, line1)
         assert status == 1
-        assert allclose(value, [14.068965517, 7.0344827586])        
+        assert numpy.allclose(value, [14.068965517, 7.0344827586])        
 
         # Swap order of lines
         status, value = intersection(line1, line0)
         assert status == 1        
-        assert allclose(value, [14.068965517, 7.0344827586])        
+        assert numpy.allclose(value, [14.068965517, 7.0344827586])        
 
 
@@ -648,5 +648,5 @@
         status, value = intersection(line0, line1)
         assert status == 1
-        assert allclose(value, [1.0, 1.0])
+        assert numpy.allclose(value, [1.0, 1.0])
 
 
@@ -656,5 +656,5 @@
         status, value = intersection(line0, line1)
         assert status == 1
-        assert allclose(value, [1.0, 1.0])        
+        assert numpy.allclose(value, [1.0, 1.0])        
         
 
@@ -686,5 +686,5 @@
                                                           common_end_point[1])
             msg += ' gave %s, \nbut when reversed we got %s' %(p1, p2)
-            assert allclose(p1, p2), msg
+            assert numpy.allclose(p1, p2), msg
 
             # Swap order of lines
@@ -692,5 +692,5 @@
             assert status == 1                        
             msg = 'Order of lines gave different results'
-            assert allclose(p1, p3), msg
+            assert numpy.allclose(p1, p3), msg
             
 
@@ -732,5 +732,5 @@
         status, value = intersection(line0, line1)
         assert status == 2
-        assert allclose(value, [[0,0], [3,0]])
+        assert numpy.allclose(value, [[0,0], [3,0]])
 
         # Overlap 2
@@ -740,5 +740,5 @@
         status, value = intersection(line0, line1)
         assert status == 2
-        assert allclose(value, [[-3, 0], [5,0]])        
+        assert numpy.allclose(value, [[-3, 0], [5,0]])        
 
         # Inclusion 1
@@ -748,5 +748,5 @@
         status, value = intersection(line0, line1)
         assert status == 2        
-        assert allclose(value, line1)
+        assert numpy.allclose(value, line1)
 
         # Inclusion 2
@@ -756,5 +756,5 @@
         status, value = intersection(line0, line1)
         assert status == 2        
-        assert allclose(value, line0)                                        
+        assert numpy.allclose(value, line0)                                        
 
 
@@ -775,9 +775,9 @@
         status, value = intersection(line0, line1)
         assert status == 2                
-        assert allclose(value, [[1, 7], [7, 19]])
+        assert numpy.allclose(value, [[1, 7], [7, 19]])
 
         status, value = intersection(line1, line0)
         assert status == 2
-        assert allclose(value, [[1, 7], [7, 19]])
+        assert numpy.allclose(value, [[1, 7], [7, 19]])
 
         # Swap direction
@@ -786,5 +786,5 @@
         status, value = intersection(line0, line1)
         assert status == 2
-        assert allclose(value, [[7, 19], [1, 7]])
+        assert numpy.allclose(value, [[7, 19], [1, 7]])
 
         line0 = [[0,5], [7,19]]
@@ -792,5 +792,5 @@
         status, value = intersection(line0, line1)
         assert status == 2
-        assert allclose(value, [[1, 7], [7, 19]])        
+        assert numpy.allclose(value, [[1, 7], [7, 19]])        
         
 
@@ -800,5 +800,5 @@
         status, value = intersection(line0, line1)
         assert status == 2                        
-        assert allclose(value, [[1,7], [7, 19]])                
+        assert numpy.allclose(value, [[1,7], [7, 19]])                
 
         line0 = [[0,5], [10,25]]
@@ -806,5 +806,5 @@
         status, value = intersection(line0, line1)
         assert status == 2                        
-        assert allclose(value, [[1,7], [7, 19]])
+        assert numpy.allclose(value, [[1,7], [7, 19]])
 
 
@@ -813,5 +813,5 @@
         status, value = intersection(line0, line1)
         assert status == 2                        
-        assert allclose(value, [[7, 19], [1, 7]])                       
+        assert numpy.allclose(value, [[7, 19], [1, 7]])                       
         
         
@@ -850,5 +850,5 @@
 	res = inside_polygon(points, polygon)
 	assert len(res) == 2
-	assert allclose(res, [0,1])
+	assert numpy.allclose(res, [0,1])
 
     def test_polygon_area(self):
Index: /anuga_core/source_numpy_conversion/anuga/utilities/test_quad.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/test_quad.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/test_quad.py	(revision 5902)
@@ -1,4 +1,4 @@
 import unittest
-from numpy import array, allclose
+##import numpy
 
 from quad import Cell, build_quadtree
@@ -236,5 +236,5 @@
                      [ 0.,  -1.]]
                      
-        # assert allclose(array(results),[[[ 2.,  1.],
+        # assert numpy.allclose(numpy.array(results),[[[ 2.,  1.],
         #[ 4.,  1.], [ 4.,  4.]], [[ 4.,  1.],[ 5.,  4.],[ 4.,  4.]]] )
         results = Q.search(5,4.)
@@ -253,5 +253,5 @@
                      [ 5.,  4.],
                      [ 4.,  4.]]
-        #assert allclose(array(results),[[[ 2.,  1.],[ 4.,  1.], [ 4.,  4.]]
+        #assert numpy.allclose(numpy.array(results),[[[ 2.,  1.],[ 4.,  1.], [ 4.,  4.]]
          #                               ,[[ 2.,  1.],[ 4.,  4.], [ 2.,  4.]],
         #[[ 4.,  1.],  [ 5.,  4.], [ 4.,  4.]],
Index: /anuga_core/source_numpy_conversion/anuga/utilities/test_sparse.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/test_sparse.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/test_sparse.py	(revision 5902)
@@ -5,5 +5,5 @@
 
 from sparse import *
-from numpy.oldnumeric import allclose, array, transpose
+import numpy
 
 class Test_Sparse(unittest.TestCase):
@@ -43,5 +43,5 @@
         C = Sparse(B)
 
-        assert allclose(C.todense(), B)
+        assert numpy.allclose(C.todense(), B)
 
 
@@ -50,5 +50,5 @@
         A[1,1] = 4
 
-        assert allclose(A.todense(), [[0,0,0], [0,4,0], [0,0,0], [0,0,0]])
+        assert numpy.allclose(A.todense(), [[0,0,0], [0,4,0], [0,0,0], [0,0,0]])
 
 
@@ -63,10 +63,10 @@
 
         assert len(A) == 0
-        assert allclose(A.todense(), [[0,0,0], [0,0,0], [0,0,0]])
+        assert numpy.allclose(A.todense(), [[0,0,0], [0,0,0], [0,0,0]])
 
         #Set an existing zero element to zero
         A[1,2] = 0
         assert len(A) == 0
-        assert allclose(A.todense(), [[0,0,0], [0,0,0], [0,0,0]])
+        assert numpy.allclose(A.todense(), [[0,0,0], [0,0,0], [0,0,0]])
 
     def test_sparse_multiplication_vector(self):
@@ -82,14 +82,14 @@
 
         u = A*v
-        assert allclose(u, [6,14,4])
+        assert numpy.allclose(u, [6,14,4])
 
         #Right hand side column
-        v = array([[2,4],[3,4],[4,4]])
+        v = numpy.array([[2,4],[3,4],[4,4]])
 
         u = A*v[:,0]
-        assert allclose(u, [6,14,4])
+        assert numpy.allclose(u, [6,14,4])
 
         u = A*v[:,1]
-        assert allclose(u, [12,16,4])
+        assert numpy.allclose(u, [12,16,4])
 
 
@@ -103,8 +103,8 @@
 
         #Right hand side matrix
-        v = array([[2,4],[3,4],[4,4]])
+        v = numpy.array([[2,4],[3,4],[4,4]])
 
         u = A*v
-        assert allclose(u, [[6,12], [14,16], [4,4]])
+        assert numpy.allclose(u, [[6,12], [14,16], [4,4]])
 
 
@@ -122,5 +122,5 @@
 
         u = A.trans_mult(v)
-        assert allclose(u, [6,6,10])
+        assert numpy.allclose(u, [6,6,10])
 
 
@@ -137,8 +137,8 @@
 
         B = 3*A
-        assert allclose(B.todense(), 3*A.todense())
+        assert numpy.allclose(B.todense(), 3*A.todense())
 
         B = A*3
-        assert allclose(B.todense(), 3*A.todense())
+        assert numpy.allclose(B.todense(), 3*A.todense())
 
         try:
@@ -166,5 +166,5 @@
         C = A+B
 
-        assert allclose(C.todense(), [[12,0,0], [2,8,8], [0,0,4]])
+        assert numpy.allclose(C.todense(), [[12,0,0], [2,8,8], [0,0,4]])
 
     def test_sparse_tocsr(self):
@@ -190,5 +190,5 @@
         C = [1, 2, 3]
 
-        assert allclose(B*C, [15.0, 10.0 ,8.0, 0.0])
+        assert numpy.allclose(B*C, [15.0, 10.0 ,8.0, 0.0])
 
         C2 = [[1,2],[2,4],[3,6]]
@@ -196,5 +196,5 @@
         #print B*C2
 
-        assert allclose(B*C2, [[15.0, 30.0],[10.0, 20.0],[8.0, 16.0],[0.0, 0.0]])
+        assert numpy.allclose(B*C2, [[15.0, 30.0],[10.0, 20.0],[8.0, 16.0],[0.0, 0.0]])
 
 
Index: /anuga_core/source_numpy_conversion/anuga/utilities/test_system_tools.py
===================================================================
--- /anuga_core/source_numpy_conversion/anuga/utilities/test_system_tools.py	(revision 5901)
+++ /anuga_core/source_numpy_conversion/anuga/utilities/test_system_tools.py	(revision 5902)
@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 
-
 import unittest
-from numpy import zeros, array, allclose, float, dtype
+import numpy
 import zlib
 from os.path import join, split, sep
@@ -81,5 +80,5 @@
             pass
         else:
-            test_array = array([[7.0, 3.14], [-31.333, 0.0]])
+            test_array = numpy.array([[7.0, 3.14], [-31.333, 0.0]])
 
             # First file
@@ -87,5 +86,5 @@
             fid = NetCDFFile(filename1, 'w')
             fid.createDimension('two', 2)
-            fid.createVariable('test_array', dtype(float).char, ('two', 'two'))
+            fid.createVariable('test_array', numpy.dtype(numpy.float).char, ('two', 'two'))
             fid.variables['test_array'][:] = test_array
             fid.close()
@@ -95,5 +94,5 @@
             fid = NetCDFFile(filename2, 'w')
             fid.createDimension('two', 2)
-            fid.createVariable('test_array', dtype(float).char, ('two', 'two'))
+            fid.createVariable('test_array', numpy.dtype(numpy.float).char, ('two', 'two'))
             fid.variables['test_array'][:] = test_array
             fid.close()
