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)
