def test_p1_trace(has_dolfinx):
"""Test the trace of a P1 Dolfin function."""
if has_dolfinx:
import dolfinx
import dolfinx.geometry
else:
try:
import dolfinx
import dolfinx.geometry
except ImportError:
pytest.skip("DOLFIN-X must be installed to run this test")
import bempp.api
from bempp.api.external.fenicsx import fenics_to_bempp_trace_data
fenics_mesh = dolfinx.UnitCubeMesh(MPI.COMM_WORLD, 2, 2, 2)
fenics_space = dolfinx.FunctionSpace(fenics_mesh, ("CG", 1))
bempp_space, trace_matrix = fenics_to_bempp_trace_data(fenics_space)
fenics_coeffs = np.random.rand(fenics_space.dofmap.index_map.size_global)
bempp_coeffs = trace_matrix @ fenics_coeffs
fenics_fun = dolfinx.Function(fenics_space)
fenics_fun.vector[:] = fenics_coeffs
bempp_fun = bempp.api.GridFunction(bempp_space, coefficients=bempp_coeffs)
tree = dolfinx.geometry.BoundingBoxTree(fenics_mesh, 3)
for cell in bempp_space.grid.entity_iterator(0):
mid = cell.geometry.centroid
bempp_val = bempp_fun.evaluate(cell.index, np.array([[1 / 3], [1 / 3]]))
fenics_cell = dolfinx.geometry.compute_closest_entity(tree, mid, fenics_mesh)[0]
fenics_val = fenics_fun.eval([mid.T], [fenics_cell])
assert np.isclose(bempp_val[0, 0], fenics_val[0])
def test_additivity(mode):
mesh = dolfinx.UnitSquareMesh(MPI.COMM_WORLD, 12, 12, ghost_mode=mode)
V = dolfinx.FunctionSpace(mesh, ("CG", 1))
f1 = dolfinx.Function(V)
f2 = dolfinx.Function(V)
f3 = dolfinx.Function(V)
with f1.vector.localForm() as f1_local:
f1_local.set(1.0)
with f2.vector.localForm() as f2_local:
f2_local.set(2.0)
with f3.vector.localForm() as f3_local:
f3_local.set(3.0)
j1 = ufl.inner(f1, f1) * ufl.dx(mesh)
j2 = ufl.inner(f2, f2) * ufl.ds(mesh)
j3 = ufl.inner(ufl.avg(f3), ufl.avg(f3)) * ufl.dS(mesh)
# Assemble each scalar form separately
J1 = mesh.mpi_comm().allreduce(dolfinx.fem.assemble_scalar(j1), op=MPI.SUM)
J2 = mesh.mpi_comm().allreduce(dolfinx.fem.assemble_scalar(j2), op=MPI.SUM)
J3 = mesh.mpi_comm().allreduce(dolfinx.fem.assemble_scalar(j3), op=MPI.SUM)
# Sum forms and assemble the result
J12 = mesh.mpi_comm().allreduce(dolfinx.fem.assemble_scalar(j1 + j2), op=MPI.SUM)
J13 = mesh.mpi_comm().allreduce(dolfinx.fem.assemble_scalar(j1 + j3), op=MPI.SUM)
J23 = mesh.mpi_comm().allreduce(dolfinx.fem.assemble_scalar(j2 + j3), op=MPI.SUM)
J123 = mesh.mpi_comm().allreduce(dolfinx.fem.assemble_scalar(j1 + j2 + j3), op=MPI.SUM)
# Compare assembled values
assert (J1 + J2) == pytest.approx(J12)
assert (J1 + J3) == pytest.approx(J13)
assert (J2 + J3) == pytest.approx(J23)
assert (J1 + J2 + J3) == pytest.approx(J123)
def test_custom_mesh_loop_rank1():
# Create mesh and function space
mesh = dolfinx.generation.UnitSquareMesh(MPI.COMM_WORLD, 64, 64)
V = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
# Unpack mesh and dofmap data
pos = mesh.geometry.dofmap.offsets()
x_dofs = mesh.geometry.dofmap.array()
x = mesh.geometry.x
dofs = V.dofmap.list.array()
# Assemble with pure Numba function (two passes, first will include JIT overhead)
b0 = dolfinx.Function(V)
for i in range(2):
with b0.vector.localForm() as b:
b.set(0.0)
start = time.time()
assemble_vector(np.asarray(b), (pos, x_dofs, x), dofs)
end = time.time()
print("Time (numba, pass {}): {}".format(i, end - start))
b0.vector.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
assert (b0.vector.sum() == pytest.approx(1.0))
# Test against generated code and general assembler
v = ufl.TestFunction(V)
L = inner(1.0, v) * dx
start = time.time()
b1 = dolfinx.fem.assemble_vector(L)
end = time.time()
print("Time (C++, pass 1):", end - start)
with b1.localForm() as b_local:
b_local.set(0.0)
start = time.time()
dolfinx.fem.assemble_vector(b1, L)
end = time.time()
print("Time (C++, pass 2):", end - start)
b1.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert ((b1 - b0.vector).norm() == pytest.approx(0.0))
# Assemble using generated tabulate_tensor kernel and Numba assembler
b3 = dolfinx.Function(V)
ufc_form = dolfinx.jit.ffcx_jit(L)
kernel = ufc_form.create_cell_integral(-1).tabulate_tensor
for i in range(2):
with b3.vector.localForm() as b:
b.set(0.0)
start = time.time()
assemble_vector_ufc(np.asarray(b), kernel, (pos, x_dofs, x), dofs)
end = time.time()
print("Time (numba/cffi, pass {}): {}".format(i, end - start))
b3.vector.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
assert ((b3.vector - b0.vector).norm() == pytest.approx(0.0))
def test_custom_mesh_loop_cffi_rank2(set_vals):
"""Test numba assembler for bilinear form"""
mesh = dolfinx.generation.UnitSquareMesh(MPI.COMM_WORLD, 64, 64)
V = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
# Test against generated code and general assembler
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
A0 = dolfinx.fem.assemble_matrix(a)
A0.assemble()
A0.zeroEntries()
start = time.time()
dolfinx.fem.assemble_matrix(A0, a)
end = time.time()
print("Time (C++, pass 2):", end - start)
A0.assemble()
# Unpack mesh and dofmap data
pos = mesh.geometry.dofmap.offsets()
x_dofs = mesh.geometry.dofmap.array()
x = mesh.geometry.x
dofs = np.array(V.dofmap.list.array(), dtype=np.dtype(PETSc.IntType))
A1 = A0.copy()
for i in range(2):
A1.zeroEntries()
start = time.time()
assemble_matrix_cffi(A1.handle, (pos, x_dofs, x), dofs, set_vals, PETSc.InsertMode.ADD_VALUES)
end = time.time()
print("Time (Numba, pass {}): {}".format(i, end - start))
A1.assemble()
assert (A1 - A0).norm() == pytest.approx(0.0)
def test_assembly_dx_domains(mode):
mesh = dolfinx.generation.UnitSquareMesh(MPI.COMM_WORLD,
10,
10,
ghost_mode=mode)
V = dolfinx.FunctionSpace(mesh, ("CG", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
# Prepare a marking structures
# indices cover all cells
# values are [1, 2, 3, 3, ...]
cell_map = mesh.topology.index_map(mesh.topology.dim)
num_cells = cell_map.size_local + cell_map.num_ghosts
indices = numpy.arange(0, num_cells)
values = numpy.full(indices.shape, 3, dtype=numpy.intc)
values[0] = 1
values[1] = 2
marker = dolfinx.mesh.MeshTags(mesh, mesh.topology.dim, indices, values)
dx = ufl.Measure('dx', subdomain_data=marker, domain=mesh)
w = dolfinx.Function(V)
with w.vector.localForm() as w_local:
w_local.set(0.5)
bc = dolfinx.fem.DirichletBC(dolfinx.Function(V), range(30))
# Assemble matrix
a = w * ufl.inner(u, v) * (dx(1) + dx(2) + dx(3))
A = dolfinx.fem.assemble_matrix(a)
A.assemble()
a2 = w * ufl.inner(u, v) * dx
A2 = dolfinx.fem.assemble_matrix(a2)
A2.assemble()
assert (A - A2).norm() < 1.0e-12
# Assemble vector
L = ufl.inner(w, v) * (dx(1) + dx(2) + dx(3))
b = dolfinx.fem.assemble_vector(L)
dolfinx.fem.apply_lifting(b, [a], [[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b, [bc])
L2 = ufl.inner(w, v) * dx
b2 = dolfinx.fem.assemble_vector(L2)
dolfinx.fem.apply_lifting(b2, [a], [[bc]])
b2.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b2, [bc])
assert (b - b2).norm() < 1.0e-12
# Assemble scalar
L = w * (dx(1) + dx(2) + dx(3))
s = dolfinx.fem.assemble_scalar(L)
s = mesh.mpi_comm().allreduce(s, op=MPI.SUM)
assert s == pytest.approx(0.5, 1.0e-12)
L2 = w * dx
s2 = dolfinx.fem.assemble_scalar(L2)
s2 = mesh.mpi_comm().allreduce(s2, op=MPI.SUM)
assert s == pytest.approx(s2, 1.0e-12)
def test_assemble_manifold():
"""Test assembly of poisson problem on a mesh with topological dimension 1
but embedded in 2D (gdim=2).
"""
points = numpy.array([[0.0, 0.0], [0.2, 0.0], [0.4, 0.0], [0.6, 0.0],
[0.8, 0.0], [1.0, 0.0]],
dtype=numpy.float64)
cells = numpy.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]],
dtype=numpy.int32)
cell = ufl.Cell("interval", geometric_dimension=points.shape[1])
domain = ufl.Mesh(ufl.VectorElement("Lagrange", cell, 1))
mesh = create_mesh(MPI.COMM_WORLD, cells, points, domain)
assert mesh.geometry.dim == 2
assert mesh.topology.dim == 1
U = dolfinx.FunctionSpace(mesh, ("P", 1))
u, v = ufl.TrialFunction(U), ufl.TestFunction(U)
w = dolfinx.Function(U)
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx(mesh)
L = ufl.inner(1.0, v) * ufl.dx(mesh)
bcdofs = dolfinx.fem.locate_dofs_geometrical(
U, lambda x: numpy.isclose(x[0], 0.0))
bcs = [dolfinx.DirichletBC(w, bcdofs)]
A = dolfinx.fem.assemble_matrix(a, bcs)
A.assemble()
b = dolfinx.fem.assemble_vector(L)
dolfinx.fem.apply_lifting(b, [a], [bcs])
dolfinx.fem.set_bc(b, bcs)
assert numpy.isclose(b.norm(), 0.41231)
assert numpy.isclose(A.norm(), 25.0199)
def interpolate_on_mesh(self, mesh, q, u):
# Extract mesh geometry nodal coordinates
dm = mesh.geometry.dofmap
oq = [0] + [*range(2, q + 1)
] + [1] # reorder lineX nodes: all ducks in a row...
x0_idx = [[dm.links(i).tolist()[k] for k in oq]
for i in range(dm.num_nodes)]
x0_idx = [item for sublist in x0_idx for item in sublist]
x0 = mesh.geometry.x[x0_idx]
# Interpolate solution at mesh geometry nodes
import dolfinx
import dolfiny.interpolation
Q = dolfinx.FunctionSpace(mesh, ("P", q))
uf = dolfinx.Function(Q)
if isinstance(u, list):
ui = []
for u_ in u:
dolfiny.interpolation.interpolate(u_, uf)
ui.append(uf.vector[x0_idx])
else:
dolfiny.interpolation.interpolate(u, uf)
ui = uf.vector[x0_idx]
return x0, ui
def test_custom_mesh_loop_cffi_rank2(set_vals):
"""Test numba assembler for bilinear form"""
mesh = dolfinx.generation.UnitSquareMesh(dolfinx.MPI.comm_world, 64, 64)
V = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
# Test against generated code and general assembler
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
A0 = dolfinx.fem.assemble_matrix(a)
A0.assemble()
A0.zeroEntries()
start = time.time()
dolfinx.fem.assemble_matrix(A0, a)
end = time.time()
print("Time (C++, pass 2):", end - start)
A0.assemble()
# Unpack mesh and dofmap data
c = mesh.topology.connectivity(2, 0).array()
pos = mesh.topology.connectivity(2, 0).offsets()
geom = mesh.geometry.points
dofs = V.dofmap.dof_array
A1 = A0.copy()
for i in range(2):
A1.zeroEntries()
start = time.time()
assemble_matrix_cffi(A1.handle, (c, pos), geom, dofs, set_vals, PETSc.InsertMode.ADD_VALUES)
end = time.time()
print("Time (Numba, pass {}): {}".format(i, end - start))
A1.assemble()
assert (A1 - A0).norm() == pytest.approx(0.0)
def monolithic_solve():
"""Monolithic (interleaved) solver"""
P2_el = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1_el = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2_el * P1_el
W = dolfinx.FunctionSpace(mesh, TH)
(u, p) = ufl.TrialFunctions(W)
(v, q) = ufl.TestFunctions(W)
a00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
a01 = ufl.inner(p, ufl.div(v)) * dx
a10 = ufl.inner(ufl.div(u), q) * dx
a = a00 + a01 + a10
p00 = ufl.inner(ufl.grad(u), ufl.grad(v)) * dx
p11 = ufl.inner(p, q) * dx
p_form = p00 + p11
f = dolfinx.Function(W.sub(0).collapse())
p_zero = dolfinx.Function(W.sub(1).collapse())
L0 = inner(f, v) * dx
L1 = inner(p_zero, q) * dx
L = L0 + L1
bdofsW0_P2_0 = dolfinx.fem.locate_dofs_topological(
(W.sub(0), P2), facetdim, bndry_facets0)
bdofsW0_P2_1 = dolfinx.fem.locate_dofs_topological(
(W.sub(0), P2), facetdim, bndry_facets1)
bc0 = dolfinx.DirichletBC(u0, bdofsW0_P2_0, W.sub(0))
bc1 = dolfinx.DirichletBC(u0, bdofsW0_P2_1, W.sub(0))
A = dolfinx.fem.assemble_matrix(a, [bc0, bc1])
A.assemble()
P = dolfinx.fem.assemble_matrix(p_form, [bc0, bc1])
P.assemble()
b = dolfinx.fem.assemble_vector(L)
dolfinx.fem.apply_lifting(b, [a], [[bc0, bc1]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b, [bc0, bc1])
ksp = PETSc.KSP()
ksp.create(mesh.mpi_comm())
ksp.setOperators(A, P)
ksp.setType("minres")
pc = ksp.getPC()
pc.setType('lu')
def monitor(ksp, its, rnorm):
# print("Num it, rnorm:", its, rnorm)
pass
ksp.setTolerances(rtol=1.0e-8, max_it=50)
ksp.setMonitor(monitor)
ksp.setFromOptions()
x = A.createVecRight()
ksp.solve(b, x)
assert ksp.getConvergedReason() > 0
return b.norm(), x.norm(), A.norm(), P.norm()
def test_assemble_derivatives():
"""This test checks the original_coefficient_positions, which may change
under differentiation (some coefficients and constants are
eliminated)"""
mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12)
Q = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
u = dolfinx.Function(Q)
v = ufl.TestFunction(Q)
du = ufl.TrialFunction(Q)
b = dolfinx.Function(Q)
c1 = fem.Constant(mesh, [[1.0, 0.0], [3.0, 4.0]])
c2 = fem.Constant(mesh, 2.0)
with b.vector.localForm() as b_local:
b_local.set(2.0)
# derivative eliminates 'u' and 'c1'
L = ufl.inner(c1, c1) * v * dx + c2 * b * inner(u, v) * dx
a = derivative(L, u, du)
A1 = dolfinx.fem.assemble_matrix(a)
A1.assemble()
a = c2 * b * inner(du, v) * dx
A2 = dolfinx.fem.assemble_matrix(a)
A2.assemble()
assert (A1 - A2).norm() == pytest.approx(0.0, rel=1e-12, abs=1e-12)
def test_mpi_p2p():
N = 2
comm = MPI.COMM_WORLD
world_rank = comm.Get_rank()
world_size = comm.Get_size()
print(comm)
print("world rank ", world_rank)
# FEniCS mesh on rank 1
if world_rank == 1:
# print("self ", r_comm)
r_comm = MPI.COMM_SELF
fenics_mesh = dolfinx.UnitCubeMesh(r_comm, N, N, N)
fenics_space = dolfinx.FunctionSpace(fenics_mesh, ("CG", 1))
bm_nodes, bm_cells, bm_coords = bm_from_fenics_mesh(fenics_mesh)
bm_nodes_arr = np.asarray(bm_nodes, dtype='i')
# comm.send(bm_nodes, dest=0, tag=11)
# comm.Send([bm_nodes_arr, MPI.INT], dest=0, tag=0)
print(len(bm_cells))
print(type(bm_cells[0, 0]))
comm.Send([bm_cells, MPI.LONG], dest=0, tag=0)
elif world_rank == 0:
# comm = MPI.COMM_SELF
# data = comm.recv(source=1, tag=11)
info = MPI.Status()
comm.Probe(MPI.ANY_SOURCE, MPI.ANY_TAG, info)
elements = info.Get_elements(MPI.LONG)
# print(elements)
data = np.zeros(elements, dtype=np.int64)
comm.Recv([data, MPI.LONG], source=1, tag=0)
data = data.reshape(int(elements / 3), 3)
print(data)
def test_assembly_dx_domains(mesh):
V = dolfinx.FunctionSpace(mesh, ("CG", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
# Prepare a marking structures
# indices cover all cells
# values are [1, 2, 3, 3, ...]
imap = mesh.topology.index_map(mesh.topology.dim)
num_cells = imap.size_local + imap.num_ghosts
indices = numpy.arange(0, num_cells)
values = numpy.full(indices.shape, 3, dtype=numpy.intc)
values[0] = 1
values[1] = 2
marker = dolfinx.mesh.MeshTags(mesh, mesh.topology.dim, indices, values)
dx = ufl.Measure('dx', subdomain_data=marker, domain=mesh)
w = dolfinx.Function(V)
with w.vector.localForm() as w_local:
w_local.set(0.5)
# Assemble matrix
a = w * ufl.inner(u, v) * (dx(1) + dx(2) + dx(3))
A = dolfinx.fem.assemble_matrix(a)
A.assemble()
norm1 = A.norm()
a2 = w * ufl.inner(u, v) * dx
A2 = dolfinx.fem.assemble_matrix(a2)
A2.assemble()
norm2 = A2.norm()
assert norm1 == pytest.approx(norm2, 1.0e-12)
# Assemble vector
L = ufl.inner(w, v) * (dx(1) + dx(2) + dx(3))
b = dolfinx.fem.assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
L2 = ufl.inner(w, v) * dx
b2 = dolfinx.fem.assemble_vector(L2)
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert b.norm() == pytest.approx(b2.norm(), 1.0e-12)
# Assemble scalar
L = w * (dx(1) + dx(2) + dx(3))
s = dolfinx.fem.assemble_scalar(L)
s = mesh.mpi_comm().allreduce(s, op=MPI.SUM)
L2 = w * dx
s2 = dolfinx.fem.assemble_scalar(L2)
s2 = mesh.mpi_comm().allreduce(s2, op=MPI.SUM)
assert (s == pytest.approx(s2, 1.0e-12)
and 0.5 == pytest.approx(s, 1.0e-12))
def test_assembly_ds_domains(mesh):
V = dolfinx.FunctionSpace(mesh, ("CG", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
marker = dolfinx.MeshFunction("size_t", mesh, mesh.topology.dim - 1, 0)
def bottom(x):
return numpy.isclose(x[1], 0.0)
def top(x):
return numpy.isclose(x[1], 1.0)
def left(x):
return numpy.isclose(x[0], 0.0)
def right(x):
return numpy.isclose(x[0], 1.0)
marker.mark(bottom, 111)
marker.mark(top, 222)
marker.mark(left, 333)
marker.mark(right, 444)
ds = ufl.Measure('ds', subdomain_data=marker, domain=mesh)
w = dolfinx.Function(V)
with w.vector.localForm() as w_local:
w_local.set(0.5)
# Assemble matrix
a = w * ufl.inner(u, v) * (ds(111) + ds(222) + ds(333) + ds(444))
A = dolfinx.fem.assemble_matrix(a)
A.assemble()
norm1 = A.norm()
a2 = w * ufl.inner(u, v) * ds
A2 = dolfinx.fem.assemble_matrix(a2)
A2.assemble()
norm2 = A2.norm()
assert norm1 == pytest.approx(norm2, 1.0e-12)
# Assemble vector
L = ufl.inner(w, v) * (ds(111) + ds(222) + ds(333) + ds(444))
b = dolfinx.fem.assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
L2 = ufl.inner(w, v) * ds
b2 = dolfinx.fem.assemble_vector(L2)
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert b.norm() == pytest.approx(b2.norm(), 1.0e-12)
# Assemble scalar
L = w * (ds(111) + ds(222) + ds(333) + ds(444))
s = dolfinx.fem.assemble_scalar(L)
s = dolfinx.MPI.sum(mesh.mpi_comm(), s)
L2 = w * ds
s2 = dolfinx.fem.assemble_scalar(L2)
s2 = dolfinx.MPI.sum(mesh.mpi_comm(), s2)
assert (s == pytest.approx(s2, 1.0e-12)
and 2.0 == pytest.approx(s, 1.0e-12))
def solve_system(N):
fenics_mesh = dolfinx.UnitCubeMesh(fenicsx_comm, N, N, N)
fenics_space = dolfinx.FunctionSpace(fenics_mesh, ("CG", 1))
u = ufl.TrialFunction(fenics_space)
v = ufl.TestFunction(fenics_space)
k = 2
# print(u*v*ufl.ds)
form = (ufl.inner(ufl.grad(u), ufl.grad(v)) -
k**2 * ufl.inner(u, v)) * ufl.dx
# locate facets on the cube boundary
facets = locate_entities_boundary(
fenics_mesh, 2, lambda x: np.logical_or(
np.logical_or(
np.logical_or(np.isclose(x[2], 0.0), np.isclose(x[2], 1.0)),
np.logical_or(np.isclose(x[1], 0.0), np.isclose(x[1], 1.0))),
np.logical_or(np.isclose(x[0], 0.0), np.isclose(x[0], 1.0))))
facets.sort()
# alternative - more general approach
boundary = entities_to_geometry(
fenics_mesh,
fenics_mesh.topology.dim - 1,
exterior_facet_indices(fenics_mesh),
True,
)
# print(len(facets)
assert len(facets) == len(exterior_facet_indices(fenics_mesh))
u0 = fem.Function(fenics_space)
with u0.vector.localForm() as u0_loc:
u0_loc.set(0)
# solution vector
bc = DirichletBC(u0, locate_dofs_topological(fenics_space, 2, facets))
A = 1 + 1j
f = Function(fenics_space)
f.interpolate(lambda x: A * k**2 * np.cos(k * x[0]) * np.cos(k * x[1]))
L = ufl.inner(f, v) * ufl.dx
u0.name = "u"
problem = fem.LinearProblem(form,
L,
u=u0,
petsc_options={
"ksp_type": "preonly",
"pc_type": "lu"
})
# problem = fem.LinearProblem(form, L, bcs=[bc], u=u0, petsc_options={"ksp_type": "preonly", "pc_type": "lu"})
start_time = time.time()
soln = problem.solve()
if world_rank == 0:
print("--- fenics solve done in %s seconds ---" %
(time.time() - start_time))
def test_mixed_element_interpolation():
def f(x):
return np.ones(2, x.shape[1])
mesh = UnitCubeMesh(MPI.COMM_WORLD, 3, 3, 3)
el = ufl.FiniteElement("CG", mesh.ufl_cell(), 1)
V = dolfinx.FunctionSpace(mesh, ufl.MixedElement([el, el]))
u = dolfinx.Function(V)
with pytest.raises(RuntimeError):
u.interpolate(f)
def test_dof_coords_2d(degree):
mesh = dolfinx.UnitSquareMesh(MPI.COMM_WORLD, 10, 10)
V = dolfinx.FunctionSpace(mesh, ("CG", degree))
u = dolfinx.Function(V)
u.interpolate(lambda x: x[0])
u.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
x = V.tabulate_dof_coordinates()
val = u.vector.array
for i in range(len(val)):
assert np.isclose(x[i, 0], val[i], rtol=1e-3)
def test_mpi_p2p_alldata():
N = 2
comm = MPI.COMM_WORLD
world_rank = comm.Get_rank()
world_size = comm.Get_size()
print(comm)
print("world rank ", world_rank)
# FEniCS mesh on rank 1
if world_rank == 1:
# print("self ", r_comm)
r_comm = MPI.COMM_SELF
fenics_mesh = dolfinx.UnitCubeMesh(r_comm, N, N, N)
fenics_space = dolfinx.FunctionSpace(fenics_mesh, ("CG", 1))
bm_nodes, bm_cells, bm_coords = bm_from_fenics_mesh(fenics_mesh)
bm_nodes_arr = np.asarray(bm_nodes, dtype='i')
# comm.send(bm_nodes, dest=0, tag=11)
# comm.Send([bm_nodes_arr, MPI.INT], dest=0, tag=0)
print(len(bm_cells))
# print(type(bm_cells[0,0]))
comm.Send([bm_cells, MPI.LONG], dest=0, tag=0)
comm.Send([bm_coords, MPI.DOUBLE], dest=0, tag=1)
# convert list to numpy array
comm.Send([np.array(bm_nodes, np.int32), MPI.LONG], dest=0, tag=2)
elif world_rank == 0:
# comm = MPI.COMM_SELF
info = MPI.Status()
# BM_CELLS
comm.Probe(MPI.ANY_SOURCE, 0, info)
elements = info.Get_elements(MPI.LONG)
bm_cells = np.zeros(elements, dtype=np.int64)
comm.Recv([bm_cells, MPI.LONG], source=1, tag=0)
bm_cells = bm_cells.reshape(int(elements / 3), 3)
# BM_COORDS
comm.Probe(MPI.ANY_SOURCE, 1, info)
elements = info.Get_elements(MPI.DOUBLE)
bm_coords = np.zeros(elements, dtype=np.float64)
comm.Recv([bm_coords, MPI.DOUBLE], source=1, tag=1)
bm_coords = bm_coords.reshape(int(elements / 3), 3)
# BM_NODES
comm.Probe(MPI.ANY_SOURCE, 2, info)
elements = info.Get_elements(MPI.INT)
bm_nodes = np.zeros(elements, dtype=np.int32)
comm.Recv([bm_nodes, MPI.INT], source=1, tag=2)
print(bm_nodes)
print(bm_coords)
print(bm_cells)
def test_refine_create_form():
"""Check that forms can be assembled on refined mesh"""
mesh = dolfinx.UnitCubeMesh(MPI.COMM_WORLD, 3, 3, 3)
mesh.topology.create_entities(1)
mesh = refine(mesh, redistribute=True)
V = dolfinx.FunctionSpace(mesh, ("CG", 1))
# Define variational problem
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
dolfinx.fem.assemble_matrix(a)
def monolithic_assembly(clock, reps, mesh, use_cpp_forms):
P2_el = ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2)
P1_el = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
TH = P2_el * P1_el
W = dolfinx.FunctionSpace(mesh, TH)
num_dofs = W.dim
U = dolfinx.Function(W)
u, p = ufl.split(U)
v, q = ufl.TestFunctions(W)
g = ufl.as_vector([0.0, 0.0, -1.0])
F = (
ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
+ ufl.inner(p, ufl.div(v)) * ufl.dx
+ ufl.inner(ufl.div(u), q) * ufl.dx
- ufl.inner(g, v) * ufl.dx
)
J = ufl.derivative(F, U, ufl.TrialFunction(W))
bcs = []
# Get jitted forms for better performance
if use_cpp_forms:
F = dolfinx.fem.assemble._create_cpp_form(F)
J = dolfinx.fem.assemble._create_cpp_form(J)
b = dolfinx.fem.create_vector(F)
A = dolfinx.fem.create_matrix(J)
for i in range(reps):
A.zeroEntries()
with b.localForm() as b_local:
b_local.set(0.0)
with dolfinx.common.Timer("ZZZ Mat Monolithic") as tmr:
dolfinx.fem.assemble_matrix(A, J, bcs)
A.assemble()
clock["mat"] += tmr.elapsed()[0]
with dolfinx.common.Timer("ZZZ Vec Monolithic") as tmr:
dolfinx.fem.assemble_vector(b, F)
dolfinx.fem.apply_lifting(b, [J], bcs=[bcs], x0=[U.vector], scale=-1.0)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b, bcs, x0=U.vector, scale=-1.0)
b.ghostUpdate(addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD)
clock["vec"] += tmr.elapsed()[0]
return num_dofs, A, b
def test_basic_assembly(mode):
mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12, ghost_mode=mode)
V = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
f = dolfinx.Function(V)
with f.vector.localForm() as f_local:
f_local.set(10.0)
a = inner(f * u, v) * dx + inner(u, v) * ds
L = inner(f, v) * dx + inner(2.0, v) * ds
# Initial assembly
A = dolfinx.fem.assemble_matrix(a)
A.assemble()
assert isinstance(A, PETSc.Mat)
b = dolfinx.fem.assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert isinstance(b, PETSc.Vec)
# Second assembly
normA = A.norm()
A.zeroEntries()
A = dolfinx.fem.assemble_matrix(A, a)
A.assemble()
assert isinstance(A, PETSc.Mat)
assert normA == pytest.approx(A.norm())
normb = b.norm()
with b.localForm() as b_local:
b_local.set(0.0)
b = dolfinx.fem.assemble_vector(b, L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert isinstance(b, PETSc.Vec)
assert normb == pytest.approx(b.norm())
# Vector re-assembly - no zeroing (but need to zero ghost entries)
with b.localForm() as b_local:
b_local.array[b.local_size:] = 0.0
dolfinx.fem.assemble_vector(b, L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert 2.0 * normb == pytest.approx(b.norm())
# Matrix re-assembly (no zeroing)
dolfinx.fem.assemble_matrix(A, a)
A.assemble()
assert 2.0 * normA == pytest.approx(A.norm())
def test_custom_mesh_loop_ctypes_rank2():
"""Test numba assembler for bilinear form"""
# Create mesh and function space
mesh = dolfinx.generation.UnitSquareMesh(MPI.COMM_WORLD, 64, 64)
V = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
# Extract mesh and dofmap data
num_owned_cells = mesh.topology.index_map(mesh.topology.dim).size_local
num_cells = num_owned_cells + mesh.topology.index_map(
mesh.topology.dim).num_ghosts
x_dofs = mesh.geometry.dofmap.array.reshape(num_cells, 3)
x = mesh.geometry.x
dofmap = V.dofmap.list.array.reshape(num_cells,
3).astype(np.dtype(PETSc.IntType))
# Generated case with general assembler
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
A0 = dolfinx.fem.assemble_matrix(a)
A0.assemble()
A0.zeroEntries()
start = time.time()
dolfinx.fem.assemble_matrix(A0, a)
end = time.time()
print("Time (C++, pass 2):", end - start)
A0.assemble()
# Custom case
A1 = A0.copy()
for i in range(2):
A1.zeroEntries()
mat = A1.handle
start = time.time()
assemble_matrix_ctypes(mat, (x_dofs, x), dofmap, num_owned_cells,
MatSetValues_ctypes,
PETSc.InsertMode.ADD_VALUES)
end = time.time()
print("Time (numba, pass {}): {}".format(i, end - start))
A1.assemble()
assert (A0 - A1).norm() == pytest.approx(0.0, abs=1.0e-9)
def test_custom_mesh_loop_ctypes_rank2():
"""Test numba assembler for bilinear form"""
# Create mesh and function space
mesh = dolfinx.generation.UnitSquareMesh(dolfinx.MPI.comm_world, 64, 64)
V = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
# Extract mesh and dofmap data
c = mesh.topology.connectivity(2, 0).array()
pos = mesh.topology.connectivity(2, 0).offsets()
geom = mesh.geometry.points
dofs = V.dofmap.dof_array
# Generated case with general assembler
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
A0 = dolfinx.fem.assemble_matrix(a)
A0.assemble()
A0.zeroEntries()
start = time.time()
dolfinx.fem.assemble_matrix(A0, a)
end = time.time()
print("Time (C++, pass 2):", end - start)
A0.assemble()
# Custom case
A1 = A0.copy()
for i in range(2):
A1.zeroEntries()
mat = A1.handle
start = time.time()
assemble_matrix_ctypes(mat, (c, pos), geom, dofs, MatSetValues_ctypes,
PETSc.InsertMode.ADD_VALUES)
end = time.time()
print("Time (numba, pass {}): {}".format(i, end - start))
A1.assemble()
assert (A0 - A1).norm() == pytest.approx(0.0, abs=1.0e-9)
def test_subcomms(N):
comm = MPI.COMM_WORLD
world_rank = comm.Get_rank()
world_size = comm.Get_size()
group = comm.Get_group()
newgroup = group.Excl([0])
newcomm = comm.Create(newgroup)
if world_rank == 0:
assert newcomm == MPI.COMM_NULL
else:
assert newcomm.size == comm.size - 1
assert newcomm.rank == comm.rank - 1
fenics_mesh = dolfinx.UnitCubeMesh(newcomm, N, N, N)
fenics_space = dolfinx.FunctionSpace(fenics_mesh, ("CG", 1))
group.Free()
newgroup.Free()
if newcomm: newcomm.Free()
print("done")
def test_monolithic(V1, V2, squaremesh_5):
mesh = squaremesh_5
Wel = ufl.MixedElement([V1.ufl_element(), V2.ufl_element()])
W = dolfinx.FunctionSpace(mesh, Wel)
u = dolfinx.Function(W)
u0, u1 = ufl.split(u)
v = ufl.TestFunction(W)
v0, v1 = ufl.split(v)
Phi = (ufl.sin(u0) - 0.5)**2 * ufl.dx(mesh) + (4.0 * u0 -
u1)**2 * ufl.dx(mesh)
F = ufl.derivative(Phi, u, v)
opts = PETSc.Options("monolithic")
opts.setValue('snes_type', 'newtonls')
opts.setValue('snes_linesearch_type', 'basic')
opts.setValue('snes_rtol', 1.0e-10)
opts.setValue('snes_max_it', 20)
opts.setValue('ksp_type', 'preonly')
opts.setValue('pc_type', 'lu')
opts.setValue('pc_factor_mat_solver_type', 'mumps')
problem = dolfiny.snesblockproblem.SNESBlockProblem([F], [u],
prefix="monolithic")
sol, = problem.solve()
u0, u1 = sol.split()
u0 = u0.collapse()
u1 = u1.collapse()
assert np.isclose((u0.vector - np.arcsin(0.5)).norm(), 0.0)
assert np.isclose((u1.vector - 4.0 * np.arcsin(0.5)).norm(), 0.0)
def test_assemble_manifold():
"""Test assembly of poisson problem on a mesh with topological dimension 1
but embedded in 2D (gdim=2).
"""
points = numpy.array([[0.0, 0.0], [0.2, 0.0], [0.4, 0.0], [0.6, 0.0],
[0.8, 0.0], [1.0, 0.0]],
dtype=numpy.float64)
cells = numpy.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]],
dtype=numpy.int32)
mesh = dolfinx.Mesh(dolfinx.MPI.comm_world,
dolfinx.cpp.mesh.CellType.interval, points, cells, [],
dolfinx.cpp.mesh.GhostMode.none)
mesh.geometry.coord_mapping = dolfinx.fem.create_coordinate_map(mesh)
assert mesh.geometry.dim == 2
assert mesh.topology.dim == 1
U = dolfinx.FunctionSpace(mesh, ("P", 1))
u, v = ufl.TrialFunction(U), ufl.TestFunction(U)
w = dolfinx.Function(U)
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx(mesh)
L = ufl.inner(1.0, v) * ufl.dx(mesh)
bcdofs = dolfinx.fem.locate_dofs_geometrical(
U, lambda x: numpy.isclose(x[0], 0.0))
bcs = [dolfinx.DirichletBC(w, bcdofs)]
A = dolfinx.fem.assemble_matrix(a, bcs)
A.assemble()
b = dolfinx.fem.assemble_vector(L)
dolfinx.fem.apply_lifting(b, [a], [bcs])
dolfinx.fem.set_bc(b, bcs)
assert numpy.isclose(b.norm(), 0.41231)
assert numpy.isclose(A.norm(), 25.0199)
def test_assembly_bcs(mode):
mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12, ghost_mode=mode)
V = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx + inner(u, v) * ds
L = inner(1.0, v) * dx
def boundary(x):
return numpy.logical_or(x[0] < 1.0e-6, x[0] > 1.0 - 1.0e-6)
bdofsV = dolfinx.fem.locate_dofs_geometrical(V, boundary)
u_bc = dolfinx.fem.Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(1.0)
bc = dolfinx.fem.dirichletbc.DirichletBC(u_bc, bdofsV)
# Assemble and apply 'global' lifting of bcs
A = dolfinx.fem.assemble_matrix(a)
A.assemble()
b = dolfinx.fem.assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
g = b.duplicate()
with g.localForm() as g_local:
g_local.set(0.0)
dolfinx.fem.set_bc(g, [bc])
f = b - A * g
dolfinx.fem.set_bc(f, [bc])
# Assemble vector and apply lifting of bcs during assembly
b = dolfinx.fem.assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
b_bc = dolfinx.fem.assemble_vector(L)
dolfinx.fem.apply_lifting(b_bc, [a], [[bc]])
b_bc.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
dolfinx.fem.set_bc(b_bc, [bc])
assert (f - b_bc).norm() == pytest.approx(0.0, rel=1e-12, abs=1e-12)
def test_eigen_assembly(mode):
"""Compare assembly into scipy.CSR matrix with PETSc assembly"""
mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12, ghost_mode=mode)
Q = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
u = ufl.TrialFunction(Q)
v = ufl.TestFunction(Q)
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
def boundary(x):
return numpy.logical_or(x[0] < 1.0e-6, x[0] > 1.0 - 1.0e-6)
bdofsQ = dolfinx.fem.locate_dofs_geometrical(Q, boundary)
u_bc = dolfinx.function.Function(Q)
with u_bc.vector.localForm() as u_local:
u_local.set(1.0)
bc = dolfinx.fem.dirichletbc.DirichletBC(u_bc, bdofsQ)
A1 = dolfinx.fem.assemble_matrix(a, [bc])
A1.assemble()
A2 = dolfinx.fem.assemble_csr_matrix(a, [bc])
assert numpy.isclose(A1.norm(), scipy.sparse.linalg.norm(A2))
def V2(squaremesh_5):
return dolfinx.FunctionSpace(squaremesh_5, ("P", 2))
from mpi4py import MPI
from petsc4py import PETSc
filedir = os.path.dirname(__file__)
infile = dolfinx.io.XDMFFile(MPI.COMM_WORLD,
os.path.join(filedir, "cooks_tri_mesh.xdmf"),
"r",
encoding=dolfinx.cpp.io.XDMFFile.Encoding.ASCII)
mesh = infile.read_mesh(name="Grid")
infile.close()
# Stress (Se) and displacement (Ue) elements
Se = ufl.TensorElement("DG", mesh.ufl_cell(), 1, symmetry=True)
Ue = ufl.VectorElement("CG", mesh.ufl_cell(), 2)
S = dolfinx.FunctionSpace(mesh, Se)
U = dolfinx.FunctionSpace(mesh, Ue)
# Get local dofmap sizes for later local tensor tabulations
Ssize = S.dolfin_element().space_dimension()
Usize = U.dolfin_element().space_dimension()
sigma, tau = ufl.TrialFunction(S), ufl.TestFunction(S)
u, v = ufl.TrialFunction(U), ufl.TestFunction(U)
def free_end(x):
"""Marks the leftmost points of the cantilever"""
return numpy.isclose(x[0], 48.0)
def test_custom_mesh_loop_rank1():
# Create mesh and function space
mesh = dolfinx.generation.UnitSquareMesh(MPI.COMM_WORLD, 64, 64)
V = dolfinx.FunctionSpace(mesh, ("Lagrange", 1))
# Unpack mesh and dofmap data
num_owned_cells = mesh.topology.index_map(mesh.topology.dim).size_local
num_cells = num_owned_cells + mesh.topology.index_map(mesh.topology.dim).num_ghosts
x_dofs = mesh.geometry.dofmap.array.reshape(num_cells, 3)
x = mesh.geometry.x
dofmap = V.dofmap.list.array.reshape(num_cells, 3)
dofmap_t = dolfinx.cpp.fem.transpose_dofmap(V.dofmap.list, num_owned_cells)
# Assemble with pure Numba function (two passes, first will include
# JIT overhead)
b0 = dolfinx.Function(V)
for i in range(2):
with b0.vector.localForm() as b:
b.set(0.0)
start = time.time()
assemble_vector(np.asarray(b), (x_dofs, x), dofmap, num_owned_cells)
end = time.time()
print("Time (numba, pass {}): {}".format(i, end - start))
b0.vector.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert b0.vector.sum() == pytest.approx(1.0)
# Assemble with pure Numba function using parallel loop (two passes,
# first will include JIT overhead)
btmp = dolfinx.Function(V)
for i in range(2):
with btmp.vector.localForm() as b:
b.set(0.0)
start = time.time()
assemble_vector_parallel(np.asarray(b), x_dofs, x,
dofmap_t.array, dofmap_t.offsets,
num_owned_cells)
end = time.time()
print("Time (numba parallel, pass {}): {}".format(i, end - start))
btmp.vector.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert (btmp.vector - b0.vector).norm() == pytest.approx(0.0)
# Test against generated code and general assembler
v = ufl.TestFunction(V)
L = inner(1.0, v) * dx
start = time.time()
b1 = dolfinx.fem.assemble_vector(L)
end = time.time()
print("Time (C++, pass 0):", end - start)
with b1.localForm() as b_local:
b_local.set(0.0)
start = time.time()
dolfinx.fem.assemble_vector(b1, L)
end = time.time()
print("Time (C++, pass 1):", end - start)
b1.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert (b1 - b0.vector).norm() == pytest.approx(0.0)
# Assemble using generated tabulate_tensor kernel and Numba assembler
b3 = dolfinx.Function(V)
ufc_form, module, code = dolfinx.jit.ffcx_jit(mesh.mpi_comm(), L)
# First 0 for "cell" integrals, second 0 for the first one, i.e. default domain
kernel = ufc_form.integrals(0)[0].tabulate_tensor
for i in range(2):
with b3.vector.localForm() as b:
b.set(0.0)
start = time.time()
assemble_vector_ufc(np.asarray(b), kernel, (x_dofs, x), dofmap, num_owned_cells)
end = time.time()
print("Time (numba/cffi, pass {}): {}".format(i, end - start))
b3.vector.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert (b3.vector - b0.vector).norm() == pytest.approx(0.0)