def test_extract_forms():
"""Test extraction on unique function spaces for rows and columns of
a block system"""
mesh = create_unit_square(MPI.COMM_WORLD, 32, 31)
V0 = FunctionSpace(mesh, ("Lagrange", 1))
V1 = FunctionSpace(mesh, ("Lagrange", 2))
V2 = V0.clone()
V3 = V1.clone()
v0, u0 = TestFunction(V0), TrialFunction(V0)
v1, u1 = TestFunction(V1), TrialFunction(V1)
v2, u2 = TestFunction(V2), TrialFunction(V2)
v3, u3 = TestFunction(V3), TrialFunction(V3)
a = form([[inner(u0, v0) * dx, inner(u1, v1) * dx],
[inner(u2, v2) * dx, inner(u3, v3) * dx]])
with pytest.raises(AssertionError):
extract_function_spaces(a, 0)
with pytest.raises(AssertionError):
extract_function_spaces(a, 1)
a = form([[inner(u0, v0) * dx, inner(u2, v1) * dx],
[inner(u0, v2) * dx, inner(u2, v2) * dx]])
with pytest.raises(AssertionError):
extract_function_spaces(a, 0)
Vc = extract_function_spaces(a, 1)
assert Vc[0] is V0._cpp_object
assert Vc[1] is V2._cpp_object
a = form([[inner(u0, v0) * dx, inner(u1, v0) * dx],
[inner(u2, v1) * dx, inner(u3, v1) * dx]])
Vr = extract_function_spaces(a, 0)
assert Vr[0] is V0._cpp_object
assert Vr[1] is V1._cpp_object
with pytest.raises(AssertionError):
extract_function_spaces(a, 1)
def test_assembly_solve_block_nl():
"""Solve a two-field nonlinear diffusion like problem with block matrix
approaches and test that solution is the same.
"""
mesh = create_unit_square(MPI.COMM_WORLD, 12, 11)
p = 1
P = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), p)
V0 = FunctionSpace(mesh, P)
V1 = V0.clone()
def bc_val_0(x):
return x[0]**2 + x[1]**2
def bc_val_1(x):
return np.sin(x[0]) * np.cos(x[1])
def initial_guess_u(x):
return np.sin(x[0]) * np.sin(x[1])
def initial_guess_p(x):
return -x[0]**2 - x[1]**3
facetdim = mesh.topology.dim - 1
bndry_facets = locate_entities_boundary(
mesh, facetdim,
lambda x: np.logical_or(np.isclose(x[0], 0.0), np.isclose(x[0], 1.0)))
u_bc0 = Function(V0)
u_bc0.interpolate(bc_val_0)
u_bc1 = Function(V1)
u_bc1.interpolate(bc_val_1)
bdofs0 = locate_dofs_topological(V0, facetdim, bndry_facets)
bdofs1 = locate_dofs_topological(V1, facetdim, bndry_facets)
bcs = [dirichletbc(u_bc0, bdofs0), dirichletbc(u_bc1, bdofs1)]
# Block and Nest variational problem
u, p = Function(V0), Function(V1)
du, dp = ufl.TrialFunction(V0), ufl.TrialFunction(V1)
v, q = ufl.TestFunction(V0), ufl.TestFunction(V1)
f = 1.0
g = -3.0
F = [
inner((u**2 + 1) * ufl.grad(u), ufl.grad(v)) * dx - inner(f, v) * dx,
inner((p**2 + 1) * ufl.grad(p), ufl.grad(q)) * dx - inner(g, q) * dx
]
J = [[derivative(F[0], u, du),
derivative(F[0], p, dp)],
[derivative(F[1], u, du),
derivative(F[1], p, dp)]]
F, J = form(F), form(J)
def blocked_solve():
"""Blocked version"""
Jmat = create_matrix_block(J)
Fvec = create_vector_block(F)
snes = PETSc.SNES().create(MPI.COMM_WORLD)
snes.setTolerances(rtol=1.0e-15, max_it=10)
snes.getKSP().setType("preonly")
snes.getKSP().getPC().setType("lu")
problem = NonlinearPDE_SNESProblem(F, J, [u, p], bcs)
snes.setFunction(problem.F_block, Fvec)
snes.setJacobian(problem.J_block, J=Jmat, P=None)
u.interpolate(initial_guess_u)
p.interpolate(initial_guess_p)
x = create_vector_block(F)
scatter_local_vectors(x, [u.vector.array_r, p.vector.array_r],
[(u.function_space.dofmap.index_map,
u.function_space.dofmap.index_map_bs),
(p.function_space.dofmap.index_map,
p.function_space.dofmap.index_map_bs)])
x.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
snes.solve(None, x)
assert snes.getKSP().getConvergedReason() > 0
assert snes.getConvergedReason() > 0
return x.norm()
def nested_solve():
"""Nested version"""
Jmat = create_matrix_nest(J)
assert Jmat.getType() == "nest"
Fvec = create_vector_nest(F)
assert Fvec.getType() == "nest"
snes = PETSc.SNES().create(MPI.COMM_WORLD)
snes.setTolerances(rtol=1.0e-15, max_it=10)
nested_IS = Jmat.getNestISs()
snes.getKSP().setType("gmres")
snes.getKSP().setTolerances(rtol=1e-12)
snes.getKSP().getPC().setType("fieldsplit")
snes.getKSP().getPC().setFieldSplitIS(["u", nested_IS[0][0]],
["p", nested_IS[1][1]])
ksp_u, ksp_p = snes.getKSP().getPC().getFieldSplitSubKSP()
ksp_u.setType("preonly")
ksp_u.getPC().setType('lu')
ksp_p.setType("preonly")
ksp_p.getPC().setType('lu')
problem = NonlinearPDE_SNESProblem(F, J, [u, p], bcs)
snes.setFunction(problem.F_nest, Fvec)
snes.setJacobian(problem.J_nest, J=Jmat, P=None)
u.interpolate(initial_guess_u)
p.interpolate(initial_guess_p)
x = create_vector_nest(F)
assert x.getType() == "nest"
for x_soln_pair in zip(x.getNestSubVecs(), (u, p)):
x_sub, soln_sub = x_soln_pair
soln_sub.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
soln_sub.vector.copy(result=x_sub)
x_sub.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
snes.solve(None, x)
assert snes.getKSP().getConvergedReason() > 0
assert snes.getConvergedReason() > 0
return x.norm()
def monolithic_solve():
"""Monolithic version"""
E = P * P
W = FunctionSpace(mesh, E)
U = Function(W)
dU = ufl.TrialFunction(W)
u0, u1 = ufl.split(U)
v0, v1 = ufl.TestFunctions(W)
F = inner((u0**2 + 1) * ufl.grad(u0), ufl.grad(v0)) * dx \
+ inner((u1**2 + 1) * ufl.grad(u1), ufl.grad(v1)) * dx \
- inner(f, v0) * ufl.dx - inner(g, v1) * dx
J = derivative(F, U, dU)
F, J = form(F), form(J)
u0_bc = Function(V0)
u0_bc.interpolate(bc_val_0)
u1_bc = Function(V1)
u1_bc.interpolate(bc_val_1)
bdofsW0_V0 = locate_dofs_topological((W.sub(0), V0), facetdim,
bndry_facets)
bdofsW1_V1 = locate_dofs_topological((W.sub(1), V1), facetdim,
bndry_facets)
bcs = [
dirichletbc(u0_bc, bdofsW0_V0, W.sub(0)),
dirichletbc(u1_bc, bdofsW1_V1, W.sub(1))
]
Jmat = create_matrix(J)
Fvec = create_vector(F)
snes = PETSc.SNES().create(MPI.COMM_WORLD)
snes.setTolerances(rtol=1.0e-15, max_it=10)
snes.getKSP().setType("preonly")
snes.getKSP().getPC().setType("lu")
problem = NonlinearPDE_SNESProblem(F, J, U, bcs)
snes.setFunction(problem.F_mono, Fvec)
snes.setJacobian(problem.J_mono, J=Jmat, P=None)
U.sub(0).interpolate(initial_guess_u)
U.sub(1).interpolate(initial_guess_p)
x = create_vector(F)
x.array = U.vector.array_r
snes.solve(None, x)
assert snes.getKSP().getConvergedReason() > 0
assert snes.getConvergedReason() > 0
return x.norm()
norm0 = blocked_solve()
norm1 = nested_solve()
norm2 = monolithic_solve()
assert norm1 == pytest.approx(norm0, 1.0e-12)
assert norm2 == pytest.approx(norm0, 1.0e-12)
def test_assembly_solve_block(mode):
"""Solve a two-field mass-matrix like problem with block matrix approaches
and test that solution is the same"""
mesh = create_unit_square(MPI.COMM_WORLD, 32, 31, ghost_mode=mode)
P = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
V0 = FunctionSpace(mesh, P)
V1 = V0.clone()
# Locate facets on boundary
facetdim = mesh.topology.dim - 1
bndry_facets = locate_entities_boundary(mesh, facetdim, lambda x: np.logical_or(np.isclose(x[0], 0.0),
np.isclose(x[0], 1.0)))
bdofsV0 = locate_dofs_topological(V0, facetdim, bndry_facets)
bdofsV1 = locate_dofs_topological(V1, facetdim, bndry_facets)
u0_bc = PETSc.ScalarType(50.0)
u1_bc = PETSc.ScalarType(20.0)
bcs = [dirichletbc(u0_bc, bdofsV0, V0), dirichletbc(u1_bc, bdofsV1, V1)]
# Variational problem
u, p = ufl.TrialFunction(V0), ufl.TrialFunction(V1)
v, q = ufl.TestFunction(V0), ufl.TestFunction(V1)
f = 1.0
g = -3.0
zero = Function(V0)
a00 = form(inner(u, v) * dx)
a01 = form(zero * inner(p, v) * dx)
a10 = form(zero * inner(u, q) * dx)
a11 = form(inner(p, q) * dx)
L0 = form(inner(f, v) * dx)
L1 = form(inner(g, q) * dx)
def monitor(ksp, its, rnorm):
pass
# print("Norm:", its, rnorm)
A0 = assemble_matrix_block([[a00, a01], [a10, a11]], bcs=bcs)
b0 = assemble_vector_block([L0, L1], [[a00, a01], [a10, a11]], bcs=bcs)
A0.assemble()
A0norm = A0.norm()
b0norm = b0.norm()
x0 = A0.createVecLeft()
ksp = PETSc.KSP()
ksp.create(mesh.comm)
ksp.setOperators(A0)
ksp.setMonitor(monitor)
ksp.setType('cg')
ksp.setTolerances(rtol=1.0e-14)
ksp.setFromOptions()
ksp.solve(b0, x0)
x0norm = x0.norm()
# Nested (MatNest)
A1 = assemble_matrix_nest([[a00, a01], [a10, a11]], bcs=bcs, diagonal=1.0)
A1.assemble()
b1 = assemble_vector_nest([L0, L1])
apply_lifting_nest(b1, [[a00, a01], [a10, a11]], bcs=bcs)
for b_sub in b1.getNestSubVecs():
b_sub.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
bcs0 = bcs_by_block([L0.function_spaces[0], L1.function_spaces[0]], bcs)
set_bc_nest(b1, bcs0)
b1.assemble()
b1norm = b1.norm()
assert b1norm == pytest.approx(b0norm, 1.0e-12)
A1norm = nest_matrix_norm(A1)
assert A0norm == pytest.approx(A1norm, 1.0e-12)
x1 = b1.copy()
ksp = PETSc.KSP()
ksp.create(mesh.comm)
ksp.setMonitor(monitor)
ksp.setOperators(A1)
ksp.setType('cg')
ksp.setTolerances(rtol=1.0e-12)
ksp.setFromOptions()
ksp.solve(b1, x1)
x1norm = x1.norm()
assert x1norm == pytest.approx(x0norm, rel=1.0e-12)
# Monolithic version
E = P * P
W = FunctionSpace(mesh, E)
u0, u1 = ufl.TrialFunctions(W)
v0, v1 = ufl.TestFunctions(W)
a = inner(u0, v0) * dx + inner(u1, v1) * dx
L = inner(f, v0) * ufl.dx + inner(g, v1) * dx
a, L = form(a), form(L)
bdofsW0_V0 = locate_dofs_topological(W.sub(0), facetdim, bndry_facets)
bdofsW1_V1 = locate_dofs_topological(W.sub(1), facetdim, bndry_facets)
bcs = [dirichletbc(u0_bc, bdofsW0_V0, W.sub(0)), dirichletbc(u1_bc, bdofsW1_V1, W.sub(1))]
A2 = assemble_matrix(a, bcs=bcs)
A2.assemble()
b2 = assemble_vector(L)
apply_lifting(b2, [a], [bcs])
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b2, bcs)
A2norm = A2.norm()
b2norm = b2.norm()
assert A2norm == pytest.approx(A0norm, 1.0e-12)
assert b2norm == pytest.approx(b0norm, 1.0e-12)
x2 = b2.copy()
ksp = PETSc.KSP()
ksp.create(mesh.comm)
ksp.setMonitor(monitor)
ksp.setOperators(A2)
ksp.setType('cg')
ksp.getPC().setType('jacobi')
ksp.setTolerances(rtol=1.0e-12)
ksp.setFromOptions()
ksp.solve(b2, x2)
x2norm = x2.norm()
assert x2norm == pytest.approx(x0norm, 1.0e-10)
