def assemble(f, tensor=None, bcs=None): """Evaluate f. :arg f: a :class:`ufl.Form` or :class:`ufl.expr.Expr`. :arg tensor: an existing tensor object to place the result in (optional). :arg bcs: a list of boundary conditions to apply (optional). 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 isinstance(f, ufl.form.Form): return _assemble(f, tensor=tensor, bcs=_extract_bcs(bcs)) elif isinstance(f, ufl.expr.Expr): return assemble_expressions.assemble_expression(f) else: raise TypeError("Unable to assemble: %r" % f)
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)