def old_distribute(domain, verbose=False, debug=False, parameters=None): """ Distribute the domain to all processes parameters values """ if debug: verbose = True barrier() # FIXME: Dummy assignment (until boundaries are refactored to # be independent of domains until they are applied) if myid == 0: bdmap = {} for tag in domain.get_boundary_tags(): bdmap[tag] = None domain.set_boundary(bdmap) if not pypar_available or numprocs == 1: return domain # Bypass # For some obscure reason this communication must happen prior to # the more complex mesh distribution - Oh Well! if myid == 0: domain_name = domain.get_name() domain_dir = domain.get_datadir() domain_store = domain.get_store() domain_store_centroids = domain.get_store_centroids() domain_smooth = domain.smooth domain_reduction = domain.reduction domain_minimum_storable_height = domain.minimum_storable_height domain_flow_algorithm = domain.get_flow_algorithm() domain_minimum_allowed_height = domain.get_minimum_allowed_height() georef = domain.geo_reference number_of_global_triangles = domain.number_of_triangles number_of_global_nodes = domain.number_of_nodes # FIXME - what other attributes need to be transferred? for p in xrange(1, numprocs): # FIXME SR: Creates cPickle dump send((domain_name, domain_dir, domain_store, \ domain_store_centroids, domain_smooth, domain_reduction, \ domain_minimum_storable_height, domain_flow_algorithm, \ domain_minimum_allowed_height, georef, \ number_of_global_triangles, number_of_global_nodes), p) else: if verbose: print 'P%d: Receiving domain attributes' % (myid) domain_name, domain_dir, domain_store, \ domain_store_centroids, domain_smooth, domain_reduction, \ domain_minimum_storable_height, domain_flow_algorithm, \ domain_minimum_allowed_height, georef, \ number_of_global_triangles, \ number_of_global_nodes = receive(0) # Distribute boundary conditions # FIXME: This cannot handle e.g. Time_boundaries due to # difficulties pickling functions if myid == 0: boundary_map = domain.boundary_map for p in xrange(1, numprocs): # FIXME SR: Creates cPickle dump send(boundary_map, p) else: if verbose: print 'P%d: Receiving boundary map' % (myid) boundary_map = receive(0) send_s2p = False if myid == 0: # Partition and distribute mesh. # Structures returned is in the # correct form for the ANUGA data structure points, vertices, boundary, quantities,\ ghost_recv_dict, full_send_dict,\ number_of_full_nodes, number_of_full_triangles,\ s2p_map, p2s_map, tri_map, node_map, tri_l2g, node_l2g, \ ghost_layer_width =\ distribute_mesh(domain, verbose=verbose, debug=debug, parameters=parameters) # Extract l2g maps #tri_l2g = extract_l2g_map(tri_map) #node_l2g = extract_l2g_map(node_map) #tri_l2g = p2s_map[tri_l2g] if debug: print 'P%d' % myid print 'tri_map ', tri_map print 'node_map', node_map print 'tri_l2g', tri_l2g print 'node_l2g', node_l2g print 's2p_map', s2p_map print 'p2s_map', p2s_map def protocol(x): vanilla = False import pypar control_info, x = pypar.create_control_info(x, vanilla, return_object=True) print 'protocol', control_info[0] # Send serial to parallel (s2p) and parallel to serial (p2s) triangle mapping to proc 1 .. numprocs if send_s2p: n = len(s2p_map) s2p_map_keys_flat = num.reshape(num.array(s2p_map.keys(), num.int), (n, 1)) s2p_map_values_flat = num.array(s2p_map.values(), num.int) s2p_map_flat = num.concatenate( (s2p_map_keys_flat, s2p_map_values_flat), axis=1) n = len(p2s_map) p2s_map_keys_flat = num.reshape(num.array(p2s_map.keys(), num.int), (n, 2)) p2s_map_values_flat = num.reshape( num.array(p2s_map.values(), num.int), (n, 1)) p2s_map_flat = num.concatenate( (p2s_map_keys_flat, p2s_map_values_flat), axis=1) for p in range(1, numprocs): # FIXME SR: Creates cPickle dump send(s2p_map_flat, p) # FIXME SR: Creates cPickle dump #print p2s_map send(p2s_map_flat, p) else: if verbose: print 'Not sending s2p_map and p2s_map' s2p_map = None p2s_map = None if verbose: print 'Communication done' else: # Read in the mesh partition that belongs to this # processor if verbose: print 'P%d: Receiving submeshes' % (myid) points, vertices, boundary, quantities,\ ghost_recv_dict, full_send_dict,\ number_of_full_nodes, number_of_full_triangles, \ tri_map, node_map, tri_l2g, node_l2g, ghost_layer_width =\ rec_submesh(0, verbose) # Extract l2g maps #tri_l2g = extract_l2g_map(tri_map) #node_l2g = extract_l2g_map(node_map) #tri_l2g = p2s_map[tri_l2g] # Receive serial to parallel (s2p) and parallel to serial (p2s) triangle mapping if send_s2p: s2p_map_flat = receive(0) s2p_map = dict.fromkeys(s2p_map_flat[:, 0], s2p_map_flat[:, 1:2]) p2s_map_flat = receive(0) p2s_map_keys = [tuple(x) for x in p2s_map_flat[:, 0:1]] p2s_map = dict.fromkeys(p2s_map_keys, p2s_map_flat[:, 2]) else: s2p_map = None p2s_map = None #------------------------------------------------------------------------ # Build the domain for this processor using partion structures #------------------------------------------------------------------------ if verbose: print 'myid = %g, no_full_nodes = %g, no_full_triangles = %g' % ( myid, number_of_full_nodes, number_of_full_triangles) domain = Parallel_domain( points, vertices, boundary, full_send_dict=full_send_dict, ghost_recv_dict=ghost_recv_dict, number_of_full_nodes=number_of_full_nodes, number_of_full_triangles=number_of_full_triangles, geo_reference=georef, number_of_global_triangles=number_of_global_triangles, number_of_global_nodes=number_of_global_nodes, s2p_map=s2p_map, p2s_map=p2s_map, ## jj added this tri_l2g=tri_l2g, ## SR added this node_l2g=node_l2g, ghost_layer_width=ghost_layer_width) #------------------------------------------------------------------------ # Transfer initial conditions to each subdomain #------------------------------------------------------------------------ for q in quantities: domain.set_quantity(q, quantities[q]) #------------------------------------------------------------------------ # Transfer boundary conditions to each subdomain #------------------------------------------------------------------------ boundary_map['ghost'] = None # Add binding to ghost boundary domain.set_boundary(boundary_map) #------------------------------------------------------------------------ # Transfer other attributes to each subdomain #------------------------------------------------------------------------ domain.set_name(domain_name) domain.set_datadir(domain_dir) domain.set_store(domain_store) domain.set_store_centroids(domain_store_centroids) domain.set_store_vertices_smoothly(domain_smooth, domain_reduction) domain.set_minimum_storable_height(domain_minimum_storable_height) domain.set_minimum_allowed_height(domain_minimum_allowed_height) domain.set_flow_algorithm(domain_flow_algorithm) domain.geo_reference = georef #------------------------------------------------------------------------ # Return parallel domain to all nodes #------------------------------------------------------------------------ return domain
def distibute_three_processors(): """ Do a parallel test of distributing a rectangle onto 3 processors """ # FIXME: Need to update expected values on macos if sys.platform == 'darwin': return # FIXME: Need to update expected values on macos #if sys.platform == 'win32': # return from anuga.utilities import parallel_abstraction as pypar myid = pypar.rank() numprocs = pypar.size() if not numprocs == 3: return try: import pymetis metis_version = 5 except: metis_version = 4 #print numprocs #barrier() if myid == 0: nodes_0, triangles_0, boundary_0 = rectangular_cross(2, 2) domain = Domain(nodes_0, triangles_0, boundary_0) domain.set_quantity('elevation', topography) # Use function for elevation domain.set_quantity('friction', 0.0) # Constant friction domain.set_quantity('stage', expression='elevation') # Dry initial stage domain.set_quantity('xmomentum', expression='friction + 2.0') domain.set_quantity('ymomentum', ycoord) #---------------------------------------------------------------------------------- # Test pmesh_divide_metis #---------------------------------------------------------------------------------- vertices, triangles, boundary, triangles_per_proc, quantities = pmesh_divide_metis( domain, numprocs) if False: print_seq_values(vertices, triangles, triangles_per_proc) true_seq_values = get_true_seq_values(metis_version=metis_version) if False: print("True Seq Values = \\") pprint(true_seq_values) assert_allclose(vertices, true_seq_values['vertices']) assert_allclose(triangles, true_seq_values['triangles']) assert_allclose(triangles_per_proc, true_seq_values['triangles_per_proc']) #---------------------------------------------------------------------------------- # Test build_submesh #---------------------------------------------------------------------------------- submesh = build_submesh(vertices, triangles, boundary, quantities, triangles_per_proc) if False: print('submesh_values = \\') print_submesh_values(submesh) true_values = get_true_submesh_values(metis_version) assert_allclose(submesh['full_nodes'][0], true_values['full_nodes_0']) assert_allclose(submesh['full_nodes'][1], true_values['full_nodes_1']) assert_allclose(submesh['full_nodes'][2], true_values['full_nodes_2']) assert_allclose(submesh['ghost_nodes'][0], true_values['ghost_nodes_0']) assert_allclose(submesh['ghost_nodes'][1], true_values['ghost_nodes_1']) assert_allclose(submesh['ghost_nodes'][2], true_values['ghost_nodes_2']) assert_allclose(submesh['full_triangles'][0], true_values['full_triangles_0']) assert_allclose(submesh['full_triangles'][1], true_values['full_triangles_1']) assert_allclose(submesh['full_triangles'][2], true_values['full_triangles_2']) assert_allclose(submesh['ghost_triangles'][0], true_values['ghost_triangles_0']) assert_allclose(submesh['ghost_triangles'][1], true_values['ghost_triangles_1']) assert_allclose(submesh['ghost_triangles'][2], true_values['ghost_triangles_2']) assert_allclose(submesh['ghost_commun'][0], true_values['ghost_commun_0']) assert_allclose(submesh['ghost_commun'][1], true_values['ghost_commun_1']) assert_allclose(submesh['ghost_commun'][2], true_values['ghost_commun_2']) assert_(submesh['full_commun'] == true_values['full_commun']) barrier() #-------------------------------- # Now do the comunnication part #-------------------------------- if myid == 0: points, vertices, boundary, quantities, \ ghost_recv_dict, full_send_dict, tri_map, node_map, tri_l2g, node_l2g, \ ghost_layer_width =\ extract_submesh(submesh, triangles_per_proc) #---------------------------------------------------------------------------------- # Test send_submesh #---------------------------------------------------------------------------------- for p in range(1, numprocs): send_submesh(submesh, triangles_per_proc, p, verbose=False) else: #---------------------------------------------------------------------------------- # Test rec_submesh #---------------------------------------------------------------------------------- points, triangles, boundary, quantities, \ ghost_recv_dict, full_send_dict, \ no_full_nodes, no_full_trigs, tri_map, node_map, tri_l2g, node_l2g, \ ghost_layer_width = \ rec_submesh(0, verbose=False) barrier() #-------------------------------- # Now do the test #-------------------------------- if myid == 0: if False: print('extract_values = \\') print_extract_submesh(points, triangles, ghost_recv_dict, \ full_send_dict, tri_map, node_map, ghost_layer_width) true_values = get_true_extract_submesh(metis_version) assert_allclose(points, true_values['points']) assert_allclose(triangles, true_values['triangles']) assert_allclose(ghost_recv_dict[1], true_values['ghost_recv_dict_1']) assert_allclose(ghost_recv_dict[2], true_values['ghost_recv_dict_2']) assert_allclose(full_send_dict[1], true_values['full_send_dict_1']) assert_allclose(full_send_dict[2], true_values['full_send_dict_2']) assert_allclose(tri_map, true_values['tri_map']) assert_allclose(node_map, true_values['node_map']) assert_allclose(ghost_layer_width, true_values['ghost_layer_width']) if myid == 1: if False: print("rec_submesh_1 = \\") print_rec_submesh_1(points, triangles, ghost_recv_dict, full_send_dict, \ tri_map, node_map, ghost_layer_width) true_values = get_true_rec_submesh_1(metis_version) if False: print('true_rec_values_1 = \\') pprint(true_values) assert_allclose(points, true_values['points']) assert_allclose(triangles, true_values['triangles']) assert_allclose(ghost_recv_dict[0], true_values['ghost_recv_dict_0']) assert_allclose(ghost_recv_dict[2], true_values['ghost_recv_dict_2']) assert_allclose(full_send_dict[0], true_values['full_send_dict_0']) assert_allclose(full_send_dict[2], true_values['full_send_dict_2']) assert_allclose(tri_map, true_values['tri_map']) assert_allclose(node_map, true_values['node_map']) assert_allclose(ghost_layer_width, true_values['ghost_layer_width']) if myid == 2: if False: print("rec_submesh_2 = \\") print_rec_submesh_2(points, triangles, ghost_recv_dict, full_send_dict, \ tri_map, node_map, ghost_layer_width) true_values = get_true_rec_submesh_2(metis_version) if False: print('true_rec_values_2 = \\') pprint(true_values) assert_allclose(points, true_values['points']) assert_allclose(triangles, true_values['triangles']) assert_allclose(ghost_recv_dict[0], true_values['ghost_recv_dict_0']) assert_allclose(ghost_recv_dict[1], true_values['ghost_recv_dict_1']) assert_allclose(full_send_dict[0], true_values['full_send_dict_0']) assert_allclose(full_send_dict[1], true_values['full_send_dict_1']) assert_allclose(tri_map, true_values['tri_map']) assert_allclose(node_map, true_values['node_map']) assert_allclose(ghost_layer_width, true_values['ghost_layer_width']) finalize()
def old_distribute(domain, verbose=False, debug=False, parameters = None): """ Distribute the domain to all processes parameters values """ if debug: verbose = True barrier() # FIXME: Dummy assignment (until boundaries are refactored to # be independent of domains until they are applied) if myid == 0: bdmap = {} for tag in domain.get_boundary_tags(): bdmap[tag] = None domain.set_boundary(bdmap) if not pypar_available or numprocs == 1 : return domain # Bypass # For some obscure reason this communication must happen prior to # the more complex mesh distribution - Oh Well! if myid == 0: domain_name = domain.get_name() domain_dir = domain.get_datadir() domain_store = domain.get_store() domain_store_centroids = domain.get_store_centroids() domain_smooth = domain.smooth domain_reduction = domain.reduction domain_minimum_storable_height = domain.minimum_storable_height domain_flow_algorithm = domain.get_flow_algorithm() domain_minimum_allowed_height = domain.get_minimum_allowed_height() georef = domain.geo_reference number_of_global_triangles = domain.number_of_triangles number_of_global_nodes = domain.number_of_nodes # FIXME - what other attributes need to be transferred? for p in xrange(1, numprocs): # FIXME SR: Creates cPickle dump send((domain_name, domain_dir, domain_store, \ domain_store_centroids, domain_smooth, domain_reduction, \ domain_minimum_storable_height, domain_flow_algorithm, \ domain_minimum_allowed_height, georef, \ number_of_global_triangles, number_of_global_nodes), p) else: if verbose: print 'P%d: Receiving domain attributes' %(myid) domain_name, domain_dir, domain_store, \ domain_store_centroids, domain_smooth, domain_reduction, \ domain_minimum_storable_height, domain_flow_algorithm, \ domain_minimum_allowed_height, georef, \ number_of_global_triangles, \ number_of_global_nodes = receive(0) # Distribute boundary conditions # FIXME: This cannot handle e.g. Time_boundaries due to # difficulties pickling functions if myid == 0: boundary_map = domain.boundary_map for p in xrange(1, numprocs): # FIXME SR: Creates cPickle dump send(boundary_map, p) else: if verbose: print 'P%d: Receiving boundary map' %(myid) boundary_map = receive(0) send_s2p = False if myid == 0: # Partition and distribute mesh. # Structures returned is in the # correct form for the ANUGA data structure points, vertices, boundary, quantities,\ ghost_recv_dict, full_send_dict,\ number_of_full_nodes, number_of_full_triangles,\ s2p_map, p2s_map, tri_map, node_map, tri_l2g, node_l2g, \ ghost_layer_width =\ distribute_mesh(domain, verbose=verbose, debug=debug, parameters=parameters) # Extract l2g maps #tri_l2g = extract_l2g_map(tri_map) #node_l2g = extract_l2g_map(node_map) #tri_l2g = p2s_map[tri_l2g] if debug: print 'P%d' %myid print 'tri_map ',tri_map print 'node_map',node_map print 'tri_l2g', tri_l2g print 'node_l2g', node_l2g print 's2p_map', s2p_map print 'p2s_map', p2s_map def protocol(x): vanilla=False import pypar control_info, x = pypar.create_control_info(x, vanilla, return_object=True) print 'protocol', control_info[0] # Send serial to parallel (s2p) and parallel to serial (p2s) triangle mapping to proc 1 .. numprocs if send_s2p : n = len(s2p_map) s2p_map_keys_flat = num.reshape(num.array(s2p_map.keys(),num.int), (n,1) ) s2p_map_values_flat = num.array(s2p_map.values(),num.int) s2p_map_flat = num.concatenate( (s2p_map_keys_flat, s2p_map_values_flat), axis=1 ) n = len(p2s_map) p2s_map_keys_flat = num.reshape(num.array(p2s_map.keys(),num.int), (n,2) ) p2s_map_values_flat = num.reshape(num.array(p2s_map.values(),num.int) , (n,1)) p2s_map_flat = num.concatenate( (p2s_map_keys_flat, p2s_map_values_flat), axis=1 ) for p in range(1, numprocs): # FIXME SR: Creates cPickle dump send(s2p_map_flat, p) # FIXME SR: Creates cPickle dump #print p2s_map send(p2s_map_flat, p) else: if verbose: print 'Not sending s2p_map and p2s_map' s2p_map = None p2s_map = None if verbose: print 'Communication done' else: # Read in the mesh partition that belongs to this # processor if verbose: print 'P%d: Receiving submeshes' %(myid) points, vertices, boundary, quantities,\ ghost_recv_dict, full_send_dict,\ number_of_full_nodes, number_of_full_triangles, \ tri_map, node_map, tri_l2g, node_l2g, ghost_layer_width =\ rec_submesh(0, verbose) # Extract l2g maps #tri_l2g = extract_l2g_map(tri_map) #node_l2g = extract_l2g_map(node_map) #tri_l2g = p2s_map[tri_l2g] # Receive serial to parallel (s2p) and parallel to serial (p2s) triangle mapping if send_s2p : s2p_map_flat = receive(0) s2p_map = dict.fromkeys(s2p_map_flat[:,0], s2p_map_flat[:,1:2]) p2s_map_flat = receive(0) p2s_map_keys = [tuple(x) for x in p2s_map_flat[:,0:1]] p2s_map = dict.fromkeys(p2s_map_keys, p2s_map_flat[:,2]) else: s2p_map = None p2s_map = None #------------------------------------------------------------------------ # Build the domain for this processor using partion structures #------------------------------------------------------------------------ if verbose: print 'myid = %g, no_full_nodes = %g, no_full_triangles = %g' % (myid, number_of_full_nodes, number_of_full_triangles) domain = Parallel_domain(points, vertices, boundary, full_send_dict=full_send_dict, ghost_recv_dict=ghost_recv_dict, number_of_full_nodes=number_of_full_nodes, number_of_full_triangles=number_of_full_triangles, geo_reference=georef, number_of_global_triangles = number_of_global_triangles, number_of_global_nodes = number_of_global_nodes, s2p_map = s2p_map, p2s_map = p2s_map, ## jj added this tri_l2g = tri_l2g, ## SR added this node_l2g = node_l2g, ghost_layer_width = ghost_layer_width) #------------------------------------------------------------------------ # Transfer initial conditions to each subdomain #------------------------------------------------------------------------ for q in quantities: domain.set_quantity(q, quantities[q]) #------------------------------------------------------------------------ # Transfer boundary conditions to each subdomain #------------------------------------------------------------------------ boundary_map['ghost'] = None # Add binding to ghost boundary domain.set_boundary(boundary_map) #------------------------------------------------------------------------ # Transfer other attributes to each subdomain #------------------------------------------------------------------------ domain.set_name(domain_name) domain.set_datadir(domain_dir) domain.set_store(domain_store) domain.set_store_centroids(domain_store_centroids) domain.set_store_vertices_smoothly(domain_smooth,domain_reduction) domain.set_minimum_storable_height(domain_minimum_storable_height) domain.set_minimum_allowed_height(domain_minimum_allowed_height) domain.set_flow_algorithm(domain_flow_algorithm) domain.geo_reference = georef #------------------------------------------------------------------------ # Return parallel domain to all nodes #------------------------------------------------------------------------ return domain
def distibute_three_processors(): """ Do a parallel test of distributing a rectangle onto 3 processors """ # FIXME: Need to update expected values on macos if sys.platform == 'darwin': return import pypar myid = pypar.rank() numprocs = pypar.size() if not numprocs == 3: return #print numprocs barrier() if myid == 0: points, vertices, boundary = rectangular_cross(2,2) domain = Domain(points, vertices, boundary) domain.set_quantity('elevation', topography) # Use function for elevation domain.set_quantity('friction', 0.0) # Constant friction domain.set_quantity('stage', expression='elevation') # Dry initial stage domain.set_quantity('xmomentum', expression='friction + 2.0') # domain.set_quantity('ymomentum', ycoord) # #---------------------------------------------------------------------------------- # Test pmesh_divide_metis #---------------------------------------------------------------------------------- nodes, triangles, boundary, triangles_per_proc, quantities = pmesh_divide_metis(domain,numprocs) assert_(num.allclose(nodes,points)) true_vertices = [[0, 9, 1], [3, 9, 0], [4, 9, 3], [1, 9, 4], [1, 10, 2], [4, 10, 1], [5, 10, 4], [2, 10, 5], [3, 11, 4], [6, 11, 3], [7, 11, 6], [4, 11, 7], [4, 12, 5], [7, 12, 4], [8, 12, 7], [5, 12, 8]] true_triangles = [[4, 9, 3], [4, 12, 5], [7, 12, 4], [8, 12, 7], [5, 12, 8], [0, 9, 1], [1, 9, 4], [1, 10, 2], [4, 10, 1], [5, 10, 4], [2, 10, 5], [3, 9, 0], [3, 11, 4], [6, 11, 3], [7, 11, 6], [4, 11, 7]] assert_(num.allclose(vertices,true_vertices)) assert_(num.allclose(triangles,true_triangles)) assert_(num.allclose(triangles_per_proc,[5,6,5])) #---------------------------------------------------------------------------------- # Test build_submesh #---------------------------------------------------------------------------------- submesh = build_submesh(nodes, triangles, boundary, quantities, triangles_per_proc) assert_(num.allclose(submesh['full_nodes'][0],[[3.0, 0.5, 0.0], [4.0, 0.5, 0.5], [5.0, 0.5, 1.0], [7.0, 1.0, 0.5], [8.0, 1.0, 1.0], [9.0, 0.25, 0.25], [12.0, 0.75, 0.75]])) assert_(num.allclose(submesh['full_nodes'][1],[[0.0, 0.0, 0.0], [1.0, 0.0, 0.5], [2.0, 0.0, 1.0], [4.0, 0.5, 0.5], [5.0, 0.5, 1.0], [9.0, 0.25, 0.25], [10.0, 0.25, 0.75]])) assert_(num.allclose(submesh['full_nodes'][2],[[0.0, 0.0, 0.0], [3.0, 0.5, 0.0], [4.0, 0.5, 0.5], [6.0, 1.0, 0.0], [7.0, 1.0, 0.5], [9.0, 0.25, 0.25], [11.0, 0.75, 0.25]])) assert_(num.allclose(submesh['ghost_nodes'][0],[[0.0, 0.0, 0.0], [1.0, 0.0, 0.5], [2.0, 0.0, 1.0], [6.0, 1.0, 0.0], [10.0, 0.25, 0.75], [11.0, 0.75, 0.25]])) assert_(num.allclose(submesh['ghost_nodes'][1],[[3.0, 0.5, 0.0], [7.0, 1.0, 0.5], [8.0, 1.0, 1.0], [11.0, 0.75, 0.25], [12.0, 0.75, 0.75]])) assert_(num.allclose(submesh['ghost_nodes'][2],[[1.0, 0.0, 0.5], [5.0, 0.5, 1.0], [8.0, 1.0, 1.0], [12.0, 0.75, 0.75]])) true_full_triangles = [num.array([[ 4, 9, 3], [ 4, 12, 5], [ 7, 12, 4], [ 8, 12, 7], [ 5, 12, 8]]), num.array([[ 0, 9, 1], [ 1, 9, 4], [ 1, 10, 2], [ 4, 10, 1], [ 5, 10, 4], [ 2, 10, 5]]), num.array([[ 3, 9, 0], [ 3, 11, 4], [ 6, 11, 3], [ 7, 11, 6], [ 4, 11, 7]])] assert_(num.allclose(submesh['full_triangles'][0],true_full_triangles[0])) assert_(num.allclose(submesh['full_triangles'][1],true_full_triangles[1])) assert_(num.allclose(submesh['full_triangles'][2],true_full_triangles[2])) true_ghost_triangles = [num.array([[ 5, 0, 9, 1], [ 6, 1, 9, 4], [ 8, 4, 10, 1], [ 9, 5, 10, 4], [10, 2, 10, 5], [11, 3, 9, 0], [12, 3, 11, 4], [13, 6, 11, 3], [14, 7, 11, 6], [15, 4, 11, 7]]), num.array([[ 0, 4, 9, 3], [ 1, 4, 12, 5], [ 2, 7, 12, 4], [ 4, 5, 12, 8], [11, 3, 9, 0], [12, 3, 11, 4]]), num.array([[ 0, 4, 9, 3], [ 1, 4, 12, 5], [ 2, 7, 12, 4], [ 3, 8, 12, 7], [ 5, 0, 9, 1], [ 6, 1, 9, 4]])] assert_(num.allclose(submesh['ghost_triangles'][0],true_ghost_triangles[0])) assert_(num.allclose(submesh['ghost_triangles'][1],true_ghost_triangles[1])) assert_(num.allclose(submesh['ghost_triangles'][2],true_ghost_triangles[2])) true_full_commun = [{0: [1, 2], 1: [1, 2], 2: [1, 2], 3: [2], 4: [1]}, {5: [0, 2], 6: [0, 2], 7: [], 8: [0], 9: [0], 10: [0]}, {11: [0, 1], 12: [0, 1], 13: [0], 14: [0], 15: [0]}] assert_(true_full_commun == submesh['full_commun']) true_ghost_commun = [num.array([[ 5, 1], [ 6, 1], [ 8, 1], [ 9, 1], [10, 1], [11, 2], [12, 2], [13, 2], [14, 2], [15, 2]]), num.array([[ 0, 0], [ 1, 0], [ 2, 0], [ 4, 0], [11, 2], [12, 2]]), num.array([[0, 0], [1, 0], [2, 0], [3, 0], [5, 1], [6, 1]])] assert_(num.allclose(submesh['ghost_commun'][0],true_ghost_commun[0])) assert_(num.allclose(submesh['ghost_commun'][1],true_ghost_commun[1])) assert_(num.allclose(submesh['ghost_commun'][2],true_ghost_commun[2])) barrier() #-------------------------------- # Now do the comunnication part #-------------------------------- if myid == 0: #---------------------------------------------------------------------------------- # Test send_submesh #---------------------------------------------------------------------------------- for p in range(1, numprocs): send_submesh(submesh, triangles_per_proc, p, verbose=False) #---------------------------------------------------------------------------------- # Test extract_submesh #---------------------------------------------------------------------------------- points, vertices, boundary, quantities, \ ghost_recv_dict, full_send_dict, tri_map, node_map, tri_l2g, node_l2g, \ ghost_layer_width =\ extract_submesh(submesh, triangles_per_proc) true_points = [[0.5, 0.0], [0.5, 0.5], [0.5, 1.0], [1.0, 0.5], [1.0, 1.0], [0.25, 0.25], [0.75, 0.75], [0.0, 0.0], [0.0, 0.5], [0.0, 1.0], [1.0, 0.0], [0.25, 0.75], [0.75, 0.25]] true_vertices = [[1, 5, 0], [1, 6, 2], [3, 6, 1], [4, 6, 3], [2, 6, 4], [7, 5, 8], [8, 5, 1], [1, 11, 8], [2, 11, 1], [9, 11, 2], [0, 5, 7], [0, 12, 1], [10, 12, 0], [3, 12, 10], [1, 12, 3]] true_ghost_recv = {1: [num.array([5, 6, 7, 8, 9]), num.array([ 5, 6, 8, 9, 10])], 2: [num.array([10, 11, 12, 13, 14]), num.array([11, 12, 13, 14, 15])]} true_full_send = {1: [num.array([0, 1, 2, 4]), num.array([0, 1, 2, 4])], 2: [num.array([0, 1, 2, 3]), num.array([0, 1, 2, 3])]} assert_(num.allclose(ghost_layer_width, 2)) assert_(num.allclose(points, true_points)) assert_(num.allclose(vertices, true_vertices)) assert_(num.allclose(ghost_recv_dict[1],true_ghost_recv[1])) assert_(num.allclose(ghost_recv_dict[2],true_ghost_recv[2])) assert_(num.allclose(full_send_dict[1],true_full_send[1])) assert_(num.allclose(full_send_dict[2],true_full_send[2])) #print triangles_per_proc else: #---------------------------------------------------------------------------------- # Test rec_submesh #---------------------------------------------------------------------------------- points, vertices, boundary, quantities, \ ghost_recv_dict, full_send_dict, \ no_full_nodes, no_full_trigs, tri_map, node_map, tri_l2g, node_l2g, \ ghost_layer_width = \ rec_submesh(0, verbose=False) if myid == 1: true_points = [[0.0, 0.0], [0.0, 0.5], [0.0, 1.0], [0.5, 0.5], [0.5, 1.0], [0.25, 0.25], [0.25, 0.75], [0.5, 0.0], [1.0, 0.5], [1.0, 1.0], [0.75, 0.25], [0.75, 0.75]] true_vertices = [[0, 5, 1], [1, 5, 3], [1, 6, 2], [3, 6, 1], [4, 6, 3], [2, 6, 4], [3, 5, 7], [3, 11, 4], [8, 11, 3], [4, 11, 9], [7, 5, 0], [7, 10, 3]] true_ghost_recv = {0: [num.array([6, 7, 8, 9]), num.array([0, 1, 2, 4])], 2: [num.array([10, 11]), num.array([11, 12])]} true_full_send = {0: [num.array([0, 1, 3, 4, 5]), num.array([ 5, 6, 8, 9, 10])], 2: [num.array([0, 1]), num.array([5, 6])]} true_tri_map = num.array([ 6, 7, 8, -1, 9, 0, 1, 2, 3, 4, 5, 10, 11]) true_node_map = num.array([ 0, 1, 2, 7, 3, 4, -1, 8, 9, 5, 6, 10, 11]) assert_(num.allclose(ghost_layer_width, 2)) assert_(num.allclose(tri_map, true_tri_map)) assert_(num.allclose(node_map, true_node_map)) assert_(num.allclose(points, true_points)) assert_(num.allclose(vertices, true_vertices)) assert_(num.allclose(ghost_recv_dict[0],true_ghost_recv[0])) assert_(num.allclose(ghost_recv_dict[2],true_ghost_recv[2])) assert_(num.allclose(full_send_dict[0],true_full_send[0])) assert_(num.allclose(full_send_dict[2],true_full_send[2])) if myid == 2: true_points = [[0.0, 0.0], [0.5, 0.0], [0.5, 0.5], [1.0, 0.0], [1.0, 0.5], [0.25, 0.25], [0.75, 0.25], [0.0, 0.5], [0.5, 1.0], [1.0, 1.0], [0.75, 0.75]] true_vertices = [[1, 5, 0], [1, 6, 2], [3, 6, 1], [4, 6, 3], [2, 6, 4], [2, 5, 1], [2, 10, 8], [4, 10, 2], [9, 10, 4], [0, 5, 7], [7, 5, 2]] true_ghost_recv = {0: [num.array([5, 6, 7, 8]), num.array([0, 1, 2, 3])], 1: [num.array([ 9, 10]), num.array([5, 6])]} true_full_send = {0: [num.array([0, 1, 2, 3, 4]), num.array([11, 12, 13, 14, 15])], 1: [num.array([0, 1]), num.array([11, 12])]} true_tri_map = num.array([5, 6, 7, 8, -1, 9, 10, -1, -1, -1, -1, 0, 1, 2, 3, 4, -1]) true_node_map = num.array([ 0, 7, -1, 1, 2, 8 , 3, 4, 9, 5, -1, 6, 10]) assert_(num.allclose(ghost_layer_width, 2)) assert_(num.allclose(tri_map, true_tri_map)) assert_(num.allclose(node_map, true_node_map)) assert_(num.allclose(points, true_points)) assert_(num.allclose(vertices, true_vertices)) assert_(num.allclose(ghost_recv_dict[0],true_ghost_recv[0])) assert_(num.allclose(ghost_recv_dict[1],true_ghost_recv[1])) assert_(num.allclose(full_send_dict[0],true_full_send[0])) assert_(num.allclose(full_send_dict[1],true_full_send[1]))