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