Index: anuga_core/source/anuga_parallel/build_commun.py
===================================================================
--- anuga_core/source/anuga_parallel/build_commun.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/build_commun.py	(revision 7400)
@@ -13,9 +13,13 @@
 #  Author: Linda Stals, June 2005
 #  Modified: Linda Stals, Nov 2005 (optimise python code)
-#
-#
-#########################################################
-
-from Numeric import array, Int, Float, zeros
+#            Steve Roberts, Aug 2009 (update to numpy)
+#
+#
+#########################################################
+
+#from Numeric import array, Int, Float, zeros
+
+import numpy as num
+
 import logging, logging.config
 logger = logging.getLogger('parallel')
@@ -30,4 +34,5 @@
 
 import pypar
+
 
 from build_local import build_local_mesh
@@ -65,13 +70,14 @@
              tagmap[bkey] = counter
              counter = counter+1
+
     pypar.send(tagmap, p)
 
     # send the quantities key information
-    
+
     pypar.send(submesh["full_quan"].keys(), p)
     
     # send the number of triangles per processor
 
-    pypar.send(triangles_per_proc, p, use_buffer=True)
+    pypar.send(triangles_per_proc, p)
 
     # compress full_commun
@@ -82,4 +88,6 @@
         for i in range(len(submesh["full_commun"][p][c])):
             flat_full_commun.append([c,submesh["full_commun"][p][c][i]])
+
+    print 'flat_full_commun', flat_full_commun
 
     # send the array sizes so memory can be allocated
@@ -95,15 +103,15 @@
     setup_array[7] = len(flat_full_commun)
 
-    pypar.send(setup_array, p)
+    pypar.send(num.array(setup_array, num.int), p)
     
     # send the nodes
-    
-    pypar.send(submesh["full_nodes"][p], p, use_buffer=True)
-    pypar.send(submesh["ghost_nodes"][p], p, use_buffer=True)
+
+    pypar.send(num.array(submesh["full_nodes"][p], num.float), p)
+    pypar.send(num.array(submesh["ghost_nodes"][p], num.float),p)
 
     # send the triangles
 
-    pypar.send(array(submesh["full_triangles"][p], Int), p, use_buffer=True)
-    pypar.send(submesh["ghost_triangles"][p], p, use_buffer=True)
+    pypar.send(num.array(submesh["full_triangles"][p],  num.int), p)
+    pypar.send(num.array(submesh["ghost_triangles"][p], num.int), p)
 
     # send the boundary
@@ -112,22 +120,27 @@
     for b in submesh["full_boundary"][p]:
         bc.append([b[0], b[1], tagmap[submesh["full_boundary"][p][b]]])
-    pypar.send(bc, p, use_buffer=True)
+
+
+    pypar.send(num.array(bc, num.int), p)
+
     bc = []
     for b in submesh["ghost_boundary"][p]:
         bc.append([b[0], b[1], tagmap[submesh["ghost_boundary"][p][b]]])
-    pypar.send(bc, p, use_buffer=True)
+
+    pypar.send(num.array(bc, num.int), p)
 
     # send the communication pattern
 
-    pypar.send(submesh["ghost_commun"][p], p, use_buffer=True)
-    pypar.send(flat_full_commun, p, use_buffer=True)
+    pypar.send(submesh["ghost_commun"][p], p)
+
+    pypar.send(num.array(flat_full_commun, num.int), p)
 
     # send the quantities
     
     for k in submesh["full_quan"]:
-        pypar.send(submesh["full_quan"][k][p], p, use_buffer=True)
+        pypar.send(num.array(submesh["full_quan"][k][p], num.float), p)
         
     for k in submesh["ghost_quan"]:
-        pypar.send(submesh["ghost_quan"][k][p], p, use_buffer=True)
+        pypar.send(num.array(submesh["ghost_quan"][k][p], num.float),p)
         
 
@@ -150,5 +163,5 @@
 
 def rec_submesh_flat(p):
-
+    
     numproc = pypar.size()
     myid = pypar.rank()
@@ -161,4 +174,5 @@
     
     tagmap = pypar.receive(p)
+
     itagmap = {}
     for t in tagmap:
@@ -166,52 +180,44 @@
 
     # receive the quantities key information
-    
+
     qkeys = pypar.receive(p)
 
     # receive the number of triangles per processor
 
-    triangles_per_proc = []
-    for i in range(numproc):
-        triangles_per_proc.append([0])
-
-    triangles_per_proc = pypar.receive(p, triangles_per_proc)
+    triangles_per_proc = pypar.receive(p)
 
     # recieve information about the array sizes
 
-    setup_array = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-    setup_array = pypar.receive(p, setup_array)
-
+    setup_array = pypar.receive(p)
+
+    no_full_nodes = setup_array[0]
+    no_ghost_nodes = setup_array[1]
+    no_full_triangles = setup_array[2]
+    no_ghost_triangles = setup_array[3]
+    no_full_boundary = setup_array[4]
+    no_ghost_boundary = setup_array[5]
+    no_ghost_commun = setup_array[6]
+    no_full_commun = setup_array[7]
+    no_quantities = len(qkeys)
+    
     # receive the full nodes
 
-    no_full_nodes = setup_array[0]
-    full_nodes = zeros((no_full_nodes, 3), Float)
-    submesh_cell["full_nodes"] = pypar.receive(p, full_nodes)
-    
+    submesh_cell["full_nodes"] = pypar.receive(p)
+
     # receive the ghost nodes
 
-    no_ghost_nodes = setup_array[1]
-    ghost_nodes = zeros((no_ghost_nodes, 3), Float)
-    submesh_cell["ghost_nodes"] = pypar.receive(p, ghost_nodes)
-
+    submesh_cell["ghost_nodes"] = pypar.receive(p)
     
     # receive the full triangles
 
-    no_full_triangles = setup_array[2]
-    full_triangles = zeros((no_full_triangles, 3), Int)
-    submesh_cell["full_triangles"] = pypar.receive(p, full_triangles)
+    submesh_cell["full_triangles"] = pypar.receive(p)
     
     # receive the ghost triangles
 
-    no_ghost_triangles = setup_array[3]
-    ghost_triangles = zeros((no_ghost_triangles, 4), Int)
-    submesh_cell["ghost_triangles"] = pypar.receive(p, ghost_triangles)
-    
+    submesh_cell["ghost_triangles"] = pypar.receive(p)
+
     # receive the full boundary
 
-    no_full_boundary = setup_array[4]
-    bc = []
-    for i in range(no_full_boundary):
-        bc.append([0.0, 0.0, 0.0])
-    bnd_c = pypar.receive(p, bc)
+    bnd_c = pypar.receive(p)
 
     submesh_cell["full_boundary"] = {}
@@ -221,9 +227,5 @@
     # receive the ghost boundary
 
-    no_ghost_boundary = setup_array[5]
-    bc = []
-    for i in range(no_ghost_boundary):
-        bc.append([0.0, 0.0, 0.0])
-    bnd_c = pypar.receive(p, bc)
+    bnd_c = pypar.receive(p)
 
     submesh_cell["ghost_boundary"] = {}
@@ -233,16 +235,9 @@
     # receive the ghost communication pattern
 
-    no_ghost_commun = setup_array[6]
-    ghost_commun = zeros((no_ghost_commun, 2), Int)
-    submesh_cell["ghost_commun"] = pypar.receive(p, ghost_commun)
+    submesh_cell["ghost_commun"] = pypar.receive(p)
     
     # receive the full communication pattern
 
-    no_full_commun = setup_array[7]
-    full_commun = []
-    for i in range(no_full_commun):
-        full_commun.append([0.0, 0.0])
-
-    full_commun = pypar.receive(p, full_commun)
+    full_commun = pypar.receive(p)
 
     submesh_cell["full_commun"] = {}
@@ -254,18 +249,15 @@
     # receive the quantities
 
-    no_quantities = len(qkeys)
-    new_quan = zeros((no_full_triangles, 3), Float)
     submesh_cell["full_quan"]={}
     
     for i in range(no_quantities):
-        tmp = pypar.receive(p, new_quan)
-        submesh_cell["full_quan"][qkeys[i]]=zeros((no_full_triangles,3), Float)
+        tmp = pypar.receive(p)
+        submesh_cell["full_quan"][qkeys[i]]=num.zeros((no_full_triangles,3), num.float)
         submesh_cell["full_quan"][qkeys[i]][:] = tmp[:]
 
-    new_quan = zeros((no_ghost_triangles, 3), Float)
     submesh_cell["ghost_quan"]={}
     for i in range(no_quantities):
-        tmp = pypar.receive(p, new_quan)
-        submesh_cell["ghost_quan"][qkeys[i]]= zeros((no_ghost_triangles,3), Float)
+        tmp = pypar.receive(p)
+        submesh_cell["ghost_quan"][qkeys[i]]= num.zeros((no_ghost_triangles,3), num.float)
         submesh_cell["ghost_quan"][qkeys[i]][:] = tmp[:]
     
@@ -293,5 +285,5 @@
 
 def rec_submesh(p):
-
+    
     numproc = pypar.size()
     myid = pypar.rank()
Index: anuga_core/source/anuga_parallel/build_local.py
===================================================================
--- anuga_core/source/anuga_parallel/build_local.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/build_local.py	(revision 7400)
@@ -14,12 +14,15 @@
 #  Authors: Linda Stals and Matthew Hardy, June 2005
 #  Modified: Linda Stals, Nov 2005 (optimise python code)
-#
-#
-#########################################################
-
-from Numeric import  zeros, Float, Int, concatenate, \
-     take, arrayrange, put, sort, compress, equal
-
-
+#            Steve Roberts, Aug 2009 (updating to numpy)
+#
+#
+#########################################################
+
+#from Numeric import  zeros, Float, Int, concatenate, \
+#     take, arrayrange, put, sort, compress, equal
+
+
+import numpy as num
+ 
 #########################################################
 # Convert the format of the data to that used by ANUGA
@@ -46,5 +49,5 @@
     # Extract the nodes (using the local ID)
     
-    GAnodes = take(nodes, (1, 2), 1)
+    GAnodes = num.take(nodes, (1, 2), 1)
 
     # Build a global ID to local ID mapping
@@ -54,14 +57,14 @@
         if nodes[i][0] > NGlobal:
             NGlobal = nodes[i][0]
-    index = zeros(int(NGlobal)+1, Int)
-    put(index, take(nodes, (0,), 1).astype(Int), \
-        arrayrange(Nnodes))
+    index = num.zeros(int(NGlobal)+1, num.int)
+    num.put(index, num.take(nodes, (0,), 1).astype(num.int), \
+        num.arange(Nnodes))
         
     # Change the global IDs in the triangles to the local IDs
 
-    GAtriangles = zeros((Ntriangles, 3), Int)
-    GAtriangles[:,0] = take(index, triangles[:,0])
-    GAtriangles[:,1] = take(index, triangles[:,1])
-    GAtriangles[:,2] = take(index, triangles[:,2])
+    GAtriangles = num.zeros((Ntriangles, 3), num.int)
+    GAtriangles[:,0] = num.take(index, triangles[:,0])
+    GAtriangles[:,1] = num.take(index, triangles[:,1])
+    GAtriangles[:,2] = num.take(index, triangles[:,2])
 
     # Change the triangle numbering in the boundaries
@@ -109,13 +112,13 @@
     # information by the global numbering)
     
-    ghostc = sort(ghostc, 0)
+    ghostc = num.sort(ghostc, 0)
     
     for c in range(nproc):
         s = ghostc[:,0]
-        d = compress(equal(ghostc[:,1],c), s)
+        d = num.compress(num.equal(ghostc[:,1],c), s)
         if len(d) > 0:
             ghost_recv[c] = [0, 0]
             ghost_recv[c][1] = d
-            ghost_recv[c][0] = take(index, d)
+            ghost_recv[c][0] = num.take(index, d)
             
     # Build a temporary copy of the full_send dictionary
@@ -136,5 +139,5 @@
 
     for neigh in tmp_send:
-        neigh_commun = sort(tmp_send[neigh], 0)
+        neigh_commun = num.sort(tmp_send[neigh], 0)
         full_send[neigh] = [0, 0]
         full_send[neigh][0] = neigh_commun[:,1]
@@ -167,11 +170,11 @@
     # Combine the full nodes and ghost nodes
 
-    nodes = concatenate((submesh["full_nodes"], \
+    nodes = num.concatenate((submesh["full_nodes"], \
                          submesh["ghost_nodes"]))
     
     # Combine the full triangles and ghost triangles
 
-    gtri =  take(submesh["ghost_triangles"],(1, 2, 3),1)
-    triangles = concatenate((submesh["full_triangles"], gtri))
+    gtri =  num.take(submesh["ghost_triangles"],(1, 2, 3),1)
+    triangles = num.concatenate((submesh["full_triangles"], gtri))
 
     # Combine the full boundaries and ghost boundaries
@@ -189,6 +192,6 @@
         if id > NGlobal:
             NGlobal = id
-    index = zeros(int(NGlobal)+1, Int)
-    index[lower_t:upper_t]=arrayrange(upper_t-lower_t)
+    index = num.zeros(int(NGlobal)+1, num.int)
+    index[lower_t:upper_t]=num.arange(upper_t-lower_t)
     for i in range(len(submesh["ghost_triangles"])):
         index[submesh["ghost_triangles"][i][0]] = i+upper_t-lower_t
@@ -205,5 +208,5 @@
         Nf = len(submesh["full_quan"][k])
         Ng = len(submesh["ghost_quan"][k])
-        quantities[k] = zeros((Nf+Ng, 3), Float)
+        quantities[k] = num.zeros((Nf+Ng, 3), num.float)
         quantities[k][0:Nf] = submesh["full_quan"][k] 
         quantities[k][Nf:Nf+Ng] = submesh["ghost_quan"][k]
@@ -223,2 +226,3 @@
     return GAnodes, GAtriangles, GAboundary, quantities, ghost_rec, \
            full_send
+
Index: anuga_core/source/anuga_parallel/build_submesh.py
===================================================================
--- anuga_core/source/anuga_parallel/build_submesh.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/build_submesh.py	(revision 7400)
@@ -1,5 +1,5 @@
 #########################################################
 #
-# Subdivide the GA domain. This module is primarily
+# Subdivide the domain. This module is primarily
 # responsible for building the ghost layer and
 # communication pattern
@@ -8,4 +8,5 @@
 #  Author: Linda Stals, June 2005
 #  Modified: Linda Stals, Nov 2005 (optimise python code)
+#            Steve Roberts, Aug 2009 (convert to numpy)
 #
 #
@@ -14,6 +15,8 @@
 import sys
 
-from Numeric import zeros, Float, Int, concatenate, \
-     reshape, arrayrange, take, nonzero
+#from Numeric import zeros, Float, Int, concatenate, \
+#     reshape, arrayrange, take, nonzero
+
+import numpy as num
 
 from anuga.abstract_2d_finite_volumes.neighbour_mesh import Mesh
@@ -55,6 +58,9 @@
     boundary_list = []
     submesh = {}
-    node_range = reshape(arrayrange(nnodes),(nnodes,1))
-    tsubnodes = concatenate((node_range, nodes), 1)
+    node_range = num.reshape(num.arange(nnodes),(nnodes,1))
+
+    #print node_range
+    tsubnodes = num.concatenate((node_range, nodes), 1)
+
 
     # Loop over processors
@@ -78,5 +84,5 @@
         # Find nodes in processor p
 
-        nodemap = zeros(nnodes, 'i')
+        nodemap = num.zeros(nnodes, 'i')
         for t in subtriangles:
             nodemap[t[0]]=1
@@ -84,5 +90,6 @@
             nodemap[t[2]]=1
 
-        node_list.append(take(tsubnodes,nonzero(nodemap)))
+        
+        node_list.append(tsubnodes.take(num.flatnonzero(nodemap),axis=0))
 
         # Move to the next processor
@@ -134,8 +141,9 @@
     # Find the first layer of boundary triangles
 
-    trianglemap = zeros(ntriangles, 'i')
+    trianglemap = num.zeros(ntriangles, 'i')
     for t in range(tlower, tupper):
         
         n = mesh.neighbours[t, 0]
+
         if n >= 0:
             if n < tlower or n >= tupper:
@@ -169,5 +177,5 @@
     # Build the triangle list and make note of the vertices
 
-    nodemap = zeros(ncoord, 'i')
+    nodemap = num.zeros(ncoord, 'i')
     fullnodes = submesh["full_nodes"][p]
 
@@ -180,8 +188,9 @@
             nodemap[t[2]] = 1
 
-    trilist = reshape(arrayrange(ntriangles),(ntriangles,1))
-    tsubtriangles = concatenate((trilist, mesh.triangles), 1)
-    subtriangles = take(tsubtriangles, nonzero(trianglemap))
-
+    trilist = num.reshape(num.arange(ntriangles),(ntriangles,1))
+    tsubtriangles = num.concatenate((trilist, mesh.triangles), 1)
+    subtriangles = tsubtriangles.take(num.flatnonzero(trianglemap),axis=0)
+
+    
     # Keep a record of the triangle vertices, if they are not already there
 
@@ -190,7 +199,7 @@
         nodemap[int(n[0])] = 0
 
-    nodelist = reshape(arrayrange(ncoord),(ncoord,1))
-    tsubnodes = concatenate((nodelist, mesh.get_nodes()), 1)
-    subnodes = take(tsubnodes, nonzero(nodemap))
+    nodelist = num.reshape(num.arange(ncoord),(ncoord,1))
+    tsubnodes = num.concatenate((nodelist, mesh.get_nodes()), 1)
+    subnodes = tsubnodes.take(num.flatnonzero(nodemap),axis=0)
 
     # Clean up before exiting
@@ -234,5 +243,7 @@
 #########################################################
 def is_in_processor(ghost_list, tlower, tupper, n):
-    return (n in ghost_list) or (tlower <= n and tupper > n)
+
+    return num.equal(ghost_list,n).any() or (tlower <= n and tupper > n)
+
 
 def ghost_bnd_layer(ghosttri, tlower, tupper, mesh, p):
@@ -240,9 +251,11 @@
     ghost_list = []
     subboundary = {}
-        
+
+
     for t in ghosttri:
         ghost_list.append(t[0])
     
     for t in ghosttri:
+
         n = mesh.neighbours[t[0], 0]
         if not is_in_processor(ghost_list, tlower, tupper, n):
@@ -279,5 +292,5 @@
     # Loop over the ghost triangles
 
-    ghost_commun = zeros((len(subtri), 2), Int)
+    ghost_commun = num.zeros((len(subtri), 2), num.int)
 
     for i in range(len(subtri)):
@@ -410,4 +423,5 @@
         ghost_nodes.append(subnodes)
 
+
         # Find the boundary layer formed by the ghost triangles
         
@@ -492,5 +506,5 @@
         for k in quantities:
             submesh["full_quan"][k].append(quantities[k][lower:upper])
-            submesh["ghost_quan"][k].append(zeros( (M,3) , Float))
+            submesh["ghost_quan"][k].append(num.zeros( (M,3) , num.float))
             for j in range(M):
                 submesh["ghost_quan"][k][p][j] = \
Index: anuga_core/source/anuga_parallel/parallel_advection.py
===================================================================
--- anuga_core/source/anuga_parallel/parallel_advection.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/parallel_advection.py	(revision 7400)
@@ -23,5 +23,9 @@
 
 from anuga.advection import *
-from Numeric import zeros, Float, Int, ones, allclose, array
+
+
+#from Numeric import zeros, Float, Int, ones, allclose, array
+import numpy as num
+
 import pypar
 
@@ -78,10 +82,19 @@
         # For some reason it looks like pypar only reduces numeric arrays
         # hence we need to create some dummy arrays for communication
-        ltimestep = ones( 1, Float )
+        ltimestep = num.ones( 1, num.float )
         ltimestep[0] = self.flux_timestep
-        gtimestep = zeros( 1, Float) # Buffer for results
-        
-        pypar.raw_reduce(ltimestep, gtimestep, pypar.MIN, 0)
+        gtimestep = num.zeros( 1, num.float ) # Buffer for results
+
+        #ltimestep = self.flux_timeste
+
+        #print self.processor, ltimestep, gtimestep
+        
+        pypar.reduce(ltimestep, pypar.MIN, 0, buffer=gtimestep)
+
+        #print self.processor, ltimestep, gtimestep
+        
         pypar.broadcast(gtimestep,0)
+
+        #print self.processor, ltimestep, gtimestep
 
         self.flux_timestep = gtimestep[0]
@@ -102,5 +115,6 @@
         # the separate processors
 
-        from Numeric import take,put
+        #from Numeric import take,put
+        import numpy as num
         import time
         t0 = time.time()
@@ -122,5 +136,5 @@
                         #for i in range(N):
                         #    Xout[i,0] = stage_cv[Idf[i]]
-                        Xout[:,0] = take(stage_cv, Idf)
+                        Xout[:,0] = num.take(stage_cv, Idf)
 
                         pypar.send(Xout,send_proc)
@@ -139,5 +153,5 @@
                     N = len(Idg)
 
-                    put(stage_cv, Idg, X[:,0])
+                    num.put(stage_cv, Idg, X[:,0])
                     #for i in range(N):
                     #    stage_cv[Idg[i]] = X[i,0]
@@ -162,5 +176,5 @@
             #    stage_cv[Idg[i]] = stage_cv[Idf[i]]
 
-            put(stage_cv, Idg, take(stage_cv, Idf))
+            num.put(stage_cv, Idg, num.take(stage_cv, Idf))
 
 
Index: anuga_core/source/anuga_parallel/parallel_api.py
===================================================================
--- anuga_core/source/anuga_parallel/parallel_api.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/parallel_api.py	(revision 7400)
@@ -4,5 +4,5 @@
 """
 
-from Numeric import zeros
+
 
 # The abstract Python-MPI interface
@@ -168,4 +168,6 @@
 
 
+
+
     # Build the mesh that should be assigned to each processor,
     # this includes ghost nodes and the communication pattern
Index: anuga_core/source/anuga_parallel/parallel_meshes.py
===================================================================
--- anuga_core/source/anuga_parallel/parallel_meshes.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/parallel_meshes.py	(revision 7400)
@@ -15,6 +15,7 @@
 
 import sys
-from Numeric import array, zeros, Float, Int, ones, sum
-
+#from Numeric import array, zeros, Float, Int, ones, sum
+
+import numpy as num
 import pypar
 
@@ -86,5 +87,5 @@
     E = EIndex(n,m)
 
-    points = zeros( (Np,2), Float)
+    points = num.zeros( (Np,2), num.float)
 
     for i in range(m+1):
@@ -98,5 +99,5 @@
 
 
-    elements = zeros( (Nt,3), Int)
+    elements = num.zeros( (Nt,3), num.int)
     boundary = {}
     Idgl = []
@@ -170,6 +171,6 @@
         print Idgr
         
-        Idfl = array(Idfl,Int)
-        Idgr = array(Idgr,Int)
+        Idfl = num.array(Idfl,num.int)
+        Idgr = num.array(Idgr,num.int)
 
         print Idfl
@@ -184,14 +185,14 @@
         Idfl.extend(Idfr)
         Idgr.extend(Idgl)
-        Idfl = array(Idfl,Int)
-        Idgr = array(Idgr,Int)
+        Idfl = num.array(Idfl,num.int)
+        Idgr = num.array(Idgr,num.int)
         full_send_dict[(processor-1)%numproc]  = [Idfl, Idfl]
         ghost_recv_dict[(processor-1)%numproc] = [Idgr, Idgr]
     else:
-        Idfl = array(Idfl,Int)
-        Idgl = array(Idgl,Int)
-
-        Idfr = array(Idfr,Int)
-        Idgr = array(Idgr,Int)
+        Idfl = num.array(Idfl,num.int)
+        Idgl = num.array(Idgl,num.int)
+
+        Idfr = num.array(Idfr,num.int)
+        Idgr = num.array(Idgr,num.int)
 
         full_send_dict[(processor-1)%numproc]  = [Idfl, Idfl]
@@ -252,5 +253,5 @@
     E = EIndex(n,m)
 
-    points = zeros( (Np,2), Float)
+    points = num.zeros( (Np,2), num.float)
 
     for i in range(m+1):
@@ -264,5 +265,5 @@
 
 
-    elements = zeros( (Nt,3), Int)
+    elements = num.zeros( (Nt,3), num.int)
     boundary = {}
     ghosts = {}
@@ -389,5 +390,5 @@
     E = EIndex(n,m)
 
-    points = zeros( (Np,2), Float)
+    points = num.zeros( (Np,2), num.float)
 
     for i in range(m+1):
@@ -401,5 +402,5 @@
 
 
-    elements = zeros( (Nt,3), Int)
+    elements = num.zeros( (Nt,3), num.int)
     boundary = {}
     ghosts = {}
Index: anuga_core/source/anuga_parallel/parallel_shallow_water.py
===================================================================
--- anuga_core/source/anuga_parallel/parallel_shallow_water.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/parallel_shallow_water.py	(revision 7400)
@@ -23,5 +23,7 @@
 
 from anuga.shallow_water.shallow_water_domain import *
-from Numeric import zeros, Float, Int, ones, allclose, array
+
+
+import numpy as num
 
 import pypar
@@ -57,10 +59,10 @@
 #        for key in full_send_dict:
 #            buffer_shape = full_send_dict[key][0].shape[0]
-#            full_send_dict[key].append(zeros( (buffer_shape,self.nsys) ,Float))
+#            full_send_dict[key].append(num.zeros( (buffer_shape,self.nsys) ,num.loat))
 #
 #
 #        for key in ghost_recv_dict:
 #            buffer_shape = ghost_recv_dict[key][0].shape[0]
-#            ghost_recv_dict[key].append(zeros( (buffer_shape,self.nsys) ,Float))
+#            ghost_recv_dict[key].append(num.zeros( (buffer_shape,self.nsys) ,num.float))
 #
 #        self.full_send_dict  = full_send_dict
@@ -68,8 +70,8 @@
 
         # Buffers for synchronisation of timesteps
-        self.local_timestep = zeros(1, Float)
-        self.global_timestep = zeros(1, Float)
-
-        self.local_timesteps = zeros(self.numproc, Float)
+        self.local_timestep = num.zeros(1, num.float)
+        self.global_timestep = num.zeros(1, num.float)
+
+        self.local_timesteps = num.zeros(self.numproc, num.loat)
 
 
Index: anuga_core/source/anuga_parallel/pmesh_divide.py
===================================================================
--- anuga_core/source/anuga_parallel/pmesh_divide.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/pmesh_divide.py	(revision 7400)
@@ -12,4 +12,5 @@
 #  Modified: Linda Stals, Nov 2005
 #            Jack Kelly, Nov 2005
+#            Steve Roberts, Aug 2009 (updating to numpy)
 #
 #
@@ -20,6 +21,6 @@
 from math import floor
 
-from Numeric import zeros, Float, Int, reshape, argsort, ArrayType
-
+import numpy as num
+#import zeros, float, Int, reshape, argsort, ArrayType
 
 #########################################################
@@ -49,5 +50,5 @@
     # Temporary storage area
 
-    index = zeros(N, Int)
+    index = num.zeros(N, num.int)
     q_reord = {}
 
@@ -62,5 +63,5 @@
 
     for k in quantities:
-        q_reord[k] = zeros((N, 3), Float)
+        q_reord[k] = num.zeros((N, 3), num.float)
         for i in range(N):
             q_reord[k][index[i]]=quantities[k].vertex_values[i]
@@ -88,5 +89,4 @@
 
 try:
-    
     from pymetis.metis import partMeshNodal
 except ImportError:
@@ -96,4 +96,5 @@
     print "***************************************************"
     raise ImportError
+
 def pmesh_divide_metis(domain, n_procs):
     
@@ -121,5 +122,5 @@
         n_vert = domain.get_number_of_nodes()
         t_list = domain.triangles.copy()
-        t_list = reshape(t_list, (-1,))
+        t_list = num.reshape(t_list, (-1,))
     
         # The 1 here is for triangular mesh elements.
@@ -133,6 +134,6 @@
         # Sometimes (usu. on x86_64), partMeshNodal returnes an array of zero
         # dimensional arrays. Correct this.
-        if type(epart[0]) == ArrayType:
-            epart_new = zeros(len(epart), Int)
+        if type(epart[0]) == num.ndarray:
+            epart_new = num.zeros(len(epart), num.int)
             for i in range(len(epart)):
                 epart_new[i] = epart[i][0]
@@ -184,5 +185,5 @@
         quantities = {}
         for k in domain.quantities:
-            quantities[k] = zeros((n_tri, 3), Float)
+            quantities[k] = num.zeros((n_tri, 3), num.float)
             for i in range(n_tri):
                 quantities[k][i] = domain.quantities[k].vertex_values[i]
@@ -195,5 +196,5 @@
     # this helps with the communication
 
-    ttriangles = zeros((len(triangles), 3), Int)
+    ttriangles = num.zeros((len(triangles), 3), num.int)
     for i in range(len(triangles)):
         ttriangles[i] = triangles[i]
Index: anuga_core/source/anuga_parallel/run_advection.py
===================================================================
--- anuga_core/source/anuga_parallel/run_advection.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/run_advection.py	(revision 7400)
@@ -4,13 +4,17 @@
 #========================================================================
 from anuga.config import g, epsilon
-from Numeric import allclose, array, zeros, ones, Float
+
+#from Numeric import allclose, array, zeros, ones, Float
+
 from anuga.advection import Domain, Transmissive_boundary, Dirichlet_boundary
-from Numeric import array
+
+#from Numeric import array
+import numpy as num
 
 
-from mesh_factory import rectangular
+from anuga.interface import rectangular_cross
 
 #points, vertices, boundary = rectangular(60, 60)
-points, vertices, boundary = rectangular(10, 10)
+points, vertices, boundary = rectangular_cross(10, 10)
 
 #Create advection domain with direction (1,-1)
@@ -26,10 +30,10 @@
 #Boundaries
 T = Transmissive_boundary(domain)
-D = Dirichlet_boundary(array([1.0]))
+D = Dirichlet_boundary(num.array([1.0]))
 
 #turn on the visualisation
 rect = [0.0, 0.0, 1.0, 1.0]
 #domain.initialise_visualiser(rect=rect)
-domain.visualise = True
+domain.visualise = False
 
 
Index: anuga_core/source/anuga_parallel/run_parallel_advection.py
===================================================================
--- anuga_core/source/anuga_parallel/run_parallel_advection.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/run_parallel_advection.py	(revision 7400)
@@ -48,8 +48,11 @@
 numprocs = pypar.size()
 myid = pypar.rank()
-processor_name = pypar.Get_processor_name()
+processor_name = pypar.get_processor_name()
 
 N = 5
 M = 2
+
+N = 10
+M = 5
 
 #######################
@@ -121,5 +124,5 @@
 # Let processor 0 output some timing information
 
-visualise = True
+visualise = False
 if visualise:
     from anuga.visualiser import RealtimeVisualiser
@@ -137,5 +140,5 @@
     t0 = time.time()
 
-for t in domain.evolve(yieldstep = 0.1, finaltime = 3.0):
+for t in domain.evolve(yieldstep = 0.1, finaltime = 30.0):
     if myid == 0:
         domain.write_time()
Index: anuga_core/source/anuga_parallel/test_parallel_sw_runup.py
===================================================================
--- anuga_core/source/anuga_parallel/test_parallel_sw_runup.py	(revision 7398)
+++ anuga_core/source/anuga_parallel/test_parallel_sw_runup.py	(revision 7400)
@@ -15,16 +15,18 @@
 #------------------------------------------------------------------------------
 
-from Numeric import allclose
+import numpy as num
 
 from anuga.pmesh.mesh_interface import create_mesh_from_regions
-from anuga.abstract_2d_finite_volumes.mesh_factory import rectangular_cross
+
 from anuga.utilities.numerical_tools import ensure_numeric
 from anuga.utilities.polygon import is_inside_polygon
 
-from anuga.shallow_water import Domain
-from anuga.shallow_water import Reflective_boundary
-from anuga.shallow_water import Dirichlet_boundary
-from anuga.shallow_water import Time_boundary
-from anuga.shallow_water import Transmissive_boundary
+from anuga.interface import Domain
+from anuga.interface import Reflective_boundary
+from anuga.interface import Dirichlet_boundary
+from anuga.interface import Time_boundary
+from anuga.interface import Transmissive_boundary
+
+from anuga.interface import rectangular_cross
 
 from parallel_api import distribute, myid, numprocs
@@ -161,5 +163,5 @@
     if tri_ids[i] > -1:
         #print 'myid = %g, allclose(gauge_values[%g], G%g) = %g' % (myid, i,i, allclose(gauge_values[i], G[i]))
-        success = success and allclose(gauge_values[i], G[i])
+        success = success and num.allclose(gauge_values[i], G[i])
 
 
