def test_mesh_function_assign_2D_cells(): mesh = UnitSquareMesh(MPI.comm_world, 3, 3) ncells = mesh.num_cells() f = MeshFunction("int", mesh, mesh.topology.dim, 0) for cell in Cells(mesh): f[cell] = ncells - cell.index() g = MeshValueCollection("int", mesh, 2) g.assign(f) assert ncells == f.size() assert ncells == g.size() f2 = MeshFunction("int", mesh, g, 0) for cell in Cells(mesh): value = ncells - cell.index() assert value == g.get_value(cell.index(), 0) assert f2[cell] == g.get_value(cell.index(), 0) h = MeshValueCollection("int", mesh, 2) global_indices = mesh.topology.global_indices(2) ncells_global = mesh.num_entities_global(2) for cell in Cells(mesh): if global_indices[cell.index()] in [5, 8, 10]: continue value = ncells_global - global_indices[cell.index()] h.set_value(cell.index(), int(value)) f3 = MeshFunction("int", mesh, h, 0) values = f3.array() values[values > ncells_global] = 0. assert MPI.sum(mesh.mpi_comm(), values.sum() * 1.0) == 140.
def test_save_3D_cell_function(tempdir, encoding, data_type): if invalid_config(encoding): pytest.skip("XDMF unsupported in current configuration") dtype_str, dtype = data_type mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4) mf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0) mf.rename("cells") for cell in Cells(mesh): mf[cell] = dtype(cell.index()) filename = os.path.join(tempdir, "mf_3D_%s.xdmf" % dtype_str) with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file: file.write(mf) # mf_in = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0) with XDMFFile(mesh.mpi_comm(), filename) as xdmf: read_function = getattr(xdmf, "read_mf_" + dtype_str) mf_in = read_function(mesh, "cells") diff = 0 for cell in Cells(mesh): diff += (mf_in[cell] - mf[cell]) assert diff == 0
def test_append_and_load_mesh_functions(tempdir, encoding, data_type): if invalid_config(encoding): pytest.skip("XDMF unsupported in current configuration") dtype_str, dtype = data_type meshes = [ UnitSquareMesh(MPI.comm_world, 12, 12), UnitCubeMesh(MPI.comm_world, 2, 2, 2) ] for mesh in meshes: dim = mesh.topology.dim vf = MeshFunction(dtype_str, mesh, 0, 0) vf.rename("vertices") ff = MeshFunction(dtype_str, mesh, mesh.topology.dim - 1, 0) ff.rename("facets") cf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0) cf.rename("cells") if (MPI.size(mesh.mpi_comm()) == 1): for vertex in Vertices(mesh): vf[vertex] = dtype(vertex.index()) for facet in Facets(mesh): ff[facet] = dtype(facet.index()) for cell in Cells(mesh): cf[cell] = dtype(cell.index()) else: for vertex in Vertices(mesh): vf[vertex] = dtype(vertex.global_index()) for facet in Facets(mesh): ff[facet] = dtype(facet.global_index()) for cell in Cells(mesh): cf[cell] = dtype(cell.global_index()) filename = os.path.join(tempdir, "appended_mf_%dD.xdmf" % dim) with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as xdmf: xdmf.write(mesh) xdmf.write(vf) xdmf.write(ff) xdmf.write(cf) with XDMFFile(mesh.mpi_comm(), filename) as xdmf: read_function = getattr(xdmf, "read_mf_" + dtype_str) vf_in = read_function(mesh, "vertices") ff_in = read_function(mesh, "facets") cf_in = read_function(mesh, "cells") diff = 0 for vertex in Vertices(mesh): diff += (vf_in[vertex] - vf[vertex]) for facet in Facets(mesh): diff += (ff_in[facet] - ff[facet]) for cell in Cells(mesh): diff += (cf_in[cell] - cf[cell]) assert diff == 0
def test_tabulate_dofs(mesh_factory): func, args = mesh_factory mesh = func(*args) W0 = FiniteElement("Lagrange", mesh.ufl_cell(), 1) W1 = VectorElement("Lagrange", mesh.ufl_cell(), 1) W = FunctionSpace(mesh, W0 * W1) L0 = W.sub(0) L1 = W.sub(1) L01 = L1.sub(0) L11 = L1.sub(1) for i, cell in enumerate(Cells(mesh)): dofs0 = L0.dofmap().cell_dofs(cell.index()) dofs1 = L01.dofmap().cell_dofs(cell.index()) dofs2 = L11.dofmap().cell_dofs(cell.index()) dofs3 = L1.dofmap().cell_dofs(cell.index()) assert np.array_equal(dofs0, L0.dofmap().cell_dofs(i)) assert np.array_equal(dofs1, L01.dofmap().cell_dofs(i)) assert np.array_equal(dofs2, L11.dofmap().cell_dofs(i)) assert np.array_equal(dofs3, L1.dofmap().cell_dofs(i)) assert len(np.intersect1d(dofs0, dofs1)) == 0 assert len(np.intersect1d(dofs0, dofs2)) == 0 assert len(np.intersect1d(dofs1, dofs2)) == 0 assert np.array_equal(np.append(dofs1, dofs2), dofs3)
def test_p4_parallel_3d(): mesh = UnitCubeMesh(MPI.comm_world, 3, 5, 8) Q = FunctionSpace(mesh, ("CG", 5)) F = Function(Q) @function.expression.numba_eval def x0(values, x, cell_idx): values[:, 0] = x[:, 0] F.interpolate(Expression(x0)) # Generate random points in this mesh partition (one per cell) x = numpy.zeros(4) tree = cpp.geometry.BoundingBoxTree(mesh, mesh.geometry.dim) for c in Cells(mesh): x[0] = random() x[1] = random() * (1 - x[0]) x[2] = random() * (1 - x[0] - x[1]) x[3] = 1 - x[0] - x[1] - x[2] p = Point(0.0, 0.0, 0.0) for i, v in enumerate(VertexRange(c)): p += v.point() * x[i] p = p.array() assert numpy.isclose(F(p, tree)[0], p[0])
def test_cell_iterators(): "Iterate over cells" mesh = UnitCubeMesh(MPI.comm_world, 5, 5, 5) for i in range(4): mesh.init(3, i) # Test connectivity cons = [(i, mesh.topology.connectivity(3, i)) for i in range(4)] # Test writability for i, con in cons: def assign(con, i): con(i)[0] = 1 with pytest.raises(Exception): assign(con, i) n = 0 for i, c in enumerate(Cells(mesh)): n += 1 for j, con in cons: assert numpy.all(con(i) == c.entities(j)) assert n == mesh.num_cells()
def test_radius_ratio_tetrahedron(): # Create mesh and compute ratios mesh = UnitCubeMesh(MPI.comm_world, 14, 14, 14) ratios = MeshQuality.radius_ratios(mesh) for c in Cells(mesh): assert round(ratios[c] - 0.717438935214, 7) == 0
def test_mixed_parallel(): mesh = UnitSquareMesh(MPI.comm_world, 5, 8) V = VectorElement("Lagrange", triangle, 4) Q = FiniteElement("Lagrange", triangle, 5) W = FunctionSpace(mesh, Q * V) F = Function(W) @function.expression.numba_eval def expr_eval(values, x, cell_idx): values[:, 0] = x[:, 0] values[:, 1] = x[:, 1] values[:, 2] = numpy.sin(x[:, 0] + x[:, 1]) F.interpolate(Expression(expr_eval, shape=(3, ))) # Generate random points in this mesh partition (one per cell) x = numpy.zeros(3) for c in Cells(mesh): x[0] = random() x[1] = random() * (1 - x[0]) x[2] = (1 - x[0] - x[1]) p = Point(0.0, 0.0) for i, v in enumerate(VertexRange(c)): p += v.point() * x[i] p = p.array()[:2] val = F(p) assert numpy.allclose(val[0], p[0]) assert numpy.isclose(val[1], p[1]) assert numpy.isclose(val[2], numpy.sin(p[0] + p[1]))
def test_mesh_topology_against_fiat(mesh_factory, ghost_mode): """Test that mesh cells have topology matching to FIAT reference cell they were created from. """ func, args = mesh_factory xfail_ghosted_quads_hexes(func, ghost_mode) mesh = func(*args) # Create FIAT cell cell_name = CellType.type2string(mesh.type().cell_type()) fiat_cell = FIAT.ufc_cell(cell_name) # Initialize all mesh entities and connectivities mesh.init() for cell in Cells(mesh): # Get mesh-global (MPI-local) indices of cell vertices vertex_global_indices = cell.entities(0) # Loop over all dimensions of reference cell topology for d, d_topology in fiat_cell.get_topology().items(): # Get entities of dimension d on the cell entities = cell.entities(d) if len(entities) == 0: # Fixup for highest dimension entities = (cell.index(), ) # Loop over all entities of fixed dimension d for entity_index, entity_topology in d_topology.items(): # Check that entity vertices map to cell vertices in right order entity = MeshEntity(mesh, d, entities[entity_index]) entity_vertices = entity.entities(0) assert all(vertex_global_indices[numpy.array(entity_topology)] == entity_vertices)
def test_radius_ratio_triangle(): # Create mesh and compute rations mesh = UnitSquareMesh(MPI.comm_world, 12, 12) ratios = MeshQuality.radius_ratios(mesh) for c in Cells(mesh): assert round(ratios[c] - 0.828427124746, 7) == 0
def test_save_mesh_value_collection(tempdir, encoding, data_type): dtype_str, dtype = data_type mesh = UnitCubeMesh(MPI.comm_world, 4, 4, 4) tdim = mesh.topology.dim meshfn = MeshFunction(dtype_str, mesh, mesh.topology.dim, False) meshfn.rename("volume_marker") for c in Cells(mesh): if c.midpoint()[1] > 0.1: meshfn[c] = dtype(1) if c.midpoint()[1] > 0.9: meshfn[c] = dtype(2) for mvc_dim in range(0, tdim + 1): mvc = MeshValueCollection(dtype_str, mesh, mvc_dim) tag = "dim_%d_marker" % mvc_dim mvc.rename(tag) mesh.init(mvc_dim, tdim) for e in MeshEntities(mesh, mvc_dim): if (e.midpoint()[0] > 0.5): mvc.set_value(e.index(), dtype(1)) filename = os.path.join(tempdir, "mvc_%d.xdmf" % mvc_dim) with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as xdmf: xdmf.write(meshfn) xdmf.write(mvc) with XDMFFile(mesh.mpi_comm(), filename) as xdmf: read_function = getattr(xdmf, "read_mvc_" + dtype_str) mvc = read_function(mesh, tag)
def test_save_1d_mesh(tempdir, encoding): filename = os.path.join(tempdir, "mf_1D.xdmf") mesh = UnitIntervalMesh(MPI.comm_world, 32) mf = MeshFunction("size_t", mesh, mesh.topology.dim, 0) for cell in Cells(mesh): mf[cell] = cell.index() with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file: file.write(mf)
def test_mixed_iterators(): "Iterate over vertices of cells" mesh = UnitCubeMesh(MPI.comm_world, 5, 5, 5) n = 0 for c in Cells(mesh): for v in VertexRange(c): n += 1 assert n == 4 * mesh.num_cells()
def test_save_2D_cell_function(tempdir, encoding, data_type): dtype_str, dtype = data_type filename = os.path.join(tempdir, "mf_2D_%s.xdmf" % dtype_str) mesh = UnitSquareMesh(MPI.comm_world, 32, 32) mf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0) mf.rename("cells") for cell in Cells(mesh): mf[cell] = dtype(cell.index()) with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file: file.write(mf) with XDMFFile(mesh.mpi_comm(), filename) as xdmf: read_function = getattr(xdmf, "read_mf_" + dtype_str) mf_in = read_function(mesh, "cells") diff = 0 for cell in Cells(mesh): diff += (mf_in[cell] - mf[cell]) assert diff == 0
def test_save_1d_mesh(tempdir, encoding): if invalid_config(encoding): pytest.skip("XDMF unsupported in current configuration") filename = os.path.join(tempdir, "mf_1D.xdmf") mesh = UnitIntervalMesh(MPI.comm_world, 32) mf = MeshFunction("size_t", mesh, mesh.topology.dim, 0) for cell in Cells(mesh): mf[cell] = cell.index() with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file: file.write(mf)
def test_assign_2D_facets(): mesh = UnitSquareMesh(MPI.comm_world, 3, 3) mesh.init(2, 1) ncells = mesh.num_cells() f = MeshValueCollection("int", mesh, 1) all_new = True for cell in Cells(mesh): value = ncells - cell.index() for i, facet in enumerate(FacetRange(cell)): all_new = all_new and f.set_value(cell.index(), i, value + i) g = MeshValueCollection("int", mesh, 1) g.assign(f) assert ncells * 3 == f.size() assert ncells * 3 == g.size() assert all_new for cell in Cells(mesh): value = ncells - cell.index() for i, facet in enumerate(FacetRange(cell)): assert value + i == g.get_value(cell.index(), i)
def test_assign_2D_vertices(): mesh = UnitSquareMesh(MPI.comm_world, 3, 3) mesh.create_connectivity(2, 0) ncells = mesh.num_cells() f = MeshValueCollection("int", mesh, 0) all_new = True for cell in Cells(mesh): value = ncells - cell.index() for i, vert in enumerate(VertexRange(cell)): all_new = all_new and f.set_value(cell.index(), i, value + i) g = MeshValueCollection("int", mesh, 0) g.assign(f) assert ncells * 3 == f.size() assert ncells * 3 == g.size() assert all_new for cell in Cells(mesh): value = ncells - cell.index() for i, vert in enumerate(VertexRange(cell)): assert value + i == g.get_value(cell.index(), i)
def test_assign_2D_cells(): mesh = UnitSquareMesh(MPI.comm_world, 3, 3) ncells = mesh.num_cells() f = MeshValueCollection("int", mesh, 2) all_new = True for cell in Cells(mesh): value = ncells - cell.index() all_new = all_new and f.set_value(cell.index(), value) g = MeshValueCollection("int", mesh, 2) g.assign(f) assert ncells == f.size() assert ncells == g.size() assert all_new for cell in Cells(mesh): value = ncells - cell.index() assert value, g.get_value(cell.index() == 0) old_value = g.get_value(0, 0) g.set_value(0, 0, old_value + 1) assert old_value + 1 == g.get_value(0, 0)
def test_mesh_function_assign_2D_facets(): mesh = UnitSquareMesh(MPI.comm_world, 3, 3) mesh.init(1) f = MeshFunction("int", mesh, mesh.topology.dim - 1, 25) for cell in Cells(mesh): for i, facet in enumerate(FacetRange(cell)): assert 25 == f[facet] g = MeshValueCollection("int", mesh, 1) g.assign(f) assert mesh.num_facets() == f.size() assert mesh.num_cells() * 3 == g.size() for cell in Cells(mesh): for i, facet in enumerate(FacetRange(cell)): assert 25 == g.get_value(cell.index(), i) f2 = MeshFunction("int", mesh, g, 0) for cell in Cells(mesh): for i, facet in enumerate(FacetRange(cell)): assert f2[facet] == g.get_value(cell.index(), i)
def test_tabulate_dofs_periodic(mesh_factory): class PeriodicBoundary2(SubDomain): def inside(self, x, on_boundary): return x[0] < np.finfo(float).eps def map(self, x, y): y[0] = x[0] - 1.0 y[1] = x[1] func, args = mesh_factory mesh = func(*args) # Create periodic boundary periodic_boundary = PeriodicBoundary2() V = FiniteElement("Lagrange", mesh.ufl_cell(), 2) Q = VectorElement("Lagrange", mesh.ufl_cell(), 2) W = V * Q V = FunctionSpace(mesh, V, constrained_domain=periodic_boundary) Q = FunctionSpace(mesh, Q, constrained_domain=periodic_boundary) W = FunctionSpace(mesh, W, constrained_domain=periodic_boundary) L0 = W.sub(0) L1 = W.sub(1) L01 = L1.sub(0) L11 = L1.sub(1) # Check dimensions assert V.dim == 110 assert Q.dim == 220 assert L0.dim == V.dim assert L1.dim == Q.dim assert L01.dim == V.dim assert L11.dim == V.dim for i, cell in enumerate(Cells(mesh)): dofs0 = L0.dofmap().cell_dofs(cell.index()) dofs1 = L01.dofmap().cell_dofs(cell.index()) dofs2 = L11.dofmap().cell_dofs(cell.index()) dofs3 = L1.dofmap().cell_dofs(cell.index()) assert np.array_equal(dofs0, L0.dofmap().cell_dofs(i)) assert np.array_equal(dofs1, L01.dofmap().cell_dofs(i)) assert np.array_equal(dofs2, L11.dofmap().cell_dofs(i)) assert np.array_equal(dofs3, L1.dofmap().cell_dofs(i)) assert len(np.intersect1d(dofs0, dofs1)) == 0 assert len(np.intersect1d(dofs0, dofs2)) == 0 assert len(np.intersect1d(dofs1, dofs2)) == 0 assert np.array_equal(np.append(dofs1, dofs2), dofs3)
def test_mesh_function_assign_2D_vertices(): mesh = UnitSquareMesh(MPI.comm_world, 3, 3) mesh.create_entities(0) f = MeshFunction("int", mesh, 0, 25) g = MeshValueCollection("int", mesh, 0) g.assign(f) assert mesh.num_entities(0) == f.size() assert mesh.num_cells() * 3 == g.size() f2 = MeshFunction("int", mesh, g, 0) for cell in Cells(mesh): for i, vert in enumerate(VertexRange(cell)): assert 25 == g.get_value(cell.index(), i) assert f2[vert] == g.get_value(cell.index(), i)
def test_tabulate_coord_periodic(mesh_factory): class PeriodicBoundary2(SubDomain): def inside(self, x, on_boundary): return x[0] < np.finfo(float).eps def map(self, x, y): y[0] = x[0] - 1.0 y[1] = x[1] # Create periodic boundary condition periodic_boundary = PeriodicBoundary2() func, args = mesh_factory mesh = func(*args) V = FiniteElement("Lagrange", mesh.ufl_cell(), 1) Q = VectorElement("Lagrange", mesh.ufl_cell(), 1) W = V * Q V = FunctionSpace(mesh, V, constrained_domain=periodic_boundary) W = FunctionSpace(mesh, W, constrained_domain=periodic_boundary) L0 = W.sub(0) L1 = W.sub(1) L01 = L1.sub(0) L11 = L1.sub(1) sdim = V.element().space_dimension() coord0 = np.zeros((sdim, 2), dtype="d") coord1 = np.zeros((sdim, 2), dtype="d") coord2 = np.zeros((sdim, 2), dtype="d") coord3 = np.zeros((sdim, 2), dtype="d") for cell in Cells(mesh): coord0 = V.element().tabulate_dof_coordinates(cell) coord1 = L0.element().tabulate_dof_coordinates(cell) coord2 = L01.element().tabulate_dof_coordinates(cell) coord3 = L11.element().tabulate_dof_coordinates(cell) coord4 = L1.element().tabulate_dof_coordinates(cell) assert (coord0 == coord1).all() assert (coord0 == coord2).all() assert (coord0 == coord3).all() assert (coord4[:sdim] == coord0).all() assert (coord4[sdim:] == coord0).all()
def test_p4_parallel_2d(): mesh = UnitSquareMesh(MPI.comm_world, 5, 8) Q = FunctionSpace(mesh, ("CG", 4)) F = Function(Q) F.interpolate(Expression("x[0]", degree=4)) # Generate random points in this mesh partition (one per cell) x = numpy.zeros(3) for c in Cells(mesh): x[0] = random() x[1] = random() * (1 - x[0]) x[2] = 1 - x[0] - x[1] p = Point(0.0, 0.0) for i, v in enumerate(VertexRange(c)): p += v.point() * x[i] p = p.array()[:2] assert numpy.isclose(F(p)[0], p[0])
def test_tabulate_all_coordinates(mesh_factory): func, args = mesh_factory mesh = func(*args) V = FunctionSpace(mesh, ("Lagrange", 1)) W0 = FiniteElement("Lagrange", mesh.ufl_cell(), 1) W1 = VectorElement("Lagrange", mesh.ufl_cell(), 1) W = FunctionSpace(mesh, W0 * W1) D = mesh.geometry.dim V_dofmap = V.dofmap() W_dofmap = W.dofmap() all_coords_V = V.tabulate_dof_coordinates() all_coords_W = W.tabulate_dof_coordinates() local_size_V = V_dofmap().index_map.size_local * V_dofmap( ).index_map.block_size local_size_W = W_dofmap().index_map.size_local * W_dofmap( ).index_map.block_size all_coords_V = all_coords_V.reshape(local_size_V, D) all_coords_W = all_coords_W.reshape(local_size_W, D) checked_V = [False] * local_size_V checked_W = [False] * local_size_W # Check that all coordinates are within the cell it should be for cell in Cells(mesh): dofs_V = V_dofmap.cell_dofs(cell.index()) for di in dofs_V: if di >= local_size_V: continue assert cell.contains(all_coords_V[di]) checked_V[di] = True dofs_W = W_dofmap.cell_dofs(cell.index()) for di in dofs_W: if di >= local_size_W: continue assert cell.contains(all_coords_W[di]) checked_W[di] = True # Assert that all dofs have been checked by the above assert all(checked_V) assert all(checked_W)
def get_cell_at(mesh, x, y, z, eps=1e-3): """Return the cell with the given midpoint or None if not found. The function also checks that the cell is found on one of the processes when running in parallel to avoid that the above tests always suceed if the cell is not found on any of the processes. """ found = None for cell in Cells(mesh): mp = cell.midpoint().array() if abs(mp[0] - x) + abs(mp[1] - y) + abs(mp[2] - z) < eps: found = cell break # Make sure this cell is on at least one of the parallel processes marker = 1 if found is not None else 0 assert MPI.max(MPI.comm_world, marker) == 1 return found
def test_mixed_parallel(): mesh = UnitSquareMesh(MPI.comm_world, 5, 8) V = VectorElement("Lagrange", triangle, 4) Q = FiniteElement("Lagrange", triangle, 5) W = FunctionSpace(mesh, Q * V) F = Function(W) F.interpolate(Expression(("x[0]", "x[1]", "sin(x[0] + x[1])"), degree=5)) # Generate random points in this mesh partition (one per cell) x = numpy.zeros(3) for c in Cells(mesh): x[0] = random() x[1] = random() * (1 - x[0]) x[2] = (1 - x[0] - x[1]) p = Point(0.0, 0.0) for i, v in enumerate(VertexRange(c)): p += v.point() * x[i] p = p.array()[:2] val = F(p) assert numpy.allclose(val[0], p[0]) assert numpy.isclose(val[1], p[1]) assert numpy.isclose(val[2], numpy.sin(p[0] + p[1]))
def test_tabulate_coord_periodic(mesh_factory): def periodic_boundary(x): return x[0] < np.finfo(float).eps func, args = mesh_factory mesh = func(*args) V = FiniteElement("Lagrange", mesh.ufl_cell(), 1) Q = VectorElement("Lagrange", mesh.ufl_cell(), 1) W = V * Q V = FunctionSpace(mesh, V, constrained_domain=periodic_boundary) W = FunctionSpace(mesh, W, constrained_domain=periodic_boundary) L0 = W.sub(0) L1 = W.sub(1) L01 = L1.sub(0) L11 = L1.sub(1) sdim = V.element.space_dimension() coord0 = np.zeros((sdim, 2), dtype="d") coord1 = np.zeros((sdim, 2), dtype="d") coord2 = np.zeros((sdim, 2), dtype="d") coord3 = np.zeros((sdim, 2), dtype="d") for cell in Cells(mesh): coord0 = V.element.tabulate_dof_coordinates(cell) coord1 = L0.element.tabulate_dof_coordinates(cell) coord2 = L01.element.tabulate_dof_coordinates(cell) coord3 = L11.element.tabulate_dof_coordinates(cell) coord4 = L1.element.tabulate_dof_coordinates(cell) assert (coord0 == coord1).all() assert (coord0 == coord2).all() assert (coord0 == coord3).all() assert (coord4[:sdim] == coord0).all() assert (coord4[sdim:] == coord0).all()
def test_ghost_connectivities(mode): # Ghosted mesh meshG = UnitSquareMesh(MPI.comm_world, 4, 4, ghost_mode=mode) meshG.init(1, 2) # Reference mesh, not ghosted, not parallel meshR = UnitSquareMesh(MPI.comm_self, 4, 4, ghost_mode=cpp.mesh.GhostMode.none) meshR.init(1, 2) # Create reference mapping from facet midpoint to cell midpoint reference = {} for facet in Facets(meshR): fidx = facet.index() facet_mp = tuple(facet.midpoint()[:]) reference[facet_mp] = [] for cidx in meshR.topology.connectivity(1, 2)(fidx): cell = Cell(meshR, cidx) cell_mp = tuple(cell.midpoint()[:]) reference[facet_mp].append(cell_mp) # Loop through ghosted mesh and check connectivities allowable_cell_indices = [ c.index() for c in Cells(meshG, cpp.mesh.MeshRangeType.ALL) ] for facet in Facets(meshG, cpp.mesh.MeshRangeType.REGULAR): fidx = facet.index() facet_mp = tuple(facet.midpoint()[:]) assert facet_mp in reference for cidx in meshG.topology.connectivity(1, 2)(fidx): assert cidx in allowable_cell_indices cell = Cell(meshG, cidx) cell_mp = tuple(cell.midpoint()[:]) assert cell_mp in reference[facet_mp]