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 assemble(f, tensor=None, bcs=None, form_compiler_parameters=None, inverse=False, nest=None): """Evaluate f. :arg f: a :class:`ufl.Form` or :class:`ufl.core.expr.Expr`. :arg tensor: an existing tensor object to place the result in (optional). :arg bcs: a list of boundary conditions to apply (optional). :arg form_compiler_parameters: (optional) dict of parameters to pass to the form compiler. Ignored if not assembling a :class:`ufl.Form`. Any parameters provided here will be overridden by parameters set on the :class;`ufl.Measure` in the form. For example, if a :data:`quadrature_degree` of 4 is specified in this argument, but a degree of 3 is requested in the measure, the latter will be used. :arg inverse: (optional) if f is a 2-form, then assemble the inverse of the local matrices. :arg nest: (optional) flag indicating if a 2-form (matrix) on a mixed space should be assembled as a block matrix (if :data:`nest` is :data:`True`) or not. The default value is taken from the parameters dict :data:`parameters["matnest"]`. If f is a :class:`ufl.Form` then this evaluates the corresponding integral(s) and returns a :class:`float` for 0-forms, a :class:`.Function` for 1-forms and a :class:`.Matrix` for 2-forms. If f is an expression other than a form, it will be evaluated pointwise on the :class:`.Function`\s in the expression. This will only succeed if all the Functions are on the same :class:`.FunctionSpace` If ``tensor`` is supplied, the assembled result will be placed there, otherwise a new object of the appropriate type will be returned. If ``bcs`` is supplied and ``f`` is a 2-form, the rows and columns of the resulting :class:`.Matrix` corresponding to boundary nodes will be set to 0 and the diagonal entries to 1. If ``f`` is a 1-form, the vector entries at boundary nodes are set to the boundary condition values. """ if isinstance(f, ufl.form.Form): return _assemble(f, tensor=tensor, bcs=solving._extract_bcs(bcs), form_compiler_parameters=form_compiler_parameters, inverse=inverse, nest=nest) elif isinstance(f, ufl.core.expr.Expr): return assemble_expressions.assemble_expression(f) else: raise TypeError("Unable to assemble: %r" % f)
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