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)
# 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 = fem.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(cpp.mesh.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], [[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
a = fem.Form(a)
A = assemble_matrix(a, [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.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT, mode=PETSc.ScatterMode.FORWARD)
M = (u_exact - uh)**2 * 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_lambda_assembler():
"""Tests assembly with a lambda function
"""
mesh = UnitSquareMesh(MPI.COMM_WORLD, 5, 5)
V = fem.FunctionSpace(mesh, ("Lagrange", 1))
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
# Initial assembly
a_form = fem.Form(a)
rdata = []
cdata = []
vdata = []
def mat_insert(rows, cols, vals):
vdata.append(vals)
rdata.append(numpy.repeat(rows, len(cols)))
cdata.append(numpy.tile(cols, len(rows)))
return 0
dolfinx.cpp.fem.assemble_matrix(mat_insert, a_form._cpp_object, [])
vdata = numpy.array(vdata).flatten()
cdata = numpy.array(cdata).flatten()
rdata = numpy.array(rdata).flatten()
mat = scipy.sparse.coo_matrix((vdata, (rdata, cdata)))
v = numpy.ones(mat.shape[1])
s = MPI.COMM_WORLD.allreduce(mat.dot(v).sum(), MPI.SUM)
assert numpy.isclose(s, 1.0)
def _solve_varproblem(*args, **kwargs):
"Solve variational problem a == L or F == 0"
# Extract arguments
eq, u, bcs, J, tol, M, form_compiler_parameters, petsc_options \
= _extract_args(*args, **kwargs)
# Solve linear variational problem
if isinstance(eq.lhs, ufl.Form) and isinstance(eq.rhs, ufl.Form):
a = fem.Form(eq.lhs, form_compiler_parameters=form_compiler_parameters)
L = fem.Form(eq.rhs, form_compiler_parameters=form_compiler_parameters)
b = fem.assemble_vector(L._cpp_object)
fem.apply_lifting(b, [a._cpp_object], [bcs])
b.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
fem.set_bc(b, bcs)
A = fem.assemble_matrix(a._cpp_object, bcs)
A.assemble()
comm = L._cpp_object.mesh().mpi_comm()
ksp = PETSc.KSP().create(comm)
ksp.setOperators(A)
ksp.setOptionsPrefix("dolfin_solve_")
opts = PETSc.Options()
opts.prefixPush("dolfin_solve_")
for k, v in petsc_options.items():
opts[k] = v
opts.prefixPop()
ksp.setFromOptions()
ksp.solve(b, u.vector)
# Solve nonlinear variational problem
else:
raise RuntimeError("Not implemented")
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 run_vector_test(mesh, V, degree):
"""Projection into H(div/curl) spaces"""
u, v = ufl.TrialFunction(V), ufl.TestFunction(V)
a = inner(u, v) * dx
# Source term
x = SpatialCoordinate(mesh)
u_exact = x[0]**degree
L = inner(u_exact, v[0]) * dx
with common.Timer("Assemble vector"):
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD,
mode=PETSc.ScatterMode.REVERSE)
with common.Timer("Assemble matrix"):
A = assemble_matrix(a)
A.assemble()
with common.Timer("Solve"):
# 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)
with common.Timer("Error functional compile"):
# Calculate error
M = (u_exact - uh[0])**2 * dx
for i in range(1, mesh.topology.dim):
M += uh[i]**2 * dx
M = fem.Form(M)
with common.Timer("Error assembly"):
error = mesh.mpi_comm().allreduce(assemble_scalar(M), op=MPI.SUM)
common.list_timings(MPI.COMM_WORLD, [common.TimingType.wall])
assert np.absolute(error) < 1.0e-14
def test_manufactured_poisson(degree, filename, datadir):
""" Manufactured Poisson problem, solving u = x[1]**p, where p is the
degree of the Lagrange function space.
"""
with XDMFFile(MPI.comm_world, os.path.join(datadir, filename)) as xdmf:
mesh = xdmf.read_mesh(GhostMode.none)
V = FunctionSpace(mesh, ("Lagrange", degree))
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)
# 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)
t0 = time.time()
L = fem.Form(L)
t1 = time.time()
print("Linear form compile time:", t1 - t0)
u_bc = Function(V)
u_bc.interpolate(lambda x: x[1]**degree)
# Create Dirichlet boundary condition
mesh.create_connectivity_all()
facetdim = mesh.topology.dim - 1
bndry_facets = np.where(
np.array(mesh.topology.on_boundary(facetdim)) == 1)[0]
bdofs = locate_dofs_topological(V, facetdim, bndry_facets)
assert (len(bdofs) < V.dim())
bc = DirichletBC(u_bc, bdofs)
t0 = time.time()
b = assemble_vector(L)
apply_lifting(b, [a], [[bc]])
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
set_bc(b, [bc])
t1 = time.time()
print("Vector assembly time:", t1 - t0)
t0 = time.time()
a = fem.Form(a)
t1 = time.time()
print("Bilinear form compile time:", t1 - t0)
t0 = time.time()
A = assemble_matrix(a, [bc])
A.assemble()
t1 = time.time()
print("Matrix assembly time:", t1 - t0)
# 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)
# Solve
t0 = time.time()
uh = Function(V)
solver.solve(b, uh.vector)
uh.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
t1 = time.time()
print("Linear solver time:", t1 - t0)
M = (u_exact - uh)**2 * dx
t0 = time.time()
M = fem.Form(M)
t1 = time.time()
print("Error functional compile time:", t1 - t0)
t0 = time.time()
error = assemble_scalar(M)
error = MPI.sum(mesh.mpi_comm(), error)
t1 = time.time()
print("Error assembly time:", t1 - t0)
assert np.absolute(error) < 1.0e-14
def run_dg_test(mesh, V, degree):
""" Manufactured Poisson problem, solving u = x[component]**n, where n is the
degree of the Lagrange function space.
"""
u, v = TrialFunction(V), TestFunction(V)
# Exact solution
x = SpatialCoordinate(mesh)
u_exact = x[1]**degree
# Coefficient
k = Function(V)
k.vector.set(2.0)
k.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
# Source term
f = -div(k * grad(u_exact))
# Mesh normals and element size
n = FacetNormal(mesh)
h = CellDiameter(mesh)
h_avg = (h("+") + h("-")) / 2.0
# Penalty parameter
alpha = 32
dx_ = dx(metadata={"quadrature_degree": -1})
ds_ = ds(metadata={"quadrature_degree": -1})
dS_ = dS(metadata={"quadrature_degree": -1})
a = inner(k * grad(u), grad(v)) * dx_ \
- k("+") * inner(avg(grad(u)), jump(v, n)) * dS_ \
- k("+") * inner(jump(u, n), avg(grad(v))) * dS_ \
+ k("+") * (alpha / h_avg) * inner(jump(u, n), jump(v, n)) * dS_ \
- inner(k * grad(u), v * n) * ds_ \
- inner(u * n, k * grad(v)) * ds_ \
+ (alpha / h) * inner(k * u, v) * ds_
L = inner(f, v) * dx_ - inner(k * u_exact * n, grad(v)) * ds_ \
+ (alpha / h) * inner(k * u_exact, v) * ds_
for integral in a.integrals():
integral.metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(
a)
for integral in L.integrals():
integral.metadata(
)["quadrature_degree"] = ufl.algorithms.estimate_total_polynomial_degree(
L)
b = assemble_vector(L)
b.ghostUpdate(addv=PETSc.InsertMode.ADD, mode=PETSc.ScatterMode.REVERSE)
A = assemble_matrix(a, [])
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)
# Solve
uh = Function(V)
solver.solve(b, uh.vector)
uh.vector.ghostUpdate(addv=PETSc.InsertMode.INSERT,
mode=PETSc.ScatterMode.FORWARD)
# Calculate error
M = (u_exact - uh)**2 * dx
M = fem.Form(M)
error = mesh.mpi_comm().allreduce(assemble_scalar(M), op=MPI.SUM)
assert np.absolute(error) < 1.0e-14
def __init__(self,
a: ufl.Form,
L: ufl.Form,
bcs: typing.List[fem.DirichletBC] = [],
u: fem.Function = None,
petsc_options={},
form_compiler_parameters={},
jit_parameters={}):
"""Initialize solver for a linear variational problem.
Parameters
----------
a
A bilinear UFL form, the left hand side of the variational problem.
L
A linear UFL form, the right hand side of the variational problem.
bcs
A list of Dirichlet boundary conditions.
u
The solution function. It will be created if not provided.
petsc_options
Parameters that is passed to the linear algebra backend PETSc.
For available choices for the 'petsc_options' kwarg, see the
`PETSc-documentation <https://www.mcs.anl.gov/petsc/documentation/index.html>`.
form_compiler_parameters
Parameters used in FFCx compilation of this form. Run `ffcx --help` at
the commandline to see all available options. Takes priority over all
other parameter values, except for `scalar_type` which is determined by
DOLFINx.
jit_parameters
Parameters used in CFFI JIT compilation of C code generated by FFCx.
See `python/dolfinx/jit.py` for all available parameters.
Takes priority over all other parameter values.
.. code-block:: python
problem = LinearProblem(a, L, [bc0, bc1], petsc_options={"ksp_type": "preonly", "pc_type": "lu"})
"""
self._a = fem.Form(a,
form_compiler_parameters=form_compiler_parameters,
jit_parameters=jit_parameters)
self._A = fem.create_matrix(self._a)
self._L = fem.Form(L,
form_compiler_parameters=form_compiler_parameters,
jit_parameters=jit_parameters)
self._b = fem.create_vector(self._L)
if u is None:
# Extract function space from TrialFunction (which is at the
# end of the argument list as it is numbered as 1, while the
# Test function is numbered as 0)
self.u = fem.Function(a.arguments()[-1].ufl_function_space())
else:
self.u = u
self.bcs = bcs
self._solver = PETSc.KSP().create(
self.u.function_space.mesh.mpi_comm())
self._solver.setOperators(self._A)
# Give PETSc solver options a unique prefix
solver_prefix = "dolfinx_solve_{}".format(id(self))
self._solver.setOptionsPrefix(solver_prefix)
# Set PETSc options
opts = PETSc.Options()
opts.prefixPush(solver_prefix)
for k, v in petsc_options.items():
opts[k] = v
opts.prefixPop()
self._solver.setFromOptions()
