diff --git a/meshmode/mesh/__init__.py b/meshmode/mesh/__init__.py index f3966e75b5523fca6a1f6c7cd33d88eef0c0302a..d400f9ef24c39c0ffb92f081441112c0a4327ab4 100644 --- a/meshmode/mesh/__init__.py +++ b/meshmode/mesh/__init__.py @@ -434,7 +434,10 @@ class InterPartitionAdj(): .. attribute:: neighbors ``neighbors[i]`` gives the element number within the neighboring partiton - of the element connected to ``elements[i]``. + of the element connected to ``elements[i]``. This gives a mesh-wide element + numbering. Use ``Mesh.find_igrp()`` to find the group that the element + belongs to, then subtract ``element_nr_base`` to find the element of the + group. .. attribute:: neighbor_faces @@ -477,13 +480,15 @@ class InterPartitionAdj(): :arg face :returns: A tuple ``(part_idx, neighbor_elem, neighbor_face)`` of neighboring elements within another :class:`Mesh`. + Or (-1, -1, -1) if the face does not have a neighbor. """ for idx in range(len(self.elements)): if elem == self.elements[idx] and face == self.element_faces[idx]: return (self.part_indices[idx], self.neighbors[idx], self.neighbor_faces[idx]) - raise RuntimeError("This face does not have a neighbor") + #raise RuntimeError("This face does not have a neighbor") + return (-1, -1, -1) # }}} diff --git a/meshmode/mesh/processing.py b/meshmode/mesh/processing.py index d1d57feeb460fea729b44871e6f28d5a2c9c8786..19d8e9f788fc84ce32dace56517c46ba03ca51e4 100644 --- a/meshmode/mesh/processing.py +++ b/meshmode/mesh/processing.py @@ -148,7 +148,7 @@ def partition_mesh(mesh, part_per_element, part_nr): facial_adjacency_groups=None, boundary_tags=boundary_tags) from meshmode.mesh import InterPartitionAdj - interpart_grps = [InterPartitionAdj() for _ in range(len(part_mesh.groups))] + adj_grps = [InterPartitionAdj() for _ in range(len(part_mesh.groups))] for igrp, grp in enumerate(part_mesh.groups): elem_base = grp.element_nr_base @@ -160,9 +160,10 @@ def partition_mesh(mesh, part_per_element, part_nr): tags = -boundary_adj.neighbors[adj_idx] assert tags >= 0, "Expected boundary tag in adjacency group." - parent_igrp = mesh.find_igrp(queried_elems[elem + elem_base]) + p_meshwide_elem = queried_elems[elem + elem_base] + parent_igrp = mesh.find_igrp(p_meshwide_elem) parent_elem_base = mesh.groups[parent_igrp].element_nr_base - parent_elem = queried_elems[elem + elem_base] - parent_elem_base + parent_elem = p_meshwide_elem - parent_elem_base parent_adj = mesh.facial_adjacency_groups[parent_igrp] @@ -184,16 +185,16 @@ def partition_mesh(mesh, part_per_element, part_nr): n_elem = np.count_nonzero( part_per_element[:rank_neighbor] == n_part_num) - interpart_grps[igrp].add_connection( - elem + elem_base, - face, - n_part_num, - n_elem, - rank_neighbor_face) + adj_grps[igrp].add_connection( + elem, + face, + n_part_num, + n_elem, + rank_neighbor_face) - mesh = part_mesh.copy() - mesh.interpart_adj_groups = interpart_grps - return mesh, queried_elems + connected_mesh = part_mesh.copy() + connected_mesh.interpart_adj_groups = adj_grps + return connected_mesh, queried_elems # }}} diff --git a/test/test_meshmode.py b/test/test_meshmode.py index 0b5f99f6f823cd2c902c1c14f9984cdc0455643e..c29f013ad5deba8c74038827687f8ada8a1e2a30 100644 --- a/test/test_meshmode.py +++ b/test/test_meshmode.py @@ -94,10 +94,13 @@ def test_partition_interpolation(ctx_getter): def test_partition_mesh(): n = 5 num_parts = 7 - from meshmode.mesh.generation import generate_regular_rect_mesh + order = 4 + dim = 3 + from meshmode.mesh.generation import (generate_regular_rect_mesh, + generate_warped_rect_mesh) mesh1 = generate_regular_rect_mesh(a=(0, 0, 0), b=(1, 1, 1), n=(n, n, n)) mesh2 = generate_regular_rect_mesh(a=(2, 2, 2), b=(3, 3, 3), n=(n, n, n)) - mesh3 = generate_regular_rect_mesh(a=(1, 2, 2), b=(2, 3, 3), n=(n, n, n)) + mesh3 = generate_warped_rect_mesh(dim, order=order, n=n) from meshmode.mesh.processing import merge_disjoint_meshes mesh = merge_disjoint_meshes([mesh1, mesh2, mesh3]) @@ -131,28 +134,31 @@ def test_partition_mesh(): for part_num in range(num_parts): part, part_to_global = new_meshes[part_num] for grp_num, f_groups in enumerate(part.facial_adjacency_groups): + adj = part.interpart_adj_groups[grp_num] f_grp = f_groups[None] - for idx in range(len(f_grp.elements)): + elem_base = part.groups[grp_num].element_nr_base + for idx, elem in enumerate(f_grp.elements): tag = -f_grp.neighbors[idx] assert tag >= 0 - elem = f_grp.elements[idx] + part.groups[grp_num].element_nr_base face = f_grp.element_faces[idx] for n_part_num in range(num_parts): n_part, n_part_to_global = new_meshes[n_part_num] if tag & part.boundary_tag_bit(BTAG_PARTITION(n_part_num)) != 0: num_tags[n_part_num] += 1 - (i, n_elem, n_face) = part.\ - interpart_adj_groups[grp_num].get_neighbor(elem, face) + + (i, n_elem, n_face) = adj.get_neighbor(elem, face) assert i == n_part_num n_grp_num = n_part.find_igrp(n_elem) - assert (part_num, elem, face) == n_part.\ - interpart_adj_groups[n_grp_num].\ - get_neighbor(n_elem, n_face),\ + n_adj = n_part.interpart_adj_groups[n_grp_num] + n_elem_base = n_part.groups[n_grp_num].element_nr_base + n_elem = n_elem - n_elem_base + assert (part_num, elem + elem_base, face) ==\ + n_adj.get_neighbor(n_elem, n_face),\ "InterpartitionAdj is not consistent" n_part_to_global = new_meshes[n_part_num][1] - p_elem = part_to_global[elem] - p_n_elem = n_part_to_global[n_elem] + p_elem = part_to_global[elem + elem_base] + p_n_elem = n_part_to_global[n_elem + n_elem_base] p_grp_num = mesh.find_igrp(p_elem) p_n_grp_num = mesh.find_igrp(p_n_elem) @@ -163,7 +169,7 @@ def test_partition_mesh(): p_n_elem -= p_n_elem_base f_groups = mesh.facial_adjacency_groups[p_grp_num] - for _, p_bnd_adj in f_groups.items(): + for p_bnd_adj in f_groups.values(): for idx in range(len(p_bnd_adj.elements)): if (p_elem == p_bnd_adj.elements[idx] and face == p_bnd_adj.element_faces[idx]):