def distribute(self, numprocs=1):
self.numprocs = numprocs
domain = self.domain
verbose = self.verbose
debug = self.debug
parameters = self.parameters
# FIXME: Dummy assignment (until boundaries are refactored to
# be independent of domains until they are applied)
bdmap = {}
for tag in domain.get_boundary_tags():
bdmap[tag] = None
domain.set_boundary(bdmap)
self.domain_name = domain.get_name()
self.domain_dir = domain.get_datadir()
self.domain_store = domain.get_store()
self.domain_store_centroids = domain.get_store_centroids()
self.domain_minimum_storable_height = domain.minimum_storable_height
self.domain_flow_algorithm = domain.get_flow_algorithm()
self.domain_minimum_allowed_height = domain.get_minimum_allowed_height()
self.domain_georef = domain.geo_reference
self.number_of_global_triangles = domain.number_of_triangles
self.number_of_global_nodes = domain.number_of_nodes
self.boundary_map = domain.boundary_map
# Subdivide the mesh
if verbose: print 'sequential_distribute: Subdivide mesh'
new_nodes, new_triangles, new_boundary, triangles_per_proc, quantities, \
s2p_map, p2s_map = \
pmesh_divide_metis_with_map(domain, numprocs)
# Build the mesh that should be assigned to each processor,
# this includes ghost nodes and the communication pattern
if verbose: print 'sequential_distribute: Build submeshes'
if verbose: print 'sequential_distribute: parameters = ',parameters
submesh = build_submesh(new_nodes, new_triangles, new_boundary, \
quantities, triangles_per_proc, parameters=parameters)
if verbose:
for p in range(numprocs):
N = len(submesh['ghost_nodes'][p])
M = len(submesh['ghost_triangles'][p])
print 'There are %d ghost nodes and %d ghost triangles on proc %d'\
%(N, M, p)
self.submesh = submesh
self.triangles_per_proc = triangles_per_proc
self.p2s_map = p2s_map
def distribute(self, numprocs=1):
self.numprocs = numprocs
domain = self.domain
verbose = self.verbose
debug = self.debug
parameters = self.parameters
# FIXME: Dummy assignment (until boundaries are refactored to
# be independent of domains until they are applied)
bdmap = {}
for tag in domain.get_boundary_tags():
bdmap[tag] = None
domain.set_boundary(bdmap)
self.domain_name = domain.get_name()
self.domain_dir = domain.get_datadir()
self.domain_store = domain.get_store()
self.domain_store_centroids = domain.get_store_centroids()
self.domain_minimum_storable_height = domain.minimum_storable_height
self.domain_flow_algorithm = domain.get_flow_algorithm()
self.domain_minimum_allowed_height = domain.get_minimum_allowed_height(
)
self.domain_georef = domain.geo_reference
self.domain_quantities_to_be_stored = domain.quantities_to_be_stored
self.domain_smooth = domain.smooth
self.domain_low_froude = domain.low_froude
self.number_of_global_triangles = domain.number_of_triangles
self.number_of_global_nodes = domain.number_of_nodes
self.boundary_map = domain.boundary_map
# Subdivide the mesh
if verbose: print 'sequential_distribute: Subdivide mesh'
new_nodes, new_triangles, new_boundary, triangles_per_proc, quantities, \
s2p_map, p2s_map = \
pmesh_divide_metis_with_map(domain, numprocs)
# Build the mesh that should be assigned to each processor,
# this includes ghost nodes and the communication pattern
if verbose: print 'sequential_distribute: Build submeshes'
if verbose: print 'sequential_distribute: parameters = ', parameters
submesh = build_submesh(new_nodes, new_triangles, new_boundary, \
quantities, triangles_per_proc, parameters=parameters)
if verbose:
for p in range(numprocs):
N = len(submesh['ghost_nodes'][p])
M = len(submesh['ghost_triangles'][p])
print 'There are %d ghost nodes and %d ghost triangles on proc %d'\
%(N, M, p)
self.submesh = submesh
self.triangles_per_proc = triangles_per_proc
self.p2s_map = p2s_map
def distribute_mesh(domain, verbose=False, debug=False, parameters=None):
""" Distribute andsend the mesh info to all the processors.
Should only be run from processor 0 and will send info to the other
processors.
There should be a corresponding rec_submesh called from all the other
processors
"""
if debug:
verbose = True
numprocs = size()
# Subdivide the mesh
if verbose: print 'Subdivide mesh'
new_nodes, new_triangles, new_boundary, triangles_per_proc, quantities, \
s2p_map, p2s_map = \
pmesh_divide_metis_with_map(domain, numprocs)
#PETE: s2p_map (maps serial domain triangles to parallel domain triangles)
# sp2_map (maps parallel domain triangles to domain triangles)
# Build the mesh that should be assigned to each processor,
# this includes ghost nodes and the communication pattern
if verbose: print 'Build submeshes'
submesh = build_submesh(new_nodes, new_triangles, new_boundary, quantities,
triangles_per_proc, parameters)
if verbose:
for p in range(numprocs):
N = len(submesh['ghost_nodes'][p])
M = len(submesh['ghost_triangles'][p])
print 'There are %d ghost nodes and %d ghost triangles on proc %d'\
%(N, M, p)
#if debug:
# from pprint import pprint
# pprint(submesh)
# Send the mesh partition to the appropriate processor
if verbose: print 'Distribute submeshes'
for p in range(1, numprocs):
send_submesh(submesh, triangles_per_proc, p2s_map, p, verbose)
# Build the local mesh for processor 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, p2s_map, 0)
# Keep track of the number full nodes and triangles.
# This is useful later if one needs access to a ghost-free domain
# Here, we do it for process 0. The others are done in rec_submesh.
number_of_full_nodes = len(submesh['full_nodes'][0])
number_of_full_triangles = len(submesh['full_triangles'][0])
#print
#for p in range(numprocs):
# print 'Process %d:' %(p)
#
# print 'full_triangles:'
# print submesh['full_triangles'][p]
#
# print 'full_nodes:'
# print submesh['full_nodes'][p]
#
# print 'ghost_triangles:'
# print submesh['ghost_triangles'][p]#
#
# print 'ghost_nodes:'
# print submesh['ghost_nodes'][p]
# print
#
#print 'Receive dict'
#print ghost_recv_dict
#
#print 'Send dict'
#print full_send_dict
# Return structures necessary for building the parallel domain
return 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
def distribute_mesh(domain, verbose=False, debug=False, parameters=None):
""" Distribute andsend the mesh info to all the processors.
Should only be run from processor 0 and will send info to the other
processors.
There should be a corresponding rec_submesh called from all the other
processors
"""
if debug:
verbose = True
numprocs = size()
# Subdivide the mesh
if verbose: print 'Subdivide mesh'
new_nodes, new_triangles, new_boundary, triangles_per_proc, quantities, \
s2p_map, p2s_map = \
pmesh_divide_metis_with_map(domain, numprocs)
#PETE: s2p_map (maps serial domain triangles to parallel domain triangles)
# sp2_map (maps parallel domain triangles to domain triangles)
# Build the mesh that should be assigned to each processor,
# this includes ghost nodes and the communication pattern
if verbose: print 'Build submeshes'
submesh = build_submesh(new_nodes, new_triangles, new_boundary, quantities, triangles_per_proc, parameters)
if verbose:
for p in range(numprocs):
N = len(submesh['ghost_nodes'][p])
M = len(submesh['ghost_triangles'][p])
print 'There are %d ghost nodes and %d ghost triangles on proc %d'\
%(N, M, p)
#if debug:
# from pprint import pprint
# pprint(submesh)
# Send the mesh partition to the appropriate processor
if verbose: print 'Distribute submeshes'
for p in range(1, numprocs):
send_submesh(submesh, triangles_per_proc, p2s_map, p, verbose)
# Build the local mesh for processor 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, p2s_map, 0)
# Keep track of the number full nodes and triangles.
# This is useful later if one needs access to a ghost-free domain
# Here, we do it for process 0. The others are done in rec_submesh.
number_of_full_nodes = len(submesh['full_nodes'][0])
number_of_full_triangles = len(submesh['full_triangles'][0])
#print
#for p in range(numprocs):
# print 'Process %d:' %(p)
#
# print 'full_triangles:'
# print submesh['full_triangles'][p]
#
# print 'full_nodes:'
# print submesh['full_nodes'][p]
#
# print 'ghost_triangles:'
# print submesh['ghost_triangles'][p]#
#
# print 'ghost_nodes:'
# print submesh['ghost_nodes'][p]
# print
#
#print 'Receive dict'
#print ghost_recv_dict
#
#print 'Send dict'
#print full_send_dict
# Return structures necessary for building the parallel domain
return 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
