def __init__(self, F, u, bcs=None, J=None,
Jp=None,
form_compiler_parameters=None):
"""
:param F: the nonlinear form
:param u: the :class:`.Function` to solve for
:param bcs: the boundary conditions (optional)
:param J: the Jacobian J = dF/du (optional)
:param Jp: a form used for preconditioning the linear system,
optional, if not supplied then the Jacobian itself
will be used.
:param dict form_compiler_parameters: parameters to pass to the form
compiler (optional)
"""
# Extract and check arguments
u = solving._extract_u(u)
bcs = solving._extract_bcs(bcs)
# Store input UFL forms and solution Function
self.F_ufl = F
# Use the user-provided Jacobian. If none is provided, derive
# the Jacobian from the residual.
self.J_ufl = J or ufl_expr.derivative(F, u)
self.Jp = Jp
self.u_ufl = u
self.bcs = bcs
# Store form compiler parameters
self.form_compiler_parameters = form_compiler_parameters
self._constant_jacobian = False
def __init__(self, F, u, bcs=None, J=None,
form_compiler_parameters=None):
"""
:param F: the nonlinear form
:param u: the :class:`.Function` to solve for
:param bcs: the boundary conditions (optional)
:param J: the Jacobian J = dF/du (optional)
:param dict form_compiler_parameters: parameters to pass to the form
compiler (optional)
"""
# Extract and check arguments
u = _extract_u(u)
bcs = _extract_bcs(bcs)
# Store input UFL forms and solution Function
self.F_ufl = F
# Use the user-provided Jacobian. If none is provided, derive
# the Jacobian from the residual.
self.J_ufl = J or ufl_expr.derivative(F, u)
self.u_ufl = u
self.bcs = bcs
# Store form compiler parameters
form_compiler_parameters = form_compiler_parameters or {}
self.form_compiler_parameters = form_compiler_parameters
def __init__(self,
F,
u,
bcs=None,
J=None,
Jp=None,
form_compiler_parameters=None,
constant_jacobian=False):
"""
:param F: the nonlinear form
:param u: the :class:`.Function` to solve for
:param bcs: the boundary conditions (optional)
:param J: the Jacobian J = dF/du (optional)
:param Jp: a form used for preconditioning the linear system,
optional, if not supplied then the Jacobian itself
will be used.
:param dict form_compiler_parameters: parameters to pass to the form
compiler (optional)
:param dict constant_jacobian: True is J is constant, False if not
"""
from function import Function
# Store input UFL forms and solution Function
self.F = F
self.Jp = Jp
self.u = u
self.bcs = _extract_bcs(bcs)
# Argument checking
if not isinstance(self.F, ufl.Form):
raise TypeError("Provided residual is a '%s', not a Form" %
type(self.F).__name__)
if len(self.F.arguments()) != 1:
raise ValueError("Provided residual is not a linear form")
if not isinstance(self.u, Function):
raise TypeError("Provided solution is a '%s', not a Function" %
type(self.u).__name__)
# Use the user-provided Jacobian. If none is provided, derive
# the Jacobian from the residual.
self.J = J or ufl_expr.derivative(F, u)
if not isinstance(self.J, ufl.Form):
raise TypeError("Provided Jacobian is a '%s', not a Form" %
type(self.J).__name__)
if len(self.J.arguments()) != 2:
raise ValueError("Provided Jacobian is not a bilinear form")
if self.Jp is not None and not isinstance(self.Jp, ufl.Form):
raise TypeError("Provided preconditioner is a '%s', not a Form" %
type(self.Jp).__name__)
if self.Jp is not None and len(self.Jp.arguments()) != 2:
raise ValueError("Provided preconditioner is not a bilinear form")
# Store form compiler parameters
self.form_compiler_parameters = form_compiler_parameters
self._constant_jacobian = constant_jacobian
def __init__(self, F, u, bcs=None, J=None,
Jp=None,
form_compiler_parameters=None,
nest=None):
"""
:param F: the nonlinear form
:param u: the :class:`.Function` to solve for
:param bcs: the boundary conditions (optional)
:param J: the Jacobian J = dF/du (optional)
:param Jp: a form used for preconditioning the linear system,
optional, if not supplied then the Jacobian itself
will be used.
:param dict form_compiler_parameters: parameters to pass to the form
compiler (optional)
:param nest: indicate if matrices on mixed spaces should be
built as monolithic operators (suitable for direct
solves), or as nested blocks (suitable for fieldsplit
preconditioning). If not provided, uses the default
given by :data:`parameters["matnest"]`.
"""
# Extract and check arguments
u = solving._extract_u(u)
bcs = solving._extract_bcs(bcs)
# Store input UFL forms and solution Function
self.F = F
# Use the user-provided Jacobian. If none is provided, derive
# the Jacobian from the residual.
self.J = J or ufl_expr.derivative(F, u)
self.Jp = Jp
self.u = u
self.bcs = bcs
self._nest = nest
# Store form compiler parameters
self.form_compiler_parameters = form_compiler_parameters
self._constant_jacobian = False