dunefunctions
dunefunctions
Abstractions for functions and discrete function space bases
Requires: 
dunelocalfunctions
dunegrid
dunetypetree
duneistl

Git repository: 
https://gitlab.duneproject.org/staging/dunefunctions 
The dunefunctions module
Functionality
The dunefunctions module provides an abstraction layer for global finite element functions. Its two main concepts are functions implemented as callable objects, and bases of finite element spaces.
Functions
dunefunctions provides an interface to “functions” in the mathematical sense, in particular to finite element functions defined on a grid, but going far beyond that.
The interface revolves around the concept of a “callable”. This encompasses any
type of C++ object that can be evaluated with operator()
, like free functions,
function objects, and lambdas. Dynamic polymorphism is realized
using type erasure and the std::function
class, which does not sacrifice
efficiency in purely static code.
dunefunctions extends the “callable” concept into several directions. First, it allows for differentiable functions. Such functions can hand out their derivative as new function objects. Second, for functions defined piecewisely on a finite element grid, the concept of local function is introduced. Local functions can be bound to grid elements. All further evaluations of a function bound to an element are in local coordinates of that element. This approach allows to avoid overhead when there are many consecutive evaluations of a function on a single element.
Function space bases
The second part of dunefunctions provides a welldefined interface to bases of finite element function spaces. For this interface, a finite element basis is a set of functions with a prescribed ordering, and a way to index them. The core functionality has three parts:
 For a given grid element, obtain the restrictions of all basis functions to this element, except for those functions where the restriction is zero. In other words: get the shape functions for the element.
 Get a local numbering for these shape functions. This is needed to index the element stiffness matrix.
 Get a global numbering for the shape functions. This is needed to index the global stiffness matrix.
While local numbers are always integers, global numbers can be multiindices, if appropriate.
A central feature of dunefunctions is the construction of finite element bases for vectorvalued and mixed spaces by tensor multiplication of simpler bases. The resulting tensor multiplication expressions can be interpreted as rooted trees. For example, the tree for the threedimensional TaylorHood basis is shown below. This tree structure is directly exposed in the dunefunctions interface.
Implementations of Function Space Bases
Some of the finite element bases currently available are:
LagrangeBasis
: A kth order Lagrangian bases, with k a runtime or compiletime parameter.LagrangeDGBasis
: A kth order DG basis, using Lagrangian shape functions.NedelecBasis
: For H(curl)conforming problemsRaviartThomasBasis
: For H(div)conforming problemsBrezziDouglasMariniBasis
: The BrezziDouglasMariniElementRannacherTurekBasis
: Combines the RannacherTurek element on quadrilateral elements with the CrouzeixRaviart element on simplicesBSplineBasis
: A basis of BSpline functions of given arbitrary order on a structured grid.
Documentation
Class documentation
The module contains a class documentation which can be build using doxygen.
After the module has been build, you can build the documentation using
make doc
Additionally the prebuild doxygen documentation for the master and
release branches is also hosted on the documentation section
of the Dune website.
Manual
There are two documents describing the concepts and use of dunefunctions. The interface for functions is described in the article
C. Engwer, C. Gräser, S. Müthing, and O. Sander.
The interface for functions in the dunefunctions module.
Archive of Numerical Software, 5(1):95109, 2017.
This is freely available via the website of the journal and as arXiv:1512.06136 preprint. The interface for the function space bases is described in the article
C. Engwer, C. Gräser, S. Müthing, and O. Sander.
Function space bases in the dunefunctions module.
Preprint, arxiv:1806.09545, 2018.
This is freely available
as arXiv:1806.09545 preprint.
The LaTeX source code for both is also contained in the module.
Like the class documentation, it is build by make doc
.
Finally, the Dune book also contains a chapter on dunefunctions, which is, however, mainly an improved presentation of the two articles.
Examples
Several example applications demonstrate how to use the module. These
example applications are contained in the examples/
directory and
they are built with make examples
. The stokestaylorhood
example is
described in detail in the book.
Communication channels
dunefunctions development and discussions happen mainly on the dunefunctions GitLab page. There is also a dunefunctions mailing list, but it has very little traffic these days.
Using dunefunctions and licensing
The module is licensed by different variants of the GPL licence.
Please have a look at the COPYING
file for more information
and a list of all contributors. When using dunefunctions
please cite the publications on the
functions interface and the
bases interface listed above.
Building dunefunctions
Dunefunctions integrates into the cmake
based Dune build system.
Hence it can be build (like any other module) using the dunecontrol
script
of the dunecommon module. For details on how to use this build system
and how to specify build options have a look at the book or
the documentation in the dunecommon module.
Dependencies
Dunefunctions depends on the dune core modules and the dunetypetree module. All of them are available in major Linux distributions. If you want their source codes you can find them at:
 https://gitlab.duneproject.org/core/dunecommon
 https://gitlab.duneproject.org/core/dunegeometry
 https://gitlab.duneproject.org/core/dunegrid
 https://gitlab.duneproject.org/core/duneistl
 https://gitlab.duneproject.org/core/dunelocalfunctions
 https://gitlab.duneproject.org/staging/dunetypetree
Release of dunefunctions happen together with releases of the Dune core modules, and use the same numbering.
Unless explicitly stated otherwise for a specific version, dunefunctions supports/requires the same build tools (compilers, cmake) as the corresponding version of the core modules.
Maintainers
dunefunctions has been originally written by
 Christian Engwer
 Carsten Gräser
 Steffen Müthing
 Oliver Sander
Additionally, significant contributions came from Ansgar Burchardt, Simon Praetorius, and many others.
See the git history for a complete list.
We welcome interest and contributions by additional developers.