Changeset 7400 for anuga_core/source/anuga_parallel/build_commun.py

Timestamp:

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

Author:

steve

Message:

Commit a working copy of numpy version of build_commun

File:

• anuga_core/source/anuga_parallel/build_commun.py (modified) (13 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()