def test_linear_pde():
"""Test Newton solver for a linear PDE"""
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 12, 12)
V = FunctionSpace(mesh, ("Lagrange", 1))
u = Function(V)
v = TestFunction(V)
F = inner(10.0, v) * dx - inner(grad(u), grad(v)) * dx
bc = dirichletbc(PETSc.ScalarType(1.0),
locate_dofs_geometrical(V, lambda x: np.logical_or(np.isclose(x[0], 0.0),
np.isclose(x[0], 1.0))), V)
# Create nonlinear problem
problem = NonlinearPDEProblem(F, u, bc)
# Create Newton solver and solve
solver = _cpp.nls.NewtonSolver(MPI.COMM_WORLD)
solver.setF(problem.F, problem.vector())
solver.setJ(problem.J, problem.matrix())
solver.set_form(problem.form)
n, converged = solver.solve(u.vector)
assert converged
assert n == 1
# Increment boundary condition and solve again
bc.g.value[...] = PETSc.ScalarType(2.0)
n, converged = solver.solve(u.vector)
assert converged
assert n == 1
def test_mixed_constant_bc(mesh_factory):
"""Test that setting a dirichletbc with on a component of a mixed
function yields the same result as setting it with a function"""
func, args = mesh_factory
mesh = func(*args)
tdim, gdim = mesh.topology.dim, mesh.geometry.dim
boundary_facets = locate_entities_boundary(
mesh, tdim - 1, lambda x: np.ones(x.shape[1], dtype=bool))
TH = ufl.MixedElement([
ufl.VectorElement("Lagrange", mesh.ufl_cell(), 2),
ufl.FiniteElement("Lagrange", mesh.ufl_cell(), 1)
])
W = FunctionSpace(mesh, TH)
U = Function(W)
# Apply BC to component of a mixed space using a Constant
c = Constant(mesh, (PETSc.ScalarType(2), PETSc.ScalarType(2)))
dofs0 = locate_dofs_topological(W.sub(0), tdim - 1, boundary_facets)
bc0 = dirichletbc(c, dofs0, W.sub(0))
u = U.sub(0)
set_bc(u.vector, [bc0])
# Apply BC to component of a mixed space using a Function
ubc1 = u.collapse()
ubc1.interpolate(lambda x: np.full((gdim, x.shape[1]), 2.0))
dofs1 = locate_dofs_topological((W.sub(0), ubc1.function_space), tdim - 1,
boundary_facets)
bc1 = dirichletbc(ubc1, dofs1, W.sub(0))
U1 = Function(W)
u1 = U1.sub(0)
set_bc(u1.vector, [bc1])
# Check that both approaches yield the same vector
assert np.allclose(u.x.array, u1.x.array)
def test_sub_constant_bc(mesh_factory):
"""Test that setting a dirichletbc with on a component of a vector
valued function yields the same result as setting it with a
function"""
func, args = mesh_factory
mesh = func(*args)
tdim = mesh.topology.dim
V = VectorFunctionSpace(mesh, ("Lagrange", 1))
c = Constant(mesh, PETSc.ScalarType(3.14))
boundary_facets = locate_entities_boundary(
mesh, tdim - 1, lambda x: np.ones(x.shape[1], dtype=bool))
for i in range(V.num_sub_spaces):
Vi = V.sub(i).collapse()[0]
u_bci = Function(Vi)
u_bci.x.array[:] = PETSc.ScalarType(c.value)
boundary_dofsi = locate_dofs_topological((V.sub(i), Vi), tdim - 1,
boundary_facets)
bc_fi = dirichletbc(u_bci, boundary_dofsi, V.sub(i))
boundary_dofs = locate_dofs_topological(V.sub(i), tdim - 1,
boundary_facets)
bc_c = dirichletbc(c, boundary_dofs, V.sub(i))
u_f = Function(V)
set_bc(u_f.vector, [bc_fi])
u_c = Function(V)
set_bc(u_c.vector, [bc_c])
assert np.allclose(u_f.vector.array, u_c.vector.array)
def interpolate_cached(compiled_expression, target_func):
kernel = compiled_expression.module.tabulate_expression
# Register complex types
cffi_support.register_type(ffi.typeof('double _Complex'),
numba.types.complex128)
cffi_support.register_type(ffi.typeof('float _Complex'),
numba.types.complex64)
reference_geometry = np.asarray(compiled_expression.fiat_element.ref_el.get_vertices())
# Unpack mesh and dofmap data
mesh = target_func.function_space.mesh
geom_dofmap = mesh.geometry.dofmap.array
geom_pos = mesh.geometry.dofmap.offsets
geom = mesh.geometry.x
gdim = mesh.geometry.dim
dofmap = target_func.function_space.dofmap.list.array
# Prepare coefficients and their dofmaps
# Global vectors and dofmaps are prepared here, local are
# fetched inside hot cell-loop
# Number of coefficients in ffcx-processed ufl form
num_coeffs = compiled_expression.module.num_coefficients
# Positions of ffcx-preprocessed coefficients in original form
cpos = compiled_expression.module.original_coefficient_positions
coeffs = ufl.algorithms.analysis.extract_coefficients(compiled_expression.expr)
coeffs_dofmaps = List.empty_list(numba.types.Array(numba.typeof(dofmap[0]), 1, "C", readonly=True))
coeffs_vectors = List.empty_list(numba.types.Array(numba.typeof(PETSc.ScalarType()), 1, "C", readonly=True))
for i in range(num_coeffs):
coeffs_dofmaps.append(coeffs[cpos[i]].function_space.dofmap.list.array)
coeffs_vectors.append(np.asarray(coeffs[cpos[i]].vector))
local_coeffs_sizes = np.asarray([coeff.function_space.element.space_dimension()
for coeff in coeffs], dtype=np.int)
local_coeffs_size = np.sum(local_coeffs_sizes, dtype=np.int)
# Prepare and pack constants
constants = ufl.algorithms.analysis.extract_constants(compiled_expression.expr)
constants_vector = np.array([], dtype=PETSc.ScalarType())
if len(constants) > 0:
constants_vector = np.hstack([c.value.flatten() for c in constants])
# Num DOFs of the target element
local_b_size = target_func.function_space.element.space_dimension()
value_size = int(np.product(compiled_expression.expr.ufl_shape))
num_coeffs = len(coeffs_vectors)
with target_func.vector.localForm() as b:
b.set(0.0)
assemble_vector_ufc(np.asarray(b), kernel, (geom_dofmap, geom_pos, geom), dofmap,
coeffs_vectors, coeffs_dofmaps, constants_vector, reference_geometry,
local_coeffs_sizes, local_coeffs_size, local_b_size, gdim, value_size)
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 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 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 test_nonlinear_pde():
"""Test Newton solver for a simple nonlinear PDE"""
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 12, 5)
V = FunctionSpace(mesh, ("Lagrange", 1))
u = Function(V)
v = TestFunction(V)
F = inner(5.0, v) * dx - ufl.sqrt(u * u) * inner(
grad(u), grad(v)) * dx - inner(u, v) * dx
bc = dirichletbc(
PETSc.ScalarType(1.0),
locate_dofs_geometrical(
V, lambda x: np.logical_or(np.isclose(x[0], 0.0),
np.isclose(x[0], 1.0))), V)
# Create nonlinear problem
problem = NonlinearPDEProblem(F, u, bc)
# Create Newton solver and solve
u.x.array[:] = 0.9
solver = _cpp.nls.petsc.NewtonSolver(MPI.COMM_WORLD)
solver.setF(problem.F, problem.vector())
solver.setJ(problem.J, problem.matrix())
solver.set_form(problem.form)
n, converged = solver.solve(u.vector)
assert converged
assert n < 6
# Modify boundary condition and solve again
bc.g.value[...] = 0.5
n, converged = solver.solve(u.vector)
assert converged
assert n > 0 and n < 6
def test_assembly_dS_domains(mode):
N = 10
mesh = create_unit_square(MPI.COMM_WORLD, N, N, ghost_mode=mode)
one = Constant(mesh, PETSc.ScalarType(1))
val = assemble_scalar(form(one * ufl.dS))
val = mesh.comm.allreduce(val, op=MPI.SUM)
assert val == pytest.approx(2 * (N - 1) + N * np.sqrt(2), 1.0e-7)
def test_constant_bc(mesh_factory):
"""Test that setting a dirichletbc with a constant yields the same
result as setting it with a function"""
func, args = mesh_factory
mesh = func(*args)
V = FunctionSpace(mesh, ("Lagrange", 1))
c = PETSc.ScalarType(2)
tdim = mesh.topology.dim
boundary_facets = locate_entities_boundary(
mesh, tdim - 1, lambda x: np.ones(x.shape[1], dtype=bool))
boundary_dofs = locate_dofs_topological(V, tdim - 1, boundary_facets)
u_bc = Function(V)
u_bc.x.array[:] = c
bc_f = dirichletbc(u_bc, boundary_dofs)
bc_c = dirichletbc(c, boundary_dofs, V)
u_f = Function(V)
set_bc(u_f.vector, [bc_f])
u_c = Function(V)
set_bc(u_c.vector, [bc_c])
assert np.allclose(u_f.vector.array, u_c.vector.array)
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_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 setUp(self):
self.ts = PETSc.TS().create(PETSc.COMM_SELF)
ptype = PETSc.TS.ProblemType.NONLINEAR
self.ts.setProblemType(ptype)
self.ts.setType(self.TYPE)
if PETSc.ScalarType().dtype.char in 'fF':
snes = self.ts.getSNES()
snes.setTolerances(rtol=1e-6)
def assemble_div_vector(k, offset):
mesh = create_quad_mesh(offset)
V = FunctionSpace(mesh, ("RTCF", k + 1))
v = ufl.TestFunction(V)
L = form(
ufl.inner(Constant(mesh, PETSc.ScalarType(1)), ufl.div(v)) * ufl.dx)
b = assemble_vector(L)
return b[:]
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 decorator(f: typing.Callable):
scalar_type = numba.typeof(PETSc.ScalarType())
c_signature = numba.types.void(
numba.types.CPointer(scalar_type),
numba.types.intc,
numba.types.intc,
numba.types.CPointer(numba.types.double),
numba.types.intc,
numba.types.float64,
)
# Compile the user function
f_jit = numba.jit(**numba_jit_options)(f)
# Wrap the user function in a function with a C interface
@numba.cfunc(c_signature, **numba_cfunc_options)
def eval(values, num_points, value_size, x, gdim, t):
np_values = numba.carray(values, (num_points, value_size),
dtype=scalar_type)
np_x = numba.carray(x, (num_points, gdim),
dtype=numba.types.double)
f_jit(np_values, np_x, t)
return eval
def test_pipeline(u_from_mpc):
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 5, 5)
V = fem.FunctionSpace(mesh, ("Lagrange", 1))
# Solve Problem without MPC for reference
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
d = fem.Constant(mesh, PETSc.ScalarType(0.01))
x = ufl.SpatialCoordinate(mesh)
f = ufl.sin(2 * ufl.pi * x[0]) * ufl.sin(ufl.pi * x[1])
a = ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx - d * ufl.inner(u, v) * ufl.dx
rhs = ufl.inner(f, v) * ufl.dx
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Generate reference matrices
A_org = fem.petsc.assemble_matrix(bilinear_form)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
# Create multipoint constraint
def periodic_relation(x):
out_x = np.copy(x)
out_x[0] = 1 - x[0]
return out_x
def PeriodicBoundary(x):
return np.isclose(x[0], 1)
facets = locate_entities_boundary(mesh, mesh.topology.dim - 1, PeriodicBoundary)
arg_sort = np.argsort(facets)
mt = meshtags(mesh, mesh.topology.dim - 1, facets[arg_sort], np.full(len(facets), 2, dtype=np.int32))
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_periodic_constraint_topological(V, mt, 2, periodic_relation, [], 1)
mpc.finalize()
if u_from_mpc:
uh = fem.Function(mpc.function_space)
problem = dolfinx_mpc.LinearProblem(bilinear_form, linear_form, mpc, bcs=[], u=uh,
petsc_options={"ksp_type": "preonly", "pc_type": "lu"})
problem.solve()
root = 0
dolfinx_mpc.utils.compare_mpc_lhs(A_org, problem.A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, problem.b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
else:
uh = fem.Function(V)
with pytest.raises(ValueError):
problem = dolfinx_mpc.LinearProblem(bilinear_form, linear_form, mpc, bcs=[], u=uh,
petsc_options={"ksp_type": "preonly", "pc_type": "lu"})
problem.solve()
def demo_elasticity():
mesh = create_unit_square(MPI.COMM_WORLD, 10, 10)
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
# Generate Dirichlet BC on lower boundary (Fixed)
def boundaries(x):
return np.isclose(x[0], np.finfo(float).eps)
facets = locate_entities_boundary(mesh, 1, boundaries)
topological_dofs = fem.locate_dofs_topological(V, 1, facets)
bc = fem.dirichletbc(np.array([0, 0], dtype=PETSc.ScalarType),
topological_dofs, V)
bcs = [bc]
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
# Elasticity parameters
E = PETSc.ScalarType(1.0e4)
nu = 0.0
mu = fem.Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = fem.Constant(mesh, 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(len(v)))
x = SpatialCoordinate(mesh)
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(sigma(u), grad(v)) * dx
rhs = inner(as_vector((0, (x[0] - 0.5) * 10**4 * x[1])), v) * dx
# Create MPC
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {l2b([1, 0]): {l2b([1, 1]): 0.9}}
mpc = MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c, 1, 1)
mpc.finalize()
# Solve Linear problem
petsc_options = {"ksp_type": "preonly", "pc_type": "lu"}
problem = LinearProblem(a, rhs, mpc, bcs=bcs, petsc_options=petsc_options)
u_h = problem.solve()
u_h.name = "u_mpc"
with XDMFFile(MPI.COMM_WORLD, "results/demo_elasticity.xdmf",
"w") as outfile:
outfile.write_mesh(mesh)
outfile.write_function(u_h)
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
bilinear_form = fem.form(a)
A_org = fem.petsc.assemble_matrix(bilinear_form, bcs)
A_org.assemble()
linear_form = fem.form(rhs)
L_org = fem.petsc.assemble_vector(linear_form)
fem.petsc.apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(L_org, bcs)
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A_org)
u_ = fem.Function(V)
solver.solve(L_org, u_.vector)
u_.x.scatter_forward()
u_.name = "u_unconstrained"
with XDMFFile(MPI.COMM_WORLD, "results/demo_elasticity.xdmf",
"a") as outfile:
outfile.write_function(u_)
outfile.close()
root = 0
with Timer("~Demo: Verification"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, problem.A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, problem.b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(u_h.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
# Print out master-slave connectivity for the first slave
master_owner = None
master_data = None
slave_owner = None
if mpc.num_local_slaves > 0:
slave_owner = MPI.COMM_WORLD.rank
bs = mpc.function_space.dofmap.index_map_bs
slave = mpc.slaves[0]
print("Constrained: {0:.5e}\n Unconstrained: {1:.5e}".format(
u_h.x.array[slave], u_.vector.array[slave]))
master_owner = mpc._cpp_object.owners.links(slave)[0]
_masters = mpc.masters
master = _masters.links(slave)[0]
glob_master = mpc.function_space.dofmap.index_map.local_to_global(
[master // bs])[0]
coeffs, offs = mpc.coefficients()
master_data = [
glob_master * bs + master % bs,
coeffs[offs[slave]:offs[slave + 1]][0]
]
# If master not on proc send info to this processor
if MPI.COMM_WORLD.rank != master_owner:
MPI.COMM_WORLD.send(master_data, dest=master_owner, tag=1)
else:
print("Master*Coeff: {0:.5e}".format(
coeffs[offs[slave]:offs[slave + 1]][0] *
u_h.x.array[_masters.links(slave)[0]]))
# As a processor with a master is not aware that it has a master,
# Determine this so that it can receive the global dof and coefficient
master_recv = MPI.COMM_WORLD.allgather(master_owner)
for master in master_recv:
if master is not None:
master_owner = master
break
if slave_owner != master_owner and MPI.COMM_WORLD.rank == master_owner:
dofmap = mpc.function_space.dofmap
bs = dofmap.index_map_bs
in_data = MPI.COMM_WORLD.recv(source=MPI.ANY_SOURCE, tag=1)
num_local = dofmap.index_map.size_local + dofmap.index_map.num_ghosts
l2g = dofmap.index_map.local_to_global(
np.arange(num_local, dtype=np.int32))
l_index = np.flatnonzero(l2g == in_data[0] // bs)[0]
print("Master*Coeff (on other proc): {0:.5e}".format(
u_h.x.array[l_index * bs + in_data[0] % bs] * in_data[1]))
def demo_periodic3D(celltype: CellType):
# Create mesh and finite element
if celltype == CellType.tetrahedron:
# Tet setup
N = 10
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N)
V = fem.VectorFunctionSpace(mesh, ("CG", 1))
else:
# Hex setup
N = 10
mesh = create_unit_cube(MPI.COMM_WORLD, N, N, N, CellType.hexahedron)
V = fem.VectorFunctionSpace(mesh, ("CG", 2))
def dirichletboundary(x: NDArray[np.float64]) -> NDArray[np.bool_]:
return np.logical_or(
np.logical_or(np.isclose(x[1], 0), np.isclose(x[1], 1)),
np.logical_or(np.isclose(x[2], 0), np.isclose(x[2], 1)))
# Create Dirichlet boundary condition
zero = PETSc.ScalarType([0, 0, 0])
geometrical_dofs = fem.locate_dofs_geometrical(V, dirichletboundary)
bc = fem.dirichletbc(zero, geometrical_dofs, V)
bcs = [bc]
def PeriodicBoundary(x):
return np.isclose(x[0], 1)
facets = locate_entities_boundary(mesh, mesh.topology.dim - 1,
PeriodicBoundary)
arg_sort = np.argsort(facets)
mt = meshtags(mesh, mesh.topology.dim - 1, facets[arg_sort],
np.full(len(facets), 2, dtype=np.int32))
def periodic_relation(x):
out_x = np.zeros(x.shape)
out_x[0] = 1 - x[0]
out_x[1] = x[1]
out_x[2] = x[2]
return out_x
with Timer("~~Periodic: Compute mpc condition"):
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_periodic_constraint_topological(V.sub(0), mt, 2,
periodic_relation, bcs, 1)
mpc.finalize()
# Define variational problem
u = TrialFunction(V)
v = TestFunction(V)
a = inner(grad(u), grad(v)) * dx
x = SpatialCoordinate(mesh)
dx_ = x[0] - 0.9
dy_ = x[1] - 0.5
dz_ = x[2] - 0.1
f = as_vector((x[0] * sin(5.0 * pi * x[1]) +
1.0 * exp(-(dx_ * dx_ + dy_ * dy_ + dz_ * dz_) / 0.02),
0.1 * dx_ * dz_, 0.1 * dx_ * dy_))
rhs = inner(f, v) * dx
petsc_options: Dict[str, Union[str, float, int]]
if complex_mode:
rtol = 1e-16
petsc_options = {"ksp_type": "preonly", "pc_type": "lu"}
else:
rtol = 1e-8
petsc_options = {
"ksp_type": "cg",
"ksp_rtol": rtol,
"pc_type": "hypre",
"pc_hypre_typ": "boomeramg",
"pc_hypre_boomeramg_max_iter": 1,
"pc_hypre_boomeramg_cycle_type": "v",
"pc_hypre_boomeramg_print_statistics": 1
}
problem = LinearProblem(a, rhs, mpc, bcs, petsc_options=petsc_options)
u_h = problem.solve()
# --------------------VERIFICATION-------------------------
print("----Verification----")
u_ = fem.Function(V)
u_.x.array[:] = 0
org_problem = fem.petsc.LinearProblem(a,
rhs,
u=u_,
bcs=bcs,
petsc_options=petsc_options)
with Timer("~Periodic: Unconstrained solve"):
org_problem.solve()
it = org_problem.solver.getIterationNumber()
print(f"Unconstrained solver iterations: {it}")
# Write solutions to file
ext = "tet" if celltype == CellType.tetrahedron else "hex"
u_.name = "u_" + ext + "_unconstrained"
# NOTE: Workaround as tabulate dof coordinates does not like extra ghosts
u_out = fem.Function(V)
old_local = u_out.x.map.size_local * u_out.x.bs
old_ghosts = u_out.x.map.num_ghosts * u_out.x.bs
mpc_local = u_h.x.map.size_local * u_h.x.bs
assert (old_local == mpc_local)
u_out.x.array[:old_local + old_ghosts] = u_h.x.array[:mpc_local +
old_ghosts]
u_out.name = "u_" + ext
fname = f"results/demo_periodic3d_{ext}.bp"
out_periodic = VTXWriter(MPI.COMM_WORLD, fname, u_out)
out_periodic.write(0)
out_periodic.close()
root = 0
with Timer("~Demo: Verification"):
dolfinx_mpc.utils.compare_mpc_lhs(org_problem.A,
problem.A,
mpc,
root=root)
dolfinx_mpc.utils.compare_mpc_rhs(org_problem.b,
problem.b,
mpc,
root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(org_problem.A, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(org_problem.b, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(u_h.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc, rtol=rtol)
def test_surface_integrals(get_assemblers): # noqa: F811
assemble_matrix, assemble_vector = get_assemblers
N = 4
mesh = create_unit_square(MPI.COMM_WORLD, N, N)
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
# Fixed Dirichlet BC on the left wall
def left_wall(x):
return np.isclose(x[0], np.finfo(float).eps)
fdim = mesh.topology.dim - 1
left_facets = locate_entities_boundary(mesh, fdim, left_wall)
bc_dofs = fem.locate_dofs_topological(V, 1, left_facets)
u_bc = fem.Function(V)
with u_bc.vector.localForm() as u_local:
u_local.set(0.0)
bc = fem.dirichletbc(u_bc, bc_dofs)
bcs = [bc]
# Traction on top of domain
def top(x):
return np.isclose(x[1], 1)
top_facets = locate_entities_boundary(mesh, 1, top)
arg_sort = np.argsort(top_facets)
mt = meshtags(mesh, fdim, top_facets[arg_sort], np.full(len(top_facets), 3, dtype=np.int32))
ds = ufl.Measure("ds", domain=mesh, subdomain_data=mt, subdomain_id=3)
g = fem.Constant(mesh, PETSc.ScalarType((0, -9.81e2)))
# Elasticity parameters
E = PETSc.ScalarType(1.0e4)
nu = 0.0
mu = fem.Constant(mesh, E / (2.0 * (1.0 + nu)))
lmbda = fem.Constant(mesh, E * nu / ((1.0 + nu) * (1.0 - 2.0 * nu)))
# Stress computation
def sigma(v):
return (2.0 * mu * ufl.sym(ufl.grad(v))
+ lmbda * ufl.tr(ufl.sym(ufl.grad(v))) * ufl.Identity(len(v)))
# Define variational problem
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(sigma(u), ufl.grad(v)) * ufl.dx
rhs = ufl.inner(fem.Constant(mesh, PETSc.ScalarType((0, 0))), v) * ufl.dx\
+ ufl.inner(g, v) * ds
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Setup LU solver
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
# Setup multipointconstraint
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {}
for i in range(1, N):
s_m_c[l2b([1, i / N])] = {l2b([1, 1]): 0.8}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c, 1, 1)
mpc.finalize()
with Timer("~TEST: Assemble matrix old"):
A = assemble_matrix(bilinear_form, mpc, bcs=bcs)
with Timer("~TEST: Assemble vector"):
b = assemble_vector(linear_form, mpc)
dolfinx_mpc.apply_lifting(b, [bilinear_form], [bcs], mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(b, bcs)
solver.setOperators(A)
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
# Write solution to file
# u_h = dolfinx.Function(mpc.function_space)
# u_h.vector.setArray(uh.array)
# u_h.name = "u_mpc"
# outfile = dolfinx.io.XDMFFile(MPI.COMM_WORLD, "output/uh.xdmf", "w")
# outfile.write_mesh(mesh)
# outfile.write_function(u_h)
# outfile.close()
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
# Generate reference matrices and unconstrained solution
A_org = fem.petsc.assemble_matrix(bilinear_form, bcs)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
fem.petsc.apply_lifting(L_org, [bilinear_form], [bcs])
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
fem.petsc.set_bc(L_org, bcs)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
def test_eigen_assembly(tempdir): # noqa: F811
"""Compare assembly into scipy.CSR matrix with PETSc assembly"""
def compile_eigen_csr_assembler_module():
dolfinx_pc = dolfinx.pkgconfig.parse("dolfinx")
eigen_dir = dolfinx.pkgconfig.parse("eigen3")["include_dirs"]
cpp_code_header = f"""
<%
setup_pybind11(cfg)
cfg['include_dirs'] = {dolfinx_pc["include_dirs"] + [petsc4py.get_include()]
+ [pybind11.get_include()] + [str(pybind_inc())] + eigen_dir}
cfg['compiler_args'] = ["-std=c++17", "-Wno-comment"]
cfg['libraries'] = {dolfinx_pc["libraries"]}
cfg['library_dirs'] = {dolfinx_pc["library_dirs"]}
%>
"""
cpp_code = """
#include <pybind11/pybind11.h>
#include <pybind11/eigen.h>
#include <pybind11/stl.h>
#include <vector>
#include <Eigen/Sparse>
#include <petscsys.h>
#include <dolfinx/fem/assembler.h>
#include <dolfinx/fem/DirichletBC.h>
#include <dolfinx/fem/Form.h>
template<typename T>
Eigen::SparseMatrix<T, Eigen::RowMajor>
assemble_csr(const dolfinx::fem::Form<T>& a,
const std::vector<std::shared_ptr<const dolfinx::fem::DirichletBC<T>>>& bcs)
{
std::vector<Eigen::Triplet<T>> triplets;
auto mat_add
= [&triplets](const xtl::span<const std::int32_t>& rows,
const xtl::span<const std::int32_t>& cols,
const xtl::span<const T>& v)
{
for (std::size_t i = 0; i < rows.size(); ++i)
for (std::size_t j = 0; j < cols.size(); ++j)
triplets.emplace_back(rows[i], cols[j], v[i * cols.size() + j]);
return 0;
};
dolfinx::fem::assemble_matrix(mat_add, a, bcs);
auto map0 = a.function_spaces().at(0)->dofmap()->index_map;
int bs0 = a.function_spaces().at(0)->dofmap()->index_map_bs();
auto map1 = a.function_spaces().at(1)->dofmap()->index_map;
int bs1 = a.function_spaces().at(1)->dofmap()->index_map_bs();
Eigen::SparseMatrix<T, Eigen::RowMajor> mat(
bs0 * (map0->size_local() + map0->num_ghosts()),
bs1 * (map1->size_local() + map1->num_ghosts()));
mat.setFromTriplets(triplets.begin(), triplets.end());
return mat;
}
PYBIND11_MODULE(eigen_csr, m)
{
m.def("assemble_matrix", &assemble_csr<PetscScalar>);
}
"""
path = pathlib.Path(tempdir)
open(pathlib.Path(tempdir, "eigen_csr.cpp"),
"w").write(cpp_code + cpp_code_header)
rel_path = path.relative_to(pathlib.Path(__file__).parent)
p = str(rel_path).replace("/", ".") + ".eigen_csr"
return cppimport.imp(p)
def assemble_csr_matrix(a, bcs):
"""Assemble bilinear form into an SciPy CSR matrix, in serial."""
module = compile_eigen_csr_assembler_module()
A = module.assemble_matrix(a, bcs)
if a.function_spaces[0] is a.function_spaces[1]:
for bc in bcs:
if a.function_spaces[0].contains(bc.function_space):
bc_dofs, _ = bc.dof_indices()
# See https://github.com/numpy/numpy/issues/14132
# for why we copy bc_dofs as a work-around
dofs = bc_dofs.copy()
A[dofs, dofs] = 1.0
return A
mesh = create_unit_square(MPI.COMM_SELF, 12, 12)
Q = FunctionSpace(mesh, ("Lagrange", 1))
u = ufl.TrialFunction(Q)
v = ufl.TestFunction(Q)
a = form(ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx)
bdofsQ = locate_dofs_geometrical(
Q,
lambda x: np.logical_or(np.isclose(x[0], 0.0), np.isclose(x[0], 1.0)))
bc = dirichletbc(PETSc.ScalarType(1), bdofsQ, Q)
A1 = assemble_matrix(a, [bc])
A1.assemble()
A2 = assemble_csr_matrix(a, [bc])
assert np.isclose(A1.norm(), scipy.sparse.linalg.norm(A2))
def test_matrix_assembly_block(mode):
"""Test assembly of block matrices and vectors into (a) monolithic
blocked structures, PETSc Nest structures, and monolithic
structures"""
mesh = create_unit_square(MPI.COMM_WORLD, 4, 8, ghost_mode=mode)
p0, p1 = 1, 2
P0 = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), p0)
P1 = ufl.FiniteElement("Lagrange", mesh.ufl_cell(), p1)
V0 = FunctionSpace(mesh, P0)
V1 = FunctionSpace(mesh, P1)
# 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)))
bdofsV1 = locate_dofs_topological(V1, facetdim, bndry_facets)
u_bc = PETSc.ScalarType(50.0)
bc = dirichletbc(u_bc, bdofsV1, V1)
# Define 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 = inner(u, v) * dx
a01 = inner(p, v) * dx
a10 = inner(u, q) * dx
a11 = inner(p, q) * dx
L0 = zero * inner(f, v) * dx
L1 = inner(g, q) * dx
a_block = form([[a00, a01], [a10, a11]])
L_block = form([L0, L1])
# Monolithic blocked
A0 = assemble_matrix_block(a_block, bcs=[bc])
A0.assemble()
b0 = assemble_vector_block(L_block, a_block, bcs=[bc])
assert A0.getType() != "nest"
Anorm0 = A0.norm()
bnorm0 = b0.norm()
# Nested (MatNest)
A1 = assemble_matrix_nest(a_block, bcs=[bc], mat_types=[["baij", "aij"], ["aij", ""]])
A1.assemble()
Anorm1 = nest_matrix_norm(A1)
assert Anorm0 == pytest.approx(Anorm1, 1.0e-12)
b1 = assemble_vector_nest(L_block)
apply_lifting_nest(b1, a_block, bcs=[bc])
for b_sub in b1.getNestSubVecs():
b_sub.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
bcs0 = bcs_by_block([L.function_spaces[0] for L in L_block], [bc])
set_bc_nest(b1, bcs0)
b1.assemble()
bnorm1 = math.sqrt(sum([x.norm()**2 for x in b1.getNestSubVecs()]))
assert bnorm0 == pytest.approx(bnorm1, 1.0e-12)
# Monolithic version
E = P0 * P1
W = FunctionSpace(mesh, E)
u0, u1 = ufl.TrialFunctions(W)
v0, v1 = ufl.TestFunctions(W)
a = inner(u0, v0) * dx + inner(u1, v1) * dx + inner(u0, v1) * dx + inner(
u1, v0) * dx
L = zero * inner(f, v0) * ufl.dx + inner(g, v1) * dx
a, L = form(a), form(L)
bdofsW_V1 = locate_dofs_topological(W.sub(1), mesh.topology.dim - 1, bndry_facets)
bc = dirichletbc(u_bc, bdofsW_V1, W.sub(1))
A2 = assemble_matrix(a, bcs=[bc])
A2.assemble()
b2 = assemble_vector(L)
apply_lifting(b2, [a], bcs=[[bc]])
b2.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b2, [bc])
assert A2.getType() != "nest"
assert A2.norm() == pytest.approx(Anorm0, 1.0e-9)
assert b2.norm() == pytest.approx(bnorm0, 1.0e-9)
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)
class TestKSPCGS(BaseTestKSP, unittest.TestCase):
KSP_TYPE = PETSc.KSP.Type.CGS
class TestKSPQCG(BaseTestKSP, unittest.TestCase):
KSP_TYPE = PETSc.KSP.Type.QCG
PC_TYPE = PETSc.PC.Type.JACOBI
class TestKSPBICG(BaseTestKSP, unittest.TestCase):
KSP_TYPE = PETSc.KSP.Type.BICG
class TestKSPGMRES(BaseTestKSP, unittest.TestCase):
KSP_TYPE = PETSc.KSP.Type.GMRES
class TestKSPFGMRES(BaseTestKSP, unittest.TestCase):
KSP_TYPE = PETSc.KSP.Type.FGMRES
# --------------------------------------------------------------------
if PETSc.ScalarType().dtype.char in 'FDG':
del TestKSPSTCG
# --------------------------------------------------------------------
if __name__ == '__main__':
unittest.main()
def test_surface_integral_dependency(get_assemblers): # noqa: F811
assemble_matrix, assemble_vector = get_assemblers
N = 10
mesh = create_unit_square(MPI.COMM_WORLD, N, N)
V = fem.VectorFunctionSpace(mesh, ("Lagrange", 1))
def top(x):
return np.isclose(x[1], 1)
fdim = mesh.topology.dim - 1
top_facets = locate_entities_boundary(mesh, fdim, top)
indices = np.array([], dtype=np.intc)
values = np.array([], dtype=np.intc)
markers = {3: top_facets}
for key in markers.keys():
indices = np.append(indices, markers[key])
values = np.append(values, np.full(len(markers[key]), key, dtype=np.intc))
sort = np.argsort(indices)
mt = meshtags(mesh, mesh.topology.dim - 1, np.array(indices[sort], dtype=np.intc),
np.array(values[sort], dtype=np.intc))
ds = ufl.Measure("ds", domain=mesh, subdomain_data=mt)
g = fem.Constant(mesh, PETSc.ScalarType((2, 1)))
h = fem.Constant(mesh, PETSc.ScalarType((3, 2)))
# Define variational problem
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
a = ufl.inner(u, v) * ds(3) + ufl.inner(ufl.grad(u), ufl.grad(v)) * ds
rhs = ufl.inner(g, v) * ds + ufl.inner(h, v) * ds(3)
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Create multipoint constraint and assemble system
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {}
for i in range(1, N):
s_m_c[l2b([1, i / N])] = {l2b([1, 1]): 0.3}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c, 1, 1)
mpc.finalize()
with Timer("~TEST: Assemble matrix"):
A = assemble_matrix(bilinear_form, mpc)
with Timer("~TEST: Assemble vector"):
b = assemble_vector(linear_form, mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
# Solve the MPC problem using a global transformation matrix
# and numpy solvers to get reference values
# Generate reference matrices and unconstrained solution
A_org = fem.petsc.assemble_matrix(bilinear_form)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES, mode=PETSc.ScatterMode.REVERSE)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
list_timings(comm, [TimingType.wall])
lid_velocity.interpolate(lid_velocity_expression)
facets = locate_entities_boundary(msh, 1, lid)
bc1 = dirichletbc(lid_velocity, locate_dofs_topological(V, 1, facets))
# Collect Dirichlet boundary conditions
bcs = [bc0, bc1]
# -
# We now define the bilinear and linear forms corresponding to the weak
# mixed formulation of the Stokes equations in a blocked structure:
# +
# Define variational problem
(u, p) = ufl.TrialFunction(V), ufl.TrialFunction(Q)
(v, q) = ufl.TestFunction(V), ufl.TestFunction(Q)
f = Constant(msh, (PETSc.ScalarType(0), PETSc.ScalarType(0)))
a = form([[inner(grad(u), grad(v)) * dx,
inner(p, div(v)) * dx], [inner(div(u), q) * dx, None]])
L = form([inner(f, v) * dx, inner(Constant(msh, PETSc.ScalarType(0)), q) * dx])
# -
# We will use a block-diagonal preconditioner to solve this problem:
a_p11 = form(inner(p, q) * dx)
a_p = [[a[0][0], None], [None, a_p11]]
# ### Nested matrix solver
#
# We now assemble the bilinear form into a nested matrix `A`, and call
# the `assemble()` method to communicate shared entries in parallel.
class TestObjectAOMapping(BaseTestObject, unittest.TestCase):
CLASS = PETSc.AO
FACTORY = 'createMapping'
TARGS = ([], [])
# class TestObjectFE(BaseTestObject, unittest.TestCase):
# CLASS = PETSc.FE
# FACTORY = 'create'
#
# class TestObjectQuad(BaseTestObject, unittest.TestCase):
# CLASS = PETSc.Quad
# FACTORY = 'create'
class TestObjectDMLabel(BaseTestObject, unittest.TestCase):
CLASS = PETSc.DMLabel
FACTORY = 'create'
TARGS = ("test", )
# --------------------------------------------------------------------
import numpy
if numpy.iscomplexobj(PETSc.ScalarType()):
del TestObjectTAO
if __name__ == '__main__':
unittest.main()
def test_linearproblem(master_point):
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 3, 5)
V = fem.FunctionSpace(mesh, ("Lagrange", 1))
# Solve Problem without MPC for reference
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
d = fem.Constant(mesh, PETSc.ScalarType(1.5))
c = fem.Constant(mesh, PETSc.ScalarType(2))
x = ufl.SpatialCoordinate(mesh)
f = c * ufl.sin(2 * ufl.pi * x[0]) * ufl.sin(ufl.pi * x[1])
g = fem.Function(V)
g.interpolate(lambda x: np.sin(x[0]) * x[1])
h = fem.Function(V)
h.interpolate(lambda x: 2 + x[1] * x[0])
a = d * g * ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
rhs = h * ufl.inner(f, v) * ufl.dx
# Generate reference matrices
A_org = fem.petsc.assemble_matrix(fem.form(a))
A_org.assemble()
L_org = fem.petsc.assemble_vector(fem.form(rhs))
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
# Create multipoint constraint
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {
l2b([1, 0]): {
l2b([0, 1]): 0.43,
l2b([1, 1]): 0.11
},
l2b([0, 0]): {
l2b(master_point): 0.69
}
}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
problem = dolfinx_mpc.LinearProblem(a,
rhs,
mpc,
bcs=[],
petsc_options={
"ksp_type": "preonly",
"pc_type": "lu"
})
uh = problem.solve()
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, problem._A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, problem._b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh.vector, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
ufc_form00 = dolfinx.jit.ffcx_jit(mesh.mpi_comm(), a00)
kernel00 = ufc_form00.create_cell_integral(-1).tabulate_tensor
ufc_form01 = dolfinx.jit.ffcx_jit(mesh.mpi_comm(), a01)
kernel01 = ufc_form01.create_cell_integral(-1).tabulate_tensor
ufc_form10 = dolfinx.jit.ffcx_jit(mesh.mpi_comm(), a10)
kernel10 = ufc_form10.create_cell_integral(-1).tabulate_tensor
ffi = cffi.FFI()
cffi_support.register_type(ffi.typeof('double _Complex'),
numba.types.complex128)
c_signature = numba.types.void(
numba.types.CPointer(numba.typeof(PETSc.ScalarType())),
numba.types.CPointer(numba.typeof(PETSc.ScalarType())),
numba.types.CPointer(numba.typeof(PETSc.ScalarType())),
numba.types.CPointer(numba.types.double),
numba.types.CPointer(numba.types.int32),
numba.types.CPointer(numba.types.uint8), numba.types.uint32)
@numba.cfunc(c_signature, nopython=True)
def tabulate_condensed_tensor_A(A_,
w_,
c_,
coords_,
entity_local_index,
permutation=ffi.NULL,
cell_permutation_info=0):
def test_pipeline(master_point, get_assemblers): # noqa: F811
assemble_matrix, assemble_vector = get_assemblers
# Create mesh and function space
mesh = create_unit_square(MPI.COMM_WORLD, 3, 5)
V = fem.FunctionSpace(mesh, ("Lagrange", 1))
# Solve Problem without MPC for reference
u = ufl.TrialFunction(V)
v = ufl.TestFunction(V)
d = fem.Constant(mesh, PETSc.ScalarType(1.5))
c = fem.Constant(mesh, PETSc.ScalarType(2))
x = ufl.SpatialCoordinate(mesh)
f = c * ufl.sin(2 * ufl.pi * x[0]) * ufl.sin(ufl.pi * x[1])
g = fem.Function(V)
g.interpolate(lambda x: np.sin(x[0]) * x[1])
h = fem.Function(V)
h.interpolate(lambda x: 2 + x[1] * x[0])
a = d * g * ufl.inner(ufl.grad(u), ufl.grad(v)) * ufl.dx
rhs = h * ufl.inner(f, v) * ufl.dx
bilinear_form = fem.form(a)
linear_form = fem.form(rhs)
# Generate reference matrices
A_org = fem.petsc.assemble_matrix(bilinear_form)
A_org.assemble()
L_org = fem.petsc.assemble_vector(linear_form)
L_org.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
# Create multipoint constraint
def l2b(li):
return np.array(li, dtype=np.float64).tobytes()
s_m_c = {
l2b([1, 0]): {
l2b([0, 1]): 0.43,
l2b([1, 1]): 0.11
},
l2b([0, 0]): {
l2b(master_point): 0.69
}
}
mpc = dolfinx_mpc.MultiPointConstraint(V)
mpc.create_general_constraint(s_m_c)
mpc.finalize()
A = assemble_matrix(bilinear_form, mpc)
b = assemble_vector(linear_form, mpc)
b.ghostUpdate(addv=PETSc.InsertMode.ADD_VALUES,
mode=PETSc.ScatterMode.REVERSE)
solver = PETSc.KSP().create(MPI.COMM_WORLD)
solver.setType(PETSc.KSP.Type.PREONLY)
solver.getPC().setType(PETSc.PC.Type.LU)
solver.setOperators(A)
# Solve
uh = b.copy()
uh.set(0)
solver.solve(b, uh)
uh.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
mpc.backsubstitution(uh)
root = 0
comm = mesh.comm
with Timer("~TEST: Compare"):
dolfinx_mpc.utils.compare_mpc_lhs(A_org, A, mpc, root=root)
dolfinx_mpc.utils.compare_mpc_rhs(L_org, b, mpc, root=root)
# Gather LHS, RHS and solution on one process
A_csr = dolfinx_mpc.utils.gather_PETScMatrix(A_org, root=root)
K = dolfinx_mpc.utils.gather_transformation_matrix(mpc, root=root)
L_np = dolfinx_mpc.utils.gather_PETScVector(L_org, root=root)
u_mpc = dolfinx_mpc.utils.gather_PETScVector(uh, root=root)
if MPI.COMM_WORLD.rank == root:
KTAK = K.T * A_csr * K
reduced_L = K.T @ L_np
# Solve linear system
d = scipy.sparse.linalg.spsolve(KTAK, reduced_L)
# Back substitution to full solution vector
uh_numpy = K @ d
assert np.allclose(uh_numpy, u_mpc)
list_timings(comm, [TimingType.wall])
