Since 2.9 release

Changes to solver parameter keys

The parameter keys used to customize the (non)-linear solvers during the construction of a scheme have been changed. Keys with prefix newton.linear have been replaced with linear while parameters with only a newton prefix are now prefixed with nonlinear. So


should be replace with

 "linear.preconditioning.method": "jacobi",

In addition the parameter newton.linear.tolerance.strategy has been replaced with nonlinear.forcing.


while all the changes are indendet to be backwards compatible with suitable deprecation warnings printed if old keys are still used, it is possible that some corner cases were missed.

Deprecation of the rhs argument for scheme.solve

The rhs argument has been replaced with rightHandSide and has to be provided as a named argument.


schemes with Dirichlet constraints did not handle a given rhs argument correctly. The returned target was always equal to the Dirichlet conditions on the boundary independent of the values in the provided rhs. This has now been corrected so that target=rhs+dirichlet at the boundary which is consistent with the evaluation of the operator (operator(u,w) results in w=u-dirichlet on the boundary). To obtain the old behavior add scheme.setConstraints(0,rhs) before calling scheme.solve(target=target,rightHandSide=rhs). No changes are needed for schemes without Dirichlet boundary constraints. See merge request 661.

Added a solve method to the linearization of schemes

The object returned by the linear method on a scheme now has a solve method.

Updated dune.fem.scheme.linearized

This function takes a scheme and returns a scheme implementing the first two terms of its Taylor expansion. Like the object returned by scheme.linear this has a solve method.

Add operator __len__ to spaces.

This allows to use the typical Python built-in function len(space).

Deprecation of dune.fem.function.integrate

This function is deprecated. Use dune.fem.integrate instead. The ufl expression to integrate is now the first argument. If possible the grid view and order will be determined from the ufl expression if possible but can be passed in as extra arguments similar to the old function: dune.fem.function.integrate(grid,expression,order=None) with dune.fem.integrate(expression,gridView=None,order=None).

Deprecation of dune.fem.function.uflFunction and dune.fem.function.cppFunction

To construct different versions of grid function use dune.fem.function.gridFunction. The signature of the new function is def gridFunction(expr=None,gridView=None,*,name=None,order=None, fctName=None, view=None, **kwargs).

  • If expr is a gridView or is None (and the gridView is not None) then the function acts like the decorator from 2.9 version. Note that the old view parameter is also deprecated and replaced by gridView.


    @gridFunction(gv,"name",5) will not work anymore since name and order need to be named arguments. So this will lead to an error instead of a deprecation warning and needs to be replaced by @gridFunction(gv,name="name",order=5).

  • If expr is a ufl expression then this functions acts like the uflFunction from 2.9 with the old ufl argument being replaced by expr. In addition gridView and order can be omitted in case where the grid view can be determined from the ufl expression (e.g. the expression contains a grid function). The order will be determined heuristically from the expression if omitted.

  • If expr is a string then the function acts as like the old cppFunction. If fctName is not provided the name argument is assumed to also be the name of the cpp function to export.

Deprecation of dune.ufl.expression2GF

Use the extended version of dune.fem.function.gridFunction instead.

Deprecation of dune.fem.operator.linear

Use the new method linear on the schemes or operators. Note that the new method has no ubar argument (use the jacobian method to assemble around a non zero value). The method has a new bool argument assemble which is True by default. Passing in assemble=False returns an empty linear operator which can be passed into jacobian to be filled.

Deprecation of

This has been renamed to and will be deprecated soon.

Add DirichletIndices method to operators and schemes

This method returns the indices of dofs on the Dirichlet boundary. By default all indices are returned but a boundary id can be provided to only return a subset of indices.

Extension of the jacobian method on schemes and operators

In addition to the existing jacobian method taking a linear operator object a new overload is available taking a further rhs argument which returns the functional part of the operator as though it was on the right hand side. So if the ufl form is a(u,v)=l(v) then this method assembles both the system matrix A and the right hand side functional (rhs needs to be a discrete function over the range space of the operator).

Set non default quadratures in quadrature rules

At the moment only dx(metadata={"quadrature_rule":"lumped"}) is available that sets a quadrature that can be used for lower order Lagrange elements to use lumped mass matrices. More general cases will be added soon.

Assembly function

The function dune.fem.assemble takes a ufl form and returns their assembled versions.

  • If the first argument has arity zero (i.e. has no trial or test function) then the intral will be computed, e.g., dune.fem.assemble(dot.ufl(x,x)*ufl.dx, gridView=gv) where x is a ufl.SpatialCoordinate. Note that the grid view needs to be provided since it can not be determined from the ufl form. It can be omitted if the form contains for example a grid function, e.g., dune.fem.assemble(inner(grad(u_h),grad(u_h))*dx). Note that forms are always scalar valued. For vector valued integration use dune.fem.integrate.

  • If the first function has arity one (i.e. contains a test function) then the functional we be assembled returning a discrete function: dune.fem.assemble(f*v*dx). Again if possible the grid view will be extracted from the form.

  • If the first argument has arity two (i.e. contains both test and trial function) then the function assembles the system matrix and (if the form contains a arity one part) the right hand side functional: dune.fem.assemble(u*v*dx - f*v*dx) returns the linear operator for u*v*dx and the discrete function for f*v*dx. If the form does not contain an arity one part, e.g., dune.fem.assemble(u*v*dx) returns only the linear operator.

Improved Pickling support

Discrete functions can now be directly pickled and will be reconstructed with the grid on load. The required JIT modules will also be generated on load if they do not exist on the system. For this to work one needs to use the dune.common.pickle module as discussed in the Section on pickling.

Paraview Reader

A paraview reader is added to the dune.fem package which can directly work with the pickled files. UFL transformations can be applied after loading the discrete functions in paraview. For paraview to find the reader a environment variable needs to be set. The correct command can be found running python -m dune.fem reader or the correct env variable can be set by running

export PV_PLUGIN_PATH=`python -m dune.fem readerpath`

See merge request 581.

Sampler along Boundary

In addition to a lineSample and pointSample the dune.fem.utility module now also provides a boundarySample function

boundarySample(gridFunction, boundaryId=None, boundaryDomain=None, order=-1)

See the help text of dune.fem.utility.boundarySample for details.

Point sampler returning (entity,local coordinate) for given global coordinate

Improved Dirichlet Boundary Indexing in UFL Forms

To restrict a domain integral to a part of the boundary given by a boundary id one can now use ufl.ds(id) or multiply the integral with dune.ufl.BoundaryId(space) (see the section on Mixing different types of boundary conditions.

Note: we have also unified the default boundary ids when using a dune.grid.cartesianDomain to always be the same as when using dune.grid.structuredGrid. This was not the case with some grid implementations.

Eisenstatwalker in Newton method

Set parameter nonlinear.forcing to eisenstatwalker during scheme construction.

Storage setup in scheme


Methods on space to return local mapper and for evaluating basis functions

New methods have been added to the space to return the basis functions evaluated at some given point. Also a new method has been added to return the global indices of the dofs attached to a given element.

Logging of parameter values

See section on internal solvers.