def test_UnitSquareMeshDistributed(): """Create mesh of unit square.""" mesh = UnitSquareMesh(MPI.comm_world, 5, 7) assert mesh.num_entities_global(0) == 48 assert mesh.num_entities_global(2) == 70 assert mesh.geometry.dim == 2 assert MPI.sum(mesh.mpi_comm(), mesh.topology.index_map(0).size_local) == 48
def test_krylov_solver_lu(): mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12) V = FunctionSpace(mesh, ("Lagrange", 1)) u, v = TrialFunction(V), TestFunction(V) a = inner(u, v) * dx L = inner(1.0, v) * dx A = assemble_matrix(a) A.assemble() b = assemble_vector(L) b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE) norm = 13.0 solver = PETSc.KSP().create(mesh.mpi_comm()) solver.setOptionsPrefix("test_lu_") opts = PETSc.Options("test_lu_") opts["ksp_type"] = "preonly" opts["pc_type"] = "lu" solver.setFromOptions() x = A.createVecRight() solver.setOperators(A) solver.solve(b, x) # *Tight* tolerance for LU solves assert x.norm(PETSc.NormType.N2) == pytest.approx(norm, abs=1.0e-12)
def test_save_and_read_function(tempdir): filename = os.path.join(tempdir, "function.h5") mesh = UnitSquareMesh(MPI.comm_world, 10, 10) Q = FunctionSpace(mesh, ("CG", 3)) F0 = Function(Q) F1 = Function(Q) def E(x): return x[0] F0.interpolate(E) # Save to HDF5 File hdf5_file = HDF5File(mesh.mpi_comm(), filename, "w") hdf5_file.write(F0, "/function") hdf5_file.close() # Read back from file hdf5_file = HDF5File(mesh.mpi_comm(), filename, "r") F1 = hdf5_file.read_function(Q, "/function") F0.vector.axpy(-1.0, F1.vector) assert F0.vector.norm() < 1.0e-12 hdf5_file.close()
def test_save_and_read_function_timeseries(tempdir): filename = os.path.join(tempdir, "function.h5") mesh = UnitSquareMesh(MPI.comm_world, 10, 10) Q = FunctionSpace(mesh, ("CG", 3)) F0 = Function(Q) F1 = Function(Q) t = 0.0 def E(x): return t * x[0] F0.interpolate(E) # Save to HDF5 File hdf5_file = HDF5File(mesh.mpi_comm(), filename, "w") for t in range(10): F0.interpolate(E) hdf5_file.write(F0, "/function", t) hdf5_file.close() # Read back from file hdf5_file = HDF5File(mesh.mpi_comm(), filename, "r") for t in range(10): F1.interpolate(E) vec_name = "/function/vector_{}".format(t) F0 = hdf5_file.read_function(Q, vec_name) # timestamp = hdf5_file.attributes(vec_name)["timestamp"] # assert timestamp == t F0.vector.axpy(-1.0, F1.vector) assert F0.vector.norm() < 1.0e-12 hdf5_file.close()
def test_UnitQuadMesh(): mesh = UnitSquareMesh(MPI.comm_world, 5, 7, CellType.quadrilateral) assert mesh.num_entities_global(0) == 48 assert mesh.num_entities_global(2) == 35 assert mesh.geometry.dim == 2 assert MPI.sum(mesh.mpi_comm(), mesh.topology.index_map(0).size_local) == 48
def test_UnitSquareMeshDistributed(): """Create mesh of unit square.""" mesh = UnitSquareMesh(MPI.COMM_WORLD, 5, 7) assert mesh.topology.index_map(0).size_global == 48 assert mesh.topology.index_map(2).size_global == 70 assert mesh.geometry.dim == 2 assert mesh.mpi_comm().allreduce(mesh.topology.index_map(0).size_local, MPI.SUM) == 48
def test_RefineUnitSquareMesh(): """Refine mesh of unit square.""" mesh = UnitSquareMesh(MPI.comm_world, 5, 7) mesh.create_entities(1) mesh = refine(mesh, False) assert mesh.num_entities_global(0) == 165 assert mesh.num_entities_global(2) == 280
def test_UnitQuadMesh(): mesh = UnitSquareMesh(MPI.COMM_WORLD, 5, 7, CellType.quadrilateral) assert mesh.topology.index_map(0).size_global == 48 assert mesh.topology.index_map(2).size_global == 35 assert mesh.geometry.dim == 2 assert mesh.mpi_comm().allreduce( mesh.topology.index_map(0).size_local, MPI.SUM) == 48
def test_save_2d_tensor(tempdir, encoding, cell_type): filename = os.path.join(tempdir, "tensor.xdmf") mesh = UnitSquareMesh(MPI.comm_world, 16, 16, cell_type) u = Function(TensorFunctionSpace(mesh, ("Lagrange", 2))) u.vector.set(1.0 + (1j if has_petsc_complex else 0)) with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file: file.write(u)
def test_assign_2D_facets(): mesh = UnitSquareMesh(MPI.comm_world, 3, 3) mesh.create_connectivity(2, 1) tdim = mesh.topology.dim num_cell_facets = cpp.mesh.cell_num_entities(mesh.topology.cell_type, tdim - 1) ncells = mesh.num_cells() f = MeshValueCollection("int", mesh, 1) all_new = True for c in range(ncells): value = ncells - c for i in range(num_cell_facets): all_new = all_new and f.set_value(c, 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 c in range(ncells): value = ncells - c for i in range(num_cell_facets): assert value + i == g.get_value(c, i)
def test_save_2d_scalar(tempdir, encoding, cell_type): filename = os.path.join(tempdir, "u2.xdmf") mesh = UnitSquareMesh(MPI.comm_world, 16, 16, cell_type) # FIXME: This randomly hangs in parallel V = FunctionSpace(mesh, ("Lagrange", 2)) u = Function(V) u.vector.set(1.0 + (1j if has_petsc_complex else 0)) with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file: file.write(u)
def test_save_2d_vector(tempdir, encoding, cell_type): filename = os.path.join(tempdir, "u_2dv.xdmf") mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 13, cell_type) V = VectorFunctionSpace(mesh, ("Lagrange", 2)) u = Function(V) u.vector.set(1.0 + (1j if has_petsc_complex else 0)) with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as file: file.write_mesh(mesh) file.write_function(u)
def test_save_2d_scalar(tempdir, encoding, cell_type): filename = os.path.join(tempdir, "u2.xdmf") mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12, cell_type) V = FunctionSpace(mesh, ("Lagrange", 2)) u = Function(V) u.vector.set(1.0) with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as file: file.write_mesh(mesh) file.write_function(u)
def test_ghost_2d(mode): N = 8 num_cells = N * N * 2 mesh = UnitSquareMesh(MPI.COMM_WORLD, N, N, ghost_mode=mode) if mesh.mpi_comm().size > 1: map = mesh.topology.index_map(2) num_cells_local = map.size_local + map.num_ghosts assert mesh.mpi_comm().allreduce(num_cells_local, op=MPI.SUM) > num_cells assert mesh.topology.index_map(0).size_global == 81 assert mesh.topology.index_map(2).size_global == num_cells
def test_compute_collisions_tree_2d(point, cells): mesh_A = UnitSquareMesh(MPI.comm_world, 4, 4) mesh_B = UnitSquareMesh(MPI.comm_world, 4, 4) bgeom = mesh_B.geometry.points bgeom += point tree_A = BoundingBoxTree(mesh_A, mesh_A.topology.dim) tree_B = BoundingBoxTree(mesh_B, mesh_B.topology.dim) entities_A, entities_B = geometry.compute_collisions_bb(tree_A, tree_B) assert set(entities_A) == set(cells[0]) assert set(entities_B) == set(cells[1])
def test_save_and_load_2d_mesh(tempdir, encoding, cell_type): filename = os.path.join(tempdir, "mesh_2D.xdmf") mesh = UnitSquareMesh(MPI.comm_world, 32, 32, cell_type) with XDMFFile(mesh.mpi_comm(), filename, encoding=encoding) as file: file.write(mesh) with XDMFFile(MPI.comm_world, filename) as file: mesh2 = file.read_mesh(cpp.mesh.GhostMode.none) assert mesh.num_entities_global(0) == mesh2.num_entities_global(0) dim = mesh.topology.dim assert mesh.num_entities_global(dim) == mesh2.num_entities_global(dim)
def test_mesh_function_assign_2D_facets(): mesh = UnitSquareMesh(MPI.comm_world, 3, 3) mesh.create_entities(1) tdim = mesh.topology.dim num_cell_facets = cpp.mesh.cell_num_entities(mesh.topology.cell_type, tdim - 1) f = MeshFunction("int", mesh, tdim - 1, 25) connectivity = mesh.topology.connectivity(tdim, tdim - 1) for c in range(mesh.num_cells()): facets = connectivity.links(c) for i in range(num_cell_facets): assert 25 == f.values[facets[i]] g = MeshValueCollection("int", mesh, 1) g.assign(f) assert mesh.num_entities(tdim - 1) == len(f.values) assert mesh.num_cells() * 3 == g.size() for c in range(mesh.num_cells()): for i in range(num_cell_facets): assert 25 == g.get_value(c, i) f2 = MeshFunction("int", mesh, g, 0) connectivity = mesh.topology.connectivity(tdim, tdim - 1) for c in range(mesh.num_cells()): facets = connectivity.links(c) for i in range(num_cell_facets): assert f2.values[facets[i]] == g.get_value(c, i)
def test_save_points_2D(tempdir, encoding, cell_type): mesh = UnitSquareMesh(MPI.comm_world, 16, 16, cell_type) points = mesh.geometry.points vals = np.linalg.norm(points, axis=1) with XDMFFile(mesh.mpi_comm(), os.path.join(tempdir, "points_2D.xdmf"), encoding=encoding) as file: file.write(points) with XDMFFile(mesh.mpi_comm(), os.path.join(tempdir, "points_values_2D.xdmf"), encoding=encoding) as file: file.write(points, vals)
def test_small_mesh(): mesh3d = UnitCubeMesh(MPI.comm_world, 1, 1, 1) gdim = mesh3d.geometry.dim assert mesh3d.num_entities_global(gdim) == 6 mesh2d = UnitSquareMesh(MPI.comm_world, 1, 1) gdim = mesh2d.geometry.dim assert mesh2d.num_entities_global(gdim) == 2 mesh1d = UnitIntervalMesh(MPI.comm_world, 2) gdim = mesh1d.geometry.dim assert mesh1d.num_entities_global(gdim) == 2
def test_save_2d_tensor(tempdir): mesh = UnitSquareMesh(MPI.COMM_WORLD, 16, 16) u = Function(TensorFunctionSpace(mesh, ("Lagrange", 2))) with u.vector.localForm() as loc: loc.set(1.0) filename = os.path.join(tempdir, "u.pvd") with VTKFile(mesh.mpi_comm(), filename, "w") as vtk: vtk.write_function(u, 0.) with u.vector.localForm() as loc: loc.set(2.0) vtk.write_function(u, 1.)
def test_compute_collisions_tree_2d(point, cells): mesh_A = UnitSquareMesh(MPI.COMM_WORLD, 4, 4) mesh_B = UnitSquareMesh(MPI.COMM_WORLD, 4, 4) bgeom = mesh_B.geometry.x bgeom += point tree_A = BoundingBoxTree(mesh_A, mesh_A.topology.dim) tree_B = BoundingBoxTree(mesh_B, mesh_B.topology.dim) entities = compute_collisions(tree_A, tree_B) entities_A = set([q[0] for q in entities]) entities_B = set([q[1] for q in entities]) assert entities_A == set(cells[0]) assert entities_B == set(cells[1])
def test_append_and_load_mesh_functions(tempdir, encoding, data_type): dtype_str, dtype = data_type meshes = [ UnitSquareMesh(MPI.comm_world, 12, 12), UnitCubeMesh(MPI.comm_world, 2, 2, 2), UnitSquareMesh(MPI.comm_world, 12, 12, CellType.quadrilateral), UnitCubeMesh(MPI.comm_world, 2, 2, 2, CellType.hexahedron) ] for mesh in meshes: dim = mesh.topology.dim vf = MeshFunction(dtype_str, mesh, 0, 0) vf.name = "vertices" ff = MeshFunction(dtype_str, mesh, mesh.topology.dim - 1, 0) ff.name = "facets" cf = MeshFunction(dtype_str, mesh, mesh.topology.dim, 0) cf.name = "cells" # vf.values[:] = mesh.topology.global_indices(0)[:] map = mesh.topology.index_map(0) vf.values[:] = map.global_indices(True) map = mesh.topology.index_map(dim - 1) ff.values[:] = map.global_indices(True) map = mesh.topology.index_map(dim) cf.values[:] = map.global_indices(True) filename = os.path.join( tempdir, "appended_mf_{0:d}_{1:s}.xdmf".format( dim, str(mesh.topology.cell_type))) 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_vf = vf_in.values - vf.values diff_ff = ff_in.values - ff.values diff_cf = cf_in.values - cf.values assert np.all(diff_vf == 0) assert np.all(diff_ff == 0) assert np.all(diff_cf == 0)
def test_clear_sub_map_data_vector(mesh): mesh = UnitSquareMesh(8, 8) P1 = FiniteElement("Lagrange", mesh.ufl_cell(), 1) W = FunctionSpace(mesh, P1 * P1) # Check block size assert W.dofmap.index_map.block_size == 2 W.dofmap.clear_sub_map_data() with pytest.raises(RuntimeError): W0 = W.sub(0) assert (W0) with pytest.raises(RuntimeError): W1 = W.sub(1) assert (W1)
def test_save_and_load_2d_mesh(tempdir, encoding, cell_type): filename = os.path.join(tempdir, "mesh.xdmf") mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12, cell_type) mesh.name = "square" with XDMFFile(mesh.mpi_comm(), filename, "w", encoding=encoding) as file: file.write_mesh(mesh) with XDMFFile(MPI.COMM_WORLD, filename, "r", encoding=encoding) as file: mesh2 = file.read_mesh(name="square") assert mesh2.name == mesh.name assert mesh.topology.index_map(0).size_global == mesh2.topology.index_map(0).size_global assert mesh.topology.index_map(mesh.topology.dim).size_global == mesh2.topology.index_map( mesh.topology.dim).size_global
def test_numba_assembly(): mesh = UnitSquareMesh(MPI.comm_world, 13, 13) V = FunctionSpace(mesh, ("Lagrange", 1)) a = cpp.fem.Form([V._cpp_object, V._cpp_object]) a.set_tabulate_tensor(FormIntegrals.Type.cell, -1, tabulate_tensor_A.address) a.set_tabulate_tensor(FormIntegrals.Type.cell, 12, tabulate_tensor_A.address) a.set_tabulate_tensor(FormIntegrals.Type.cell, 2, tabulate_tensor_A.address) L = cpp.fem.Form([V._cpp_object]) L.set_tabulate_tensor(FormIntegrals.Type.cell, -1, tabulate_tensor_b.address) A = dolfinx.fem.assemble_matrix(a) A.assemble() b = dolfinx.fem.assemble_vector(L) b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE) Anorm = A.norm(PETSc.NormType.FROBENIUS) bnorm = b.norm(PETSc.NormType.N2) assert (np.isclose(Anorm, 56.124860801609124)) assert (np.isclose(bnorm, 0.0739710713711999)) list_timings(MPI.comm_world, [TimingType.wall])
def test_distance_triangle(): mesh = UnitSquareMesh(MPI.COMM_SELF, 1, 1) assert cpp.geometry.squared_distance(mesh, mesh.topology.dim, 1, numpy.array([-1.0, -1.0, 0.0])) == pytest.approx(2.0) assert cpp.geometry.squared_distance(mesh, mesh.topology.dim, 1, numpy.array([-1.0, 0.5, 0.0])) == pytest.approx(1.0) assert cpp.geometry.squared_distance(mesh, mesh.topology.dim, 1, numpy.array([0.5, 0.5, 0.0])) == pytest.approx(0.0)
def test_numba_assembly(): mesh = UnitSquareMesh(MPI.COMM_WORLD, 13, 13) V = FunctionSpace(mesh, ("Lagrange", 1)) integrals = { IntegralType.cell: ([(-1, tabulate_tensor_A.address), (12, tabulate_tensor_A.address), (2, tabulate_tensor_A.address)], None) } a = cpp.fem.Form([V._cpp_object, V._cpp_object], integrals, [], [], False) integrals = {IntegralType.cell: ([(-1, tabulate_tensor_b.address)], None)} L = cpp.fem.Form([V._cpp_object], integrals, [], [], False) A = dolfinx.fem.assemble_matrix(a) A.assemble() b = dolfinx.fem.assemble_vector(L) b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE) Anorm = A.norm(PETSc.NormType.FROBENIUS) bnorm = b.norm(PETSc.NormType.N2) assert (np.isclose(Anorm, 56.124860801609124)) assert (np.isclose(bnorm, 0.0739710713711999)) list_timings(MPI.COMM_WORLD, [TimingType.wall])
def test_RefineUnitSquareMesh(): """Refine mesh of unit square.""" mesh = UnitSquareMesh(MPI.COMM_WORLD, 5, 7, ghost_mode=GhostMode.none) mesh.topology.create_entities(1) mesh = refine(mesh, redistribute=False) assert mesh.topology.index_map(0).size_global == 165 assert mesh.topology.index_map(2).size_global == 280
def mesh_factory(tdim, n): if tdim == 1: return UnitIntervalMesh(MPI.COMM_WORLD, n) elif tdim == 2: return UnitSquareMesh(MPI.COMM_WORLD, n, n) elif tdim == 3: return UnitCubeMesh(MPI.COMM_WORLD, n, n, n)
def test_P_simplex_built_in(family, degree, cell_type, datadir): if cell_type == CellType.tetrahedron: mesh = UnitCubeMesh(MPI.COMM_WORLD, 5, 5, 5) elif cell_type == CellType.triangle: mesh = UnitSquareMesh(MPI.COMM_WORLD, 5, 5) V = FunctionSpace(mesh, (family, degree)) run_scalar_test(mesh, V, degree)