def solve(self, bounds=None):
r"""Solve the variational problem.
:arg bounds: Optional bounds on the solution (lower, upper).
``lower`` and ``upper`` must both be
:class:`~.Function`\s. or :class:`~.Vector`\s.
.. note::
If bounds are provided the ``snes_type`` must be set to
``vinewtonssls`` or ``vinewtonrsls``.
"""
# Make sure appcontext is attached to the DM before we solve.
dm = self.snes.getDM()
for dbc in self._problem.dirichlet_bcs():
dbc.apply(self._problem.u)
if bounds is not None:
lower, upper = bounds
with lower.dat.vec_ro as lb, upper.dat.vec_ro as ub:
self.snes.setVariableBounds(lb, ub)
work = self._work
with self._problem.u.dat.vec as u:
u.copy(work)
with ExitStack() as stack:
# Ensure options database has full set of options (so monitors
# work right)
for ctx in chain((self.inserted_options(), dmhooks.appctx(dm, self._ctx)),
self._transfer_operators):
stack.enter_context(ctx)
self.snes.solve(None, work)
work.copy(u)
self._setup = True
solving_utils.check_snes_convergence(self.snes)
def solve(self, bounds=None):
"""Solve the variational problem.
:arg bounds: Optional bounds on the solution (lower, upper).
``lower`` and ``upper`` must both be
:class:`~.Function`\s. or :class:`~.Vector`\s.
.. note::
If bounds are provided the ``snes_type`` must be set to
``vinewtonssls`` or ``vinewtonrsls``.
"""
# Make sure appcontext is attached to the DM before we solve.
dm = self.snes.getDM()
# Apply the boundary conditions to the initial guess.
for bc in self._problem.bcs:
bc.apply(self._problem.u)
if bounds is not None:
lower, upper = bounds
with lower.dat.vec_ro as lb, upper.dat.vec_ro as ub:
self.snes.setVariableBounds(lb, ub)
work = self._work
# Ensure options database has full set of options (so monitors work right)
with self.inserted_options(), dmhooks.appctx(dm, self._ctx):
with self._problem.u.dat.vec as u:
u.copy(work)
if self._transfer_operators is not None:
with self._transfer_operators:
self.snes.solve(None, work)
else:
self.snes.solve(None, work)
work.copy(u)
self._setup = True
solving_utils.check_snes_convergence(self.snes)
def __init__(self, problem, **kwargs):
r"""
:arg problem: A :class:`NonlinearVariationalProblem` to solve.
:kwarg nullspace: an optional :class:`.VectorSpaceBasis` (or
:class:`.MixedVectorSpaceBasis`) spanning the null
space of the operator.
:kwarg transpose_nullspace: as for the nullspace, but used to
make the right hand side consistent.
:kwarg near_nullspace: as for the nullspace, but used to
specify the near nullspace (for multigrid solvers).
:kwarg solver_parameters: Solver parameters to pass to PETSc.
This should be a dict mapping PETSc options to values.
:kwarg appctx: A dictionary containing application context that
is passed to the preconditioner if matrix-free.
:kwarg options_prefix: an optional prefix used to distinguish
PETSc options. If not provided a unique prefix will be
created. Use this option if you want to pass options
to the solver from the command line in addition to
through the ``solver_parameters`` dict.
:kwarg pre_jacobian_callback: A user-defined function that will
be called immediately before Jacobian assembly. This can
be used, for example, to update a coefficient function
that has a complicated dependence on the unknown solution.
:kwarg pre_function_callback: As above, but called immediately
before residual assembly
Example usage of the ``solver_parameters`` option: to set the
nonlinear solver type to just use a linear solver, use
.. code-block:: python
{'snes_type': 'ksponly'}
PETSc flag options (where the presence of the option means something) should
be specified with ``None``.
For example:
.. code-block:: python
{'snes_monitor': None}
To use the ``pre_jacobian_callback`` or ``pre_function_callback``
functionality, the user-defined function must accept the current
solution as a petsc4py Vec. Example usage is given below:
.. code-block:: python
def update_diffusivity(current_solution):
with cursol.dat.vec_wo as v:
current_solution.copy(v)
solve(trial*test*dx == dot(grad(cursol), grad(test))*dx, diffusivity)
solver = NonlinearVariationalSolver(problem,
pre_jacobian_callback=update_diffusivity)
"""
assert isinstance(problem, NonlinearVariationalProblem)
parameters = kwargs.get("solver_parameters")
if "parameters" in kwargs:
raise TypeError("Use solver_parameters, not parameters")
nullspace = kwargs.get("nullspace")
nullspace_T = kwargs.get("transpose_nullspace")
near_nullspace = kwargs.get("near_nullspace")
options_prefix = kwargs.get("options_prefix")
pre_j_callback = kwargs.get("pre_jacobian_callback")
pre_f_callback = kwargs.get("pre_function_callback")
super(NonlinearVariationalSolver,
self).__init__(parameters, options_prefix)
# Allow anything, interpret "matfree" as matrix_free.
mat_type = self.parameters.get("mat_type")
pmat_type = self.parameters.get("pmat_type")
matfree = mat_type == "matfree"
pmatfree = pmat_type == "matfree"
appctx = kwargs.get("appctx")
ctx = solving_utils._SNESContext(problem,
mat_type=mat_type,
pmat_type=pmat_type,
appctx=appctx,
pre_jacobian_callback=pre_j_callback,
pre_function_callback=pre_f_callback,
options_prefix=self.options_prefix)
# No preconditioner by default for matrix-free
if (problem.Jp is not None and pmatfree) or matfree:
self.set_default_parameter("pc_type", "none")
elif ctx.is_mixed:
# Mixed problem, use jacobi pc if user has not supplied
# one.
self.set_default_parameter("pc_type", "jacobi")
self.snes = PETSc.SNES().create(comm=problem.dm.comm)
self._problem = problem
self._ctx = ctx
self._work = problem.u.dof_dset.layout_vec.duplicate()
self.snes.setDM(problem.dm)
ctx.set_function(self.snes)
ctx.set_jacobian(self.snes)
ctx.set_nullspace(nullspace,
problem.J.arguments()[0].function_space()._ises,
transpose=False,
near=False)
ctx.set_nullspace(nullspace_T,
problem.J.arguments()[1].function_space()._ises,
transpose=True,
near=False)
ctx.set_nullspace(near_nullspace,
problem.J.arguments()[0].function_space()._ises,
transpose=False,
near=True)
ctx._nullspace = nullspace
ctx._nullspace_T = nullspace_T
ctx._near_nullspace = near_nullspace
# Set from options now, so that people who want to noodle with
# the snes object directly (mostly Patrick), can. We need the
# DM with an app context in place so that if the DM is active
# on a subKSP the context is available.
dm = self.snes.getDM()
with dmhooks.appctx(dm, self._ctx):
self.set_from_options(self.snes)
# Used for custom grid transfer.
self._transfer_operators = ()
self._setup = False
def _la_solve(A, x, b, **kwargs):
r"""Solve a linear algebra problem.
:arg A: the assembled bilinear form, a :class:`.Matrix`.
:arg x: the :class:`.Function` to write the solution into.
:arg b: the :class:`.Function` defining the right hand side values.
:kwarg bcs: an optional list of :class:`.DirichletBC`\s and/or :class:`.EquationBC`\s to apply.
:kwarg solver_parameters: optional solver parameters.
:kwarg nullspace: an optional :class:`.VectorSpaceBasis` (or
:class:`.MixedVectorSpaceBasis`) spanning the null space of
the operator.
:kwarg transpose_nullspace: as for the nullspace, but used to
make the right hand side consistent.
:kwarg near_nullspace: as for the nullspace, but used to add
the near nullspace.
:kwarg options_prefix: an optional prefix used to distinguish
PETSc options. If not provided a unique prefix will be
created. Use this option if you want to pass options
to the solver from the command line in addition to
through the ``solver_parameters`` dict.
.. note::
Any boundary conditions passed in as an argument here override the
boundary conditions set when the bilinear form was assembled.
That is, in the following example:
.. code-block:: python
A = assemble(a, bcs=[bc1])
solve(A, x, b, bcs=[bc2])
the boundary conditions in `bc2` will be applied to the problem
while `bc1` will be ignored.
Example usage:
.. code-block:: python
_la_solve(A, x, b, solver_parameters=parameters_dict)."""
bcs, solver_parameters, nullspace, nullspace_T, near_nullspace, \
options_prefix = _extract_linear_solver_args(A, x, b, **kwargs)
for bc in _extract_bcs(bcs):
if not bc.is_linear:
raise RuntimeError("EquationBCs must also be linear when solving linear system.")
if bcs is not None:
A.bcs = bcs
solver = ls.LinearSolver(A, solver_parameters=solver_parameters,
nullspace=nullspace,
transpose_nullspace=nullspace_T,
near_nullspace=near_nullspace,
options_prefix=options_prefix)
if isinstance(x, firedrake.Vector):
x = x.function
# linear MG doesn't need RHS, supply zero.
lvp = vs.LinearVariationalProblem(a=A.a, L=0, u=x, bcs=bcs)
mat_type = A.mat_type
appctx = solver_parameters.get("appctx", {})
ctx = solving_utils._SNESContext(lvp,
mat_type=mat_type,
pmat_type=mat_type,
appctx=appctx,
options_prefix=options_prefix)
dm = solver.ksp.dm
with dmhooks.appctx(dm, ctx):
solver.solve(x, b)
def _la_solve(A, x, b, **kwargs):
r"""Solve a linear algebra problem.
:arg A: the assembled bilinear form, a :class:`.Matrix`.
:arg x: the :class:`.Function` to write the solution into.
:arg b: the :class:`.Function` defining the right hand side values.
:kwarg bcs: an optional list of :class:`.DirichletBC`\s to apply.
:kwarg solver_parameters: optional solver parameters.
:kwarg nullspace: an optional :class:`.VectorSpaceBasis` (or
:class:`.MixedVectorSpaceBasis`) spanning the null space of
the operator.
:kwarg transpose_nullspace: as for the nullspace, but used to
make the right hand side consistent.
:kwarg near_nullspace: as for the nullspace, but used to add
the near nullspace.
:kwarg options_prefix: an optional prefix used to distinguish
PETSc options. If not provided a unique prefix will be
created. Use this option if you want to pass options
to the solver from the command line in addition to
through the ``solver_parameters`` dict.
.. note::
Any boundary conditions passed in as an argument here override the
boundary conditions set when the bilinear form was assembled.
That is, in the following example:
.. code-block:: python
A = assemble(a, bcs=[bc1])
solve(A, x, b, bcs=[bc2])
the boundary conditions in `bc2` will be applied to the problem
while `bc1` will be ignored.
Example usage:
.. code-block:: python
_la_solve(A, x, b, solver_parameters=parameters_dict)."""
bcs, solver_parameters, nullspace, nullspace_T, near_nullspace, \
options_prefix = _extract_linear_solver_args(A, x, b, **kwargs)
if bcs is not None:
A.bcs = bcs
solver = ls.LinearSolver(A, solver_parameters=solver_parameters,
nullspace=nullspace,
transpose_nullspace=nullspace_T,
near_nullspace=near_nullspace,
options_prefix=options_prefix)
if isinstance(x, firedrake.Vector):
x = x.function
# linear MG doesn't need RHS, supply zero.
lvp = vs.LinearVariationalProblem(a=A.a, L=0, u=x, bcs=bcs)
mat_type = A.mat_type
appctx = solver_parameters.get("appctx", {})
ctx = solving_utils._SNESContext(lvp,
mat_type=mat_type,
pmat_type=mat_type,
appctx=appctx,
options_prefix=options_prefix)
dm = solver.ksp.dm
with dmhooks.appctx(dm, ctx):
solver.solve(x, b)
def __init__(self, problem, **kwargs):
r"""
:arg problem: A :class:`NonlinearVariationalProblem` to solve.
:kwarg nullspace: an optional :class:`.VectorSpaceBasis` (or
:class:`.MixedVectorSpaceBasis`) spanning the null
space of the operator.
:kwarg transpose_nullspace: as for the nullspace, but used to
make the right hand side consistent.
:kwarg near_nullspace: as for the nullspace, but used to
specify the near nullspace (for multigrid solvers).
:kwarg solver_parameters: Solver parameters to pass to PETSc.
This should be a dict mapping PETSc options to values.
:kwarg appctx: A dictionary containing application context that
is passed to the preconditioner if matrix-free.
:kwarg options_prefix: an optional prefix used to distinguish
PETSc options. If not provided a unique prefix will be
created. Use this option if you want to pass options
to the solver from the command line in addition to
through the ``solver_parameters`` dict.
:kwarg pre_jacobian_callback: A user-defined function that will
be called immediately before Jacobian assembly. This can
be used, for example, to update a coefficient function
that has a complicated dependence on the unknown solution.
:kwarg pre_function_callback: As above, but called immediately
before residual assembly
Example usage of the ``solver_parameters`` option: to set the
nonlinear solver type to just use a linear solver, use
.. code-block:: python
{'snes_type': 'ksponly'}
PETSc flag options (where the presence of the option means something) should
be specified with ``None``.
For example:
.. code-block:: python
{'snes_monitor': None}
To use the ``pre_jacobian_callback`` or ``pre_function_callback``
functionality, the user-defined function must accept the current
solution as a petsc4py Vec. Example usage is given below:
.. code-block:: python
def update_diffusivity(current_solution):
with cursol.dat.vec_wo as v:
current_solution.copy(v)
solve(trial*test*dx == dot(grad(cursol), grad(test))*dx, diffusivity)
solver = NonlinearVariationalSolver(problem,
pre_jacobian_callback=update_diffusivity)
"""
assert isinstance(problem, NonlinearVariationalProblem)
parameters = kwargs.get("solver_parameters")
if "parameters" in kwargs:
raise TypeError("Use solver_parameters, not parameters")
nullspace = kwargs.get("nullspace")
nullspace_T = kwargs.get("transpose_nullspace")
near_nullspace = kwargs.get("near_nullspace")
options_prefix = kwargs.get("options_prefix")
pre_j_callback = kwargs.get("pre_jacobian_callback")
pre_f_callback = kwargs.get("pre_function_callback")
super(NonlinearVariationalSolver, self).__init__(parameters, options_prefix)
# Allow anything, interpret "matfree" as matrix_free.
mat_type = self.parameters.get("mat_type")
pmat_type = self.parameters.get("pmat_type")
matfree = mat_type == "matfree"
pmatfree = pmat_type == "matfree"
appctx = kwargs.get("appctx")
ctx = solving_utils._SNESContext(problem,
mat_type=mat_type,
pmat_type=pmat_type,
appctx=appctx,
pre_jacobian_callback=pre_j_callback,
pre_function_callback=pre_f_callback,
options_prefix=self.options_prefix)
# No preconditioner by default for matrix-free
if (problem.Jp is not None and pmatfree) or matfree:
self.set_default_parameter("pc_type", "none")
elif ctx.is_mixed:
# Mixed problem, use jacobi pc if user has not supplied
# one.
self.set_default_parameter("pc_type", "jacobi")
self.snes = PETSc.SNES().create(comm=problem.dm.comm)
self._problem = problem
self._ctx = ctx
self._work = problem.u.dof_dset.layout_vec.duplicate()
self.snes.setDM(problem.dm)
ctx.set_function(self.snes)
ctx.set_jacobian(self.snes)
ctx.set_nullspace(nullspace, problem.J.arguments()[0].function_space()._ises,
transpose=False, near=False)
ctx.set_nullspace(nullspace_T, problem.J.arguments()[1].function_space()._ises,
transpose=True, near=False)
ctx.set_nullspace(near_nullspace, problem.J.arguments()[0].function_space()._ises,
transpose=False, near=True)
ctx._nullspace = nullspace
ctx._nullspace_T = nullspace_T
ctx._near_nullspace = near_nullspace
# Set from options now, so that people who want to noodle with
# the snes object directly (mostly Patrick), can. We need the
# DM with an app context in place so that if the DM is active
# on a subKSP the context is available.
dm = self.snes.getDM()
with dmhooks.appctx(dm, self._ctx):
self.set_from_options(self.snes)
# Used for custom grid transfer.
self._transfer_operators = ()
self._setup = False
