def test_basic_assembly_constant(mode):
"""Tests assembly with Constant
The following test should be sensitive to order of flattening the
matrix-valued constant.
"""
mesh = create_unit_square(MPI.COMM_WORLD, 5, 5, ghost_mode=mode)
V = FunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
c = Constant(mesh, np.array([[1.0, 2.0], [5.0, 3.0]], PETSc.ScalarType))
a = inner(c[1, 0] * u, v) * dx + inner(c[1, 0] * u, v) * ds
L = inner(c[1, 0], v) * dx + inner(c[1, 0], v) * ds
a, L = form(a), form(L)
# Initial assembly
A1 = assemble_matrix(a)
A1.assemble()
b1 = assemble_vector(L)
b1.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
c.value = [[1.0, 2.0], [3.0, 4.0]]
A2 = assemble_matrix(a)
A2.assemble()
b2 = assemble_vector(L)
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert (A1 * 3.0 - A2 * 5.0).norm() == pytest.approx(0.0)
assert (b1 * 3.0 - b2 * 5.0).norm() == pytest.approx(0.0)
def test_assemble_derivatives():
"""This test checks the original_coefficient_positions, which may change
under differentiation (some coefficients and constants are
eliminated)"""
mesh = create_unit_square(MPI.COMM_WORLD, 12, 12)
Q = FunctionSpace(mesh, ("Lagrange", 1))
u = Function(Q)
v = ufl.TestFunction(Q)
du = ufl.TrialFunction(Q)
b = Function(Q)
c1 = Constant(mesh, np.array([[1.0, 0.0], [3.0, 4.0]], PETSc.ScalarType))
c2 = Constant(mesh, PETSc.ScalarType(2.0))
b.x.array[:] = 2.0
# derivative eliminates 'u' and 'c1'
L = ufl.inner(c1, c1) * v * dx + c2 * b * inner(u, v) * dx
a = form(derivative(L, u, du))
A1 = assemble_matrix(a)
A1.assemble()
a = form(c2 * b * inner(du, v) * dx)
A2 = assemble_matrix(a)
A2.assemble()
assert (A1 - A2).norm() == pytest.approx(0.0, rel=1e-12, abs=1e-12)
def solve(self) -> fem.Function:
"""Solve the problem."""
# Assemble lhs
self._A.zeroEntries()
fem.assemble_matrix(self._A, self._a, bcs=self.bcs)
self._A.assemble()
# Assemble rhs
with self._b.localForm() as b_loc:
b_loc.set(0)
fem.assemble_vector(self._b, self._L)
# Apply boundary conditions to the rhs
fem.apply_lifting(self._b, [self._a], [self.bcs])
self._b.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
fem.set_bc(self._b, self.bcs)
# Solve linear system and update ghost values in the solution
self._solver.solve(self._b, self.u.vector)
self.u.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
return self.u
def test_pack_coefficients():
"""Test packing of form coefficients ahead of main assembly call"""
mesh = create_unit_square(MPI.COMM_WORLD, 12, 15)
V = FunctionSpace(mesh, ("Lagrange", 1))
# Non-blocked
u = Function(V)
v = ufl.TestFunction(V)
c = Constant(mesh, PETSc.ScalarType(12.0))
F = ufl.inner(c, v) * dx - c * ufl.sqrt(u * u) * ufl.inner(u, v) * dx
u.x.array[:] = 10.0
_F = form(F)
# -- Test vector
b0 = assemble_vector(_F)
b0.assemble()
constants = pack_constants(_F)
coeffs = pack_coefficients(_F)
with b0.localForm() as _b0:
for c in [(None, None), (None, coeffs), (constants, None), (constants, coeffs)]:
b = assemble_vector(_F, coeffs=c)
b.assemble()
with b.localForm() as _b:
assert (_b0.array_r == _b.array_r).all()
# Change coefficients
constants *= 5.0
for coeff in coeffs.values():
coeff *= 5.0
with b0.localForm() as _b0:
for c in [(None, coeffs), (constants, None), (constants, coeffs)]:
b = assemble_vector(_F, coeffs=c)
b.assemble()
with b.localForm() as _b:
assert (_b0 - _b).norm() > 1.0e-5
# -- Test matrix
du = ufl.TrialFunction(V)
J = ufl.derivative(F, u, du)
J = form(J)
A0 = assemble_matrix(J)
A0.assemble()
constants = pack_constants(J)
coeffs = pack_coefficients(J)
for c in [(None, None), (None, coeffs), (constants, None), (constants, coeffs)]:
A = assemble_matrix(J, coeffs=c)
A.assemble()
assert pytest.approx((A - A0).norm(), 1.0e-12) == 0.0
# Change coefficients
constants *= 5.0
for coeff in coeffs.values():
coeff *= 5.0
for c in [(None, coeffs), (constants, None), (constants, coeffs)]:
A = assemble_matrix(J, coeffs=c)
A.assemble()
assert (A - A0).norm() > 1.0e-5
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 = 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 = Function(W.sub(0).collapse()[0])
p_zero = Function(W.sub(1).collapse()[0])
L0 = inner(f, v) * dx
L1 = inner(p_zero, q) * dx
L = L0 + L1
a, p_form, L = form(a), form(p_form), form(L)
bdofsW0_P2_0 = locate_dofs_topological(W.sub(0), facetdim, bndry_facets0)
bdofsW0_P2_1 = locate_dofs_topological(W.sub(0), facetdim, bndry_facets1)
bc0 = dirichletbc(bc_value, bdofsW0_P2_0, W.sub(0))
bc1 = dirichletbc(bc_value, bdofsW0_P2_1, W.sub(0))
A = assemble_matrix(a, bcs=[bc0, bc1])
A.assemble()
P = assemble_matrix(p_form, bcs=[bc0, bc1])
P.assemble()
b = assemble_vector(L)
apply_lifting(b, [a], bcs=[[bc0, bc1]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc0, bc1])
ksp = PETSc.KSP()
ksp.create(mesh.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 J_mono(self, snes, x, J, P):
J.zeroEntries()
assemble_matrix(J, self.a, bcs=self.bcs, diagonal=1.0)
J.assemble()
if self.a_precon is not None:
P.zeroEntries()
assemble_matrix(P, self.a_precon, bcs=self.bcs, diagonal=1.0)
P.assemble()
def J(self, x):
"""Assemble Jacobian matrix."""
if self._J is None:
self._J = fem.assemble_matrix(self.a, [self.bc])
else:
self._J.zeroEntries()
self._J = fem.assemble_matrix(self._J, self.a, [self.bc])
self._J.assemble()
return self._J
def test_assembly_dx_domains(mode):
mesh = create_unit_square(MPI.COMM_WORLD, 10, 10, ghost_mode=mode)
V = FunctionSpace(mesh, ("Lagrange", 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 = np.arange(0, num_cells)
values = np.full(indices.shape, 3, dtype=np.intc)
values[0] = 1
values[1] = 2
marker = MeshTags(mesh, mesh.topology.dim, indices, values)
dx = ufl.Measure('dx', subdomain_data=marker, domain=mesh)
w = Function(V)
w.x.array[:] = 0.5
# Assemble matrix
a = form(w * ufl.inner(u, v) * (dx(1) + dx(2) + dx(3)))
A = assemble_matrix(a)
A.assemble()
a2 = form(w * ufl.inner(u, v) * dx)
A2 = assemble_matrix(a2)
A2.assemble()
assert (A - A2).norm() < 1.0e-12
bc = dirichletbc(Function(V), range(30))
# Assemble vector
L = form(ufl.inner(w, v) * (dx(1) + dx(2) + dx(3)))
b = assemble_vector(L)
apply_lifting(b, [a], [[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
L2 = form(ufl.inner(w, v) * dx)
b2 = assemble_vector(L2)
apply_lifting(b2, [a], [[bc]])
b2.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
set_bc(b2, [bc])
assert (b - b2).norm() < 1.0e-12
# Assemble scalar
L = form(w * (dx(1) + dx(2) + dx(3)))
s = assemble_scalar(L)
s = mesh.comm.allreduce(s, op=MPI.SUM)
assert s == pytest.approx(0.5, 1.0e-12)
L2 = form(w * dx)
s2 = assemble_scalar(L2)
s2 = mesh.comm.allreduce(s2, op=MPI.SUM)
assert s == pytest.approx(s2, 1.0e-12)
def J(self, snes, x: PETSc.Vec, A: PETSc.Mat, P: PETSc.Mat):
"""Assemble the Jacobian matrix.
Parameters
==========
x: Vector containing the latest solution.
A: Matrix to assemble the Jacobian into.
"""
A.zeroEntries()
assemble_matrix(A, self.J_form, self.bcs)
A.assemble()
def J(self, x: PETSc.Vec, A: PETSc.Mat):
"""Assemble the Jacobian matrix.
Parameters
----------
x
The vector containing the latest solution
A
The matrix to assemble the Jacobian into
"""
A.zeroEntries()
fem.assemble_matrix(A, self._a, self.bcs)
A.assemble()
def test_refine_create_form():
"""Check that forms can be assembled on refined mesh"""
mesh = create_unit_cube(MPI.COMM_WORLD, 3, 3, 3)
mesh.topology.create_entities(1)
mesh = refine(mesh, redistribute=True)
V = FunctionSpace(mesh, ("Lagrange", 1))
# Define variational problem
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = form(ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx)
assemble_matrix(a)
def test_complex_assembly():
"""Test assembly of complex matrices and vectors"""
mesh = create_unit_square(MPI.COMM_WORLD, 10, 10)
P2 = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 2)
V = FunctionSpace(mesh, P2)
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
g = -2 + 3.0j
j = 1.0j
a_real = form(inner(u, v) * dx)
L1 = form(inner(g, v) * dx)
b = assemble_vector(L1)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
bnorm = b.norm(PETSc.NormType.N1)
b_norm_ref = abs(-2 + 3.0j)
assert bnorm == pytest.approx(b_norm_ref)
A = assemble_matrix(a_real)
A.assemble()
A0_norm = A.norm(PETSc.NormType.FROBENIUS)
x = ufl.SpatialCoordinate(mesh)
a_imag = form(j * inner(u, v) * dx)
f = 1j * ufl.sin(2 * np.pi * x[0])
L0 = form(inner(f, v) * dx)
A = assemble_matrix(a_imag)
A.assemble()
A1_norm = A.norm(PETSc.NormType.FROBENIUS)
assert A0_norm == pytest.approx(A1_norm)
b = assemble_vector(L0)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
b1_norm = b.norm(PETSc.NormType.N2)
a_complex = form((1 + j) * inner(u, v) * dx)
f = ufl.sin(2 * np.pi * x[0])
L2 = form(inner(f, v) * dx)
A = assemble_matrix(a_complex)
A.assemble()
A2_norm = A.norm(PETSc.NormType.FROBENIUS)
assert A1_norm == pytest.approx(A2_norm / np.sqrt(2))
b = assemble_vector(L2)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
b2_norm = b.norm(PETSc.NormType.N2)
assert b2_norm == pytest.approx(b1_norm)
def test_nullspace_check(mesh, degree):
V = VectorFunctionSpace(mesh, ('Lagrange', degree))
u, v = TrialFunction(V), TestFunction(V)
E, nu = 2.0e2, 0.3
mu = E / (2.0 * (1.0 + nu))
lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
def sigma(w, gdim):
return 2.0 * mu * ufl.sym(grad(w)) + lmbda * ufl.tr(
grad(w)) * ufl.Identity(gdim)
a = inner(sigma(u, mesh.geometry.dim), grad(v)) * dx
# Assemble matrix and create compatible vector
A = assemble_matrix(a)
A.assemble()
# Create null space basis and test
null_space = build_elastic_nullspace(V)
assert null_space.in_nullspace(A, tol=1.0e-8)
null_space.orthonormalize()
assert null_space.in_nullspace(A, tol=1.0e-8)
# Create incorrect null space basis and test
null_space = build_broken_elastic_nullspace(V)
assert not null_space.in_nullspace(A, tol=1.0e-8)
null_space.orthonormalize()
assert not null_space.in_nullspace(A, tol=1.0e-8)
def test_assemble_manifold():
"""Test assembly of poisson problem on a mesh with topological
dimension 1 but embedded in 2D (gdim=2)"""
points = np.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=np.float64)
cells = np.array([[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]], dtype=np.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 = FunctionSpace(mesh, ("P", 1))
u, v = ufl.TrialFunction(U), ufl.TestFunction(U)
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx(mesh)
L = ufl.inner(1.0, v) * ufl.dx(mesh)
a, L = form(a), form(L)
bcdofs = locate_dofs_geometrical(U, lambda x: np.isclose(x[0], 0.0))
bcs = [dirichletbc(PETSc.ScalarType(0), bcdofs, U)]
A = assemble_matrix(a, bcs=bcs)
A.assemble()
b = assemble_vector(L)
apply_lifting(b, [a], bcs=[bcs])
set_bc(b, bcs)
assert np.isclose(b.norm(), 0.41231)
assert np.isclose(A.norm(), 25.0199)
def solve(dtype=np.float32):
"""Solve the variational problem"""
# Process forms. This will compile the forms for the requested type.
a0 = fem.form(a, dtype=dtype)
if np.issubdtype(dtype, np.complexfloating):
L0 = fem.form(L, dtype=dtype)
else:
L0 = fem.form(ufl.replace(L, {fc: 0, gc: 0}), dtype=dtype)
# Create a Dirichlet boundary condition
bc = fem.dirichletbc(value=dtype(0), dofs=dofs, V=V)
# Assemble forms
A = fem.assemble_matrix(a0, [bc])
A.finalize()
b = fem.assemble_vector(L0)
fem.apply_lifting(b.array, [a0], bcs=[[bc]])
b.scatter_reverse(common.ScatterMode.add)
fem.set_bc(b.array, [bc])
# Create a Scipy sparse matrix that shares data with A
As = scipy.sparse.csr_matrix((A.data, A.indices, A.indptr))
# Solve the variational problem and return the solution
uh = fem.Function(V, dtype=dtype)
uh.x.array[:] = scipy.sparse.linalg.spsolve(As, b.array)
return uh
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_ghost_mesh_assembly(mode, dx, ds):
mesh = UnitSquareMesh(MPI.COMM_WORLD, 12, 12, ghost_mode=mode)
V = FunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
dx = dx(mesh)
ds = ds(mesh)
f = 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 = fem.assemble_matrix(a)
A.assemble()
assert isinstance(A, PETSc.Mat)
b = fem.assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
assert isinstance(b, PETSc.Vec)
# Check that the norms are the same for all three modes
normA = A.norm()
assert normA == pytest.approx(0.6713621455570528, rel=1.e-6, abs=1.e-12)
normb = b.norm()
assert normb == pytest.approx(1.582294032953906, rel=1.e-6, abs=1.e-12)
def test_vector_assemble_matrix_interior():
mesh = create_unit_square(MPI.COMM_WORLD, 3, 3)
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = form(ufl.inner(ufl.jump(u), ufl.jump(v)) * ufl.dS)
A = assemble_matrix(a)
A.assemble()
def test_assembly_bcs(mode):
mesh = create_unit_square(MPI.COMM_WORLD, 12, 12, ghost_mode=mode)
V = 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
a, L = form(a), form(L)
bdofsV = locate_dofs_geometrical(V, lambda x: np.logical_or(np.isclose(x[0], 0.0), np.isclose(x[0], 1.0)))
bc = dirichletbc(PETSc.ScalarType(1), bdofsV, V)
# Assemble and apply 'global' lifting of bcs
A = assemble_matrix(a)
A.assemble()
b = 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)
set_bc(g, [bc])
f = b - A * g
set_bc(f, [bc])
# Assemble vector and apply lifting of bcs during assembly
b_bc = assemble_vector(L)
apply_lifting(b_bc, [a], [[bc]])
b_bc.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b_bc, [bc])
assert (f - b_bc).norm() == pytest.approx(0.0, rel=1e-12, abs=1e-12)
def run_scalar_test(mesh, V, degree):
""" Manufactured Poisson problem, solving u = x[1]**p, where p is the
degree of the Lagrange function space.
"""
u, v = TrialFunction(V), TestFunction(V)
a = inner(grad(u), grad(v)) * dx
# Get quadrature degree for bilinear form integrand (ignores effect of non-affine map)
a = inner(grad(u), grad(v)) * dx(metadata={"quadrature_degree": -1})
a.integrals()[0].metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(a)
a = form(a)
# Source term
x = SpatialCoordinate(mesh)
u_exact = x[1]**degree
f = -div(grad(u_exact))
# Set quadrature degree for linear form integrand (ignores effect of non-affine map)
L = inner(f, v) * dx(metadata={"quadrature_degree": -1})
L.integrals()[0].metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(L)
L = form(L)
u_bc = Function(V)
u_bc.interpolate(lambda x: x[1]**degree)
# Create Dirichlet boundary condition
facetdim = mesh.topology.dim - 1
mesh.topology.create_connectivity(facetdim, mesh.topology.dim)
bndry_facets = np.where(
np.array(compute_boundary_facets(mesh.topology)) == 1)[0]
bdofs = locate_dofs_topological(V, facetdim, bndry_facets)
bc = dirichletbc(u_bc, bdofs)
b = assemble_vector(L)
apply_lifting(b, [a], bcs=[[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
a = form(a)
A = assemble_matrix(a, bcs=[bc])
A.assemble()
# Create LU linear solver
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
uh = Function(V)
solver.solve(b, uh.vector)
uh.x.scatter_forward()
M = (u_exact - uh)**2 * dx
M = form(M)
error = mesh.comm.allreduce(assemble_scalar(M), op=MPI.SUM)
assert np.absolute(error) < 1.0e-14
def test_basic_assembly(mode):
mesh = create_unit_square(MPI.COMM_WORLD, 12, 12, ghost_mode=mode)
V = FunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
f = Function(V)
f.x.array[:] = 10.0
a = inner(f * u, v) * dx + inner(u, v) * ds
L = inner(f, v) * dx + inner(2.0, v) * ds
a, L = form(a), form(L)
# Initial assembly
A = assemble_matrix(a)
A.assemble()
assert isinstance(A, PETSc.Mat)
b = 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 = 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 = 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
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)
assemble_matrix(A, a)
A.assemble()
assert 2.0 * normA == pytest.approx(A.norm())
def assemble_div_matrix(k, offset):
mesh = create_quad_mesh(offset)
V = FunctionSpace(mesh, ("DQ", k))
W = FunctionSpace(mesh, ("RTCF", k + 1))
u, w = ufl.TrialFunction(V), ufl.TestFunction(W)
form = ufl.inner(u, ufl.div(w)) * ufl.dx
A = fem.assemble_matrix(form)
A.assemble()
return A[:, :]
def test_overlapping_bcs():
"""Test that, when boundaries condition overlap, the last provided
boundary condition is applied"""
n = 23
mesh = create_unit_square(MPI.COMM_WORLD, n, n)
V = FunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = form(inner(u, v) * dx)
L = form(inner(1, v) * dx)
dofs_left = locate_dofs_geometrical(V, lambda x: x[0] < 1.0 / (2.0 * n))
dofs_top = locate_dofs_geometrical(V, lambda x: x[1] > 1.0 - 1.0 /
(2.0 * n))
dof_corner = np.array(list(set(dofs_left).intersection(set(dofs_top))),
dtype=np.int64)
# Check only one dof pair is found globally
assert len(set(np.concatenate(MPI.COMM_WORLD.allgather(dof_corner)))) == 1
bcs = [
dirichletbc(PETSc.ScalarType(0), dofs_left, V),
dirichletbc(PETSc.ScalarType(123.456), dofs_top, V)
]
A, b = create_matrix(a), create_vector(L)
assemble_matrix(A, a, bcs=bcs)
A.assemble()
# Check the diagonal (only on the rank that owns the row)
d = A.getDiagonal()
if len(dof_corner) > 0 and dof_corner[0] < V.dofmap.index_map.size_local:
assert np.isclose(d.array_r[dof_corner[0]], 1.0)
with b.localForm() as b_loc:
b_loc.set(0)
assemble_vector(b, L)
apply_lifting(b, [a], [bcs])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, bcs)
b.ghostUpdate(addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD)
if len(dof_corner) > 0:
with b.localForm() as b_loc:
assert b_loc[dof_corner[0]] == 123.456
def amg_solve(N, method):
# Elasticity parameters
E = 1.0e9
nu = 0.3
mu = E / (2.0 * (1.0 + nu))
lmbda = E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu))
# Stress computation
def sigma(v):
return 2.0 * mu * sym(grad(v)) + lmbda * tr(sym(
grad(v))) * Identity(2)
# Define problem
mesh = create_unit_square(MPI.COMM_WORLD, N, N)
V = VectorFunctionSpace(mesh, 'Lagrange', 1)
u = TrialFunction(V)
v = TestFunction(V)
facetdim = mesh.topology.dim - 1
bndry_facets = locate_entities_boundary(mesh, facetdim, lambda x: np.full(x.shape[1], True))
bdofs = locate_dofs_topological(V.sub(0), V, facetdim, bndry_facets)
bc = dirichletbc(PETSc.ScalarType(0), bdofs, V.sub(0))
# Forms
a, L = inner(sigma(u), grad(v)) * dx, dot(ufl.as_vector((1.0, 1.0)), v) * dx
# Assemble linear algebra objects
A = assemble_matrix(a, [bc])
A.assemble()
b = assemble_vector(L)
apply_lifting(b, [a], [[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
# Create solution function
u = Function(V)
# Create near null space basis and orthonormalize
null_space = build_nullspace(V, u.vector)
# Attached near-null space to matrix
A.set_near_nullspace(null_space)
# Test that basis is orthonormal
assert null_space.is_orthonormal()
# Create PETSC smoothed aggregation AMG preconditioner, and
# create CG solver
solver = PETSc.KSP().create(mesh.comm)
solver.setType("cg")
# Set matrix operator
solver.setOperators(A)
# Compute solution and return number of iterations
return solver.solve(b, u.vector)
def test_manufactured_vector2(family, degree, filename, datadir):
"""Projection into H(div/curl) spaces"""
# Skip slowest tests
if "tetra" in filename and degree > 2:
return
with XDMFFile(MPI.comm_world, os.path.join(datadir, filename)) as xdmf:
mesh = xdmf.read_mesh(GhostMode.none)
# FIXME: these test are currently failing on unordered meshes
if "tetra" in filename:
if family == "N1curl":
Ordering.order_simplex(mesh)
V = FunctionSpace(mesh, (family, degree + 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
xp = np.array([0.33, 0.33, 0.0])
tree = geometry.BoundingBoxTree(mesh, mesh.geometry.dim)
cells = geometry.compute_first_entity_collision(tree, mesh, xp)
# Source term
x = SpatialCoordinate(mesh)
u_ref = x[0]**degree
L = inner(u_ref, v[0]) * dx
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
A = assemble_matrix(a)
A.assemble()
# Create LU linear solver (Note: need to use a solver that
# re-orders to handle pivots, e.g. not the PETSc built-in LU
# solver)
solver = PETSc.KSP().create(MPI.comm_world)
solver.setType("preonly")
solver.getPC().setType('lu')
solver.setOperators(A)
# Solve
uh = Function(V)
solver.solve(b, uh.vector)
uh.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
up = uh.eval(xp, cells[0])
print("test0:", up)
print("test1:", xp[0]**degree)
u_exact = np.zeros(mesh.geometry.dim)
u_exact[0] = xp[0]**degree
assert np.allclose(up, u_exact)
def test_basic_assembly_petsc_matrixcsr(mode):
mesh = create_unit_square(MPI.COMM_WORLD, 12, 12, ghost_mode=mode)
V = FunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx + inner(u, v) * ds
a = form(a)
A0 = fem.assemble_matrix(a)
A0.finalize()
assert isinstance(A0, la.MatrixCSRMetaClass)
A1 = fem.petsc.assemble_matrix(a)
A1.assemble()
assert isinstance(A1, PETSc.Mat)
assert np.sqrt(A0.norm_squared()) == pytest.approx(A1.norm())
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = form(inner(u, v) * dx + inner(u, v) * ds)
with pytest.raises(RuntimeError):
A0 = fem.assemble_matrix(a)
def test_plus_minus_matrix(cell_type, pm1, pm2):
"""Test that ('+') and ('-') match up with the correct DOFs for DG functions"""
results = []
spaces = []
orders = []
for count in range(3):
for agree in [True, False]:
# Two cell mesh with randomly numbered points
mesh, order = two_unit_cells(cell_type, agree, return_order=True)
V = FunctionSpace(mesh, ("DG", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
# Assemble matrices with combinations of + and - for a few
# different numberings
a = ufl.inner(u(pm1), v(pm2)) * ufl.dS
result = fem.assemble_matrix(a, [])
result.assemble()
spaces.append(V)
results.append(result)
orders.append(order)
# Check that the above matrices all have the same values, but
# permuted due to differently ordered dofs
dofmap0 = spaces[0].mesh.geometry.dofmap
for result, space in zip(results[1:], spaces[1:]):
# Get the data relating to two results
dofmap1 = space.mesh.geometry.dofmap
dof_order = []
# For each cell
for cell in range(2):
# For each point in cell 0 in the the first mesh
for dof0, point0 in zip(spaces[0].dofmap.cell_dofs(cell),
dofmap0.links(cell)):
# Find the point in the cell 0 in the second mesh
for dof1, point1 in zip(space.dofmap.cell_dofs(cell),
dofmap1.links(cell)):
if np.allclose(spaces[0].mesh.geometry.x[point0],
space.mesh.geometry.x[point1]):
break
else:
# If no matching point found, fail
assert False
dof_order.append((dof0, dof1))
# For all dof pairs, check that entries in the matrix agree
for a, b in dof_order:
for c, d in dof_order:
assert np.isclose(results[0][a, c], result[b, d])
def test_custom_mesh_loop_cffi_rank2(set_vals):
"""Test numba assembler for bilinear form"""
mesh = create_unit_square(MPI.COMM_WORLD, 64, 64)
V = FunctionSpace(mesh, ("Lagrange", 1))
# Test against generated code and general assembler
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = form(inner(u, v) * dx)
A0 = assemble_matrix(a)
A0.assemble()
A0.zeroEntries()
start = time.time()
assemble_matrix(A0, a)
end = time.time()
print("Time (C++, pass 2):", end - start)
A0.assemble()
# 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).astype(np.dtype(PETSc.IntType))
A1 = A0.copy()
for i in range(2):
A1.zeroEntries()
start = time.time()
assemble_matrix_cffi(A1.handle, (x_dofs, x), dofmap, num_owned_cells,
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_manufactured_vector1(family, degree, filename, datadir):
"""Projection into H(div/curl) spaces"""
with XDMFFile(MPI.COMM_WORLD,
os.path.join(datadir, filename),
"r",
encoding=XDMFFile.Encoding.ASCII) as xdmf:
mesh = xdmf.read_mesh(name="Grid")
V = FunctionSpace(mesh, (family, degree))
W = VectorFunctionSpace(mesh, ("CG", degree))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
# Source term
x = SpatialCoordinate(mesh)
u_ref = x[0]**degree
L = inner(u_ref, v[0]) * dx
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
A = assemble_matrix(a)
A.assemble()
# Create LU linear solver (Note: need to use a solver that
# re-orders to handle pivots, e.g. not the PETSc built-in LU
# solver)
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType("preonly")
solver.getPC().setType('lu')
solver.setOperators(A)
# Solve
uh = Function(V)
solver.solve(b, uh.vector)
uh.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
u_exact = Function(W)
u_exact.interpolate(lambda x: np.array([
x[0]**degree if i == 0 else 0 * x[0] for i in range(mesh.topology.dim)
]))
M = inner(uh - u_exact, uh - u_exact) * dx
M = fem.Form(M)
error = mesh.mpi_comm().allreduce(assemble_scalar(M), op=MPI.SUM)
assert np.absolute(error) < 1.0e-14
def test_manufactured_vector1(family, degree, filename, datadir):
"""Projection into H(div/curl) spaces"""
with XDMFFile(MPI.COMM_WORLD,
os.path.join(datadir, filename),
"r",
encoding=XDMFFile.Encoding.ASCII) as xdmf:
mesh = xdmf.read_mesh(name="Grid")
V = FunctionSpace(mesh, (family, degree))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
# Source term
x = SpatialCoordinate(mesh)
u_ref = x[0]**degree
L = inner(u_ref, v[0]) * dx
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
A = assemble_matrix(a)
A.assemble()
# Create LU linear solver (Note: need to use a solver that
# re-orders to handle pivots, e.g. not the PETSc built-in LU
# solver)
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType("preonly")
solver.getPC().setType('lu')
solver.setOperators(A)
# Solve
uh = Function(V)
solver.solve(b, uh.vector)
uh.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
xp = np.array([0.33, 0.33, 0.0])
tree = geometry.BoundingBoxTree(mesh, mesh.geometry.dim)
cells = geometry.compute_first_entity_collision(tree, mesh, xp)
up = uh.eval(xp, cells[0])
print("test0:", up)
print("test1:", xp[0]**degree)
u_exact = np.zeros(mesh.geometry.dim)
u_exact[0] = xp[0]**degree
assert np.allclose(up, u_exact)
