Changeset 7400

Timestamp:

Aug 21, 2009, 2:02:46 PM (15 years ago)

Author:

steve

Message:

Commit a working copy of numpy version of build_commun

Location:

anuga_core/source/anuga_parallel

Files:

• build_commun.py (modified) (13 diffs)
• build_local.py (modified) (9 diffs)
• build_submesh.py (modified) (15 diffs)
• parallel_advection.py (modified) (6 diffs)
• parallel_api.py (modified) (2 diffs)
• parallel_meshes.py (modified) (9 diffs)
• parallel_shallow_water.py (modified) (3 diffs)
• pmesh_divide.py (modified) (10 diffs)
• run_advection.py (modified) (2 diffs)
• run_parallel_advection.py (modified) (3 diffs)
• test_parallel_sw_runup.py (modified) (2 diffs)

anuga_core/source/anuga_parallel/build_commun.py

@@ -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 +34 @@
 
 import pypar
+
 
 from build_local import build_local_mesh
@@ -65 +70 @@
              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 +88 @@
         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 +103 @@
     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 +120 @@
     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 +163 @@
 
 def rec_submesh_flat(p):
-
+    
     numproc = pypar.size()
     myid = pypar.rank()
@@ -161 +174 @@
     
     tagmap = pypar.receive(p)
+
     itagmap = {}
     for t in tagmap:
@@ -166 +180 @@
 
     # 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 +227 @@
     # 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 +235 @@
     # 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 +249 @@
     # 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 +285 @@
 
 def rec_submesh(p):
-
+    
     numproc = pypar.size()
     myid = pypar.rank()

anuga_core/source/anuga_parallel/build_local.py

@@ -14 +14 @@
 #  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 +49 @@
     # 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 +57 @@
         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 +112 @@
     # 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 +139 @@
 
     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 +170 @@
     # 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 +192 @@
         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 +208 @@
         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 +226 @@
     return GAnodes, GAtriangles, GAboundary, quantities, ghost_rec, \
            full_send
+

anuga_core/source/anuga_parallel/build_submesh.py

@@ -1 +1 @@
 #########################################################
 #
-# 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 +8 @@
 #  Author: Linda Stals, June 2005
 #  Modified: Linda Stals, Nov 2005 (optimise python code)
+#            Steve Roberts, Aug 2009 (convert to numpy)
 #
 #
@@ -14 +15 @@
 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 +58 @@
     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 +84 @@
         # Find nodes in processor p
 
-        nodemap = zeros(nnodes, 'i')
+        nodemap = num.zeros(nnodes, 'i')
         for t in subtriangles:
             nodemap[t[0]]=1
@@ -84 +90 @@
             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 +141 @@
     # 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 +177 @@
     # 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 +188 @@
             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 +199 @@
         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 +243 @@
 #########################################################
 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 +251 @@
     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 +292 @@
     # 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 +423 @@
         ghost_nodes.append(subnodes)
 
+
         # Find the boundary layer formed by the ghost triangles
         
@@ -492 +506 @@
         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] = \

anuga_core/source/anuga_parallel/parallel_advection.py

@@ -23 +23 @@
 
 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 +82 @@
         # 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 +115 @@
         # the separate processors
 
-        from Numeric import take,put
+        #from Numeric import take,put
+        import numpy as num
         import time
         t0 = time.time()
@@ -122 +136 @@
                         #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 +153 @@
                     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 +176 @@
             #    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))
 
 

anuga_core/source/anuga_parallel/parallel_api.py

@@ -4 +4 @@
 """
 
-from Numeric import zeros
+
 
 # The abstract Python-MPI interface
@@ -168 +168 @@
 
 
+
+
     # Build the mesh that should be assigned to each processor,
     # this includes ghost nodes and the communication pattern

anuga_core/source/anuga_parallel/parallel_meshes.py

@@ -15 +15 @@
 
 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 +87 @@
     E = EIndex(n,m)
 
-    points = zeros( (Np,2), Float)
+    points = num.zeros( (Np,2), num.float)
 
     for i in range(m+1):
@@ -98 +99 @@
 
 
-    elements = zeros( (Nt,3), Int)
+    elements = num.zeros( (Nt,3), num.int)
     boundary = {}
     Idgl = []
@@ -170 +171 @@
         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 +185 @@
         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 +253 @@
     E = EIndex(n,m)
 
-    points = zeros( (Np,2), Float)
+    points = num.zeros( (Np,2), num.float)
 
     for i in range(m+1):
@@ -264 +265 @@
 
 
-    elements = zeros( (Nt,3), Int)
+    elements = num.zeros( (Nt,3), num.int)
     boundary = {}
     ghosts = {}
@@ -389 +390 @@
     E = EIndex(n,m)
 
-    points = zeros( (Np,2), Float)
+    points = num.zeros( (Np,2), num.float)
 
     for i in range(m+1):
@@ -401 +402 @@
 
 
-    elements = zeros( (Nt,3), Int)
+    elements = num.zeros( (Nt,3), num.int)
     boundary = {}
     ghosts = {}

anuga_core/source/anuga_parallel/parallel_shallow_water.py

@@ -23 +23 @@
 
 from anuga.shallow_water.shallow_water_domain import *
-from Numeric import zeros, Float, Int, ones, allclose, array
+
+
+import numpy as num
 
 import pypar
@@ -57 +59 @@
 #        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 +70 @@
 
         # 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)
 
 

anuga_core/source/anuga_parallel/pmesh_divide.py

@@ -12 +12 @@
 #  Modified: Linda Stals, Nov 2005
 #            Jack Kelly, Nov 2005
+#            Steve Roberts, Aug 2009 (updating to numpy)
 #
 #
@@ -20 +21 @@
 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 +50 @@
     # Temporary storage area
 
-    index = zeros(N, Int)
+    index = num.zeros(N, num.int)
     q_reord = {}
 
@@ -62 +63 @@
 
     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 +89 @@
 
 try:
-    
     from pymetis.metis import partMeshNodal
 except ImportError:
@@ -96 +96 @@
     print "***************************************************"
     raise ImportError
+
 def pmesh_divide_metis(domain, n_procs):
     
@@ -121 +122 @@
         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 +134 @@
         # 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 +185 @@
         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 +196 @@
     # 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]

anuga_core/source/anuga_parallel/run_advection.py

@@ -4 +4 @@
 #========================================================================
 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 +30 @@
 #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
 
 

anuga_core/source/anuga_parallel/run_parallel_advection.py

@@ -48 +48 @@
 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 +124 @@
 # Let processor 0 output some timing information
 
-visualise = True
+visualise = False
 if visualise:
     from anuga.visualiser import RealtimeVisualiser
@@ -137 +140 @@
     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()

anuga_core/source/anuga_parallel/test_parallel_sw_runup.py

@@ -15 +15 @@
 #------------------------------------------------------------------------------
 
-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 +163 @@
     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])