Dune is a modular toolbox for solving partial differential equations with grid-based methods such as finite elements, finite volumes, and finite differences. It uses a generic grid interface that connects different grid implementations and supports applications for high performance computing. Dune is based on separating data structures from algorithms through abstract interfaces to provide functionality with less code, and it leverages modern C++ techniques and existing finite element packages. The framework consists of core modules and various add-on modules that can be downloaded and used individually or together.

1. Introduction Dune.
Dune (Distributed and Unified Numerics Environment) is a modular toolboy for solving partial
differential equations (PDEs) with grid-based methods. It supports the easy implementation of
methods like Finite Elements (FE), Finite Volume (FV) and also Finite Differences (FD). Dune is a
useful tool to create 3D configurators in Realtime.
Dune is a free software, which is licensed under GPL (Version 2) with a so called “Runtime
Exception”. This license is comparable to the one under which the libstdc++ libraries are
distributed. So it is possible to use DUNE also in proprietary software.
The basic idea of Dune is to create slim interfaces, which allow an efficient use of existing and/or
new libraries. Modern C++ programming techniques allow very different implementations of the
same concept over a common interface with very little effort. Thus Dune provides efficiency in
scientific calculations and supports applications for high performance computers.
Special highlights are:
• a generic grid interface, which allows to connect a number of very different grid
implementations.
• The iterative Solver Template Library, which contains an algebraic multigrid preconditioner.
• High-quality interfaces for experimental and test functions and generic discretization
modules.
• Python binding for the full-grid interface and a flexible concept for connecting user
modules.
Dune is based on the following basic principles:
• Separation of data structures and algorithms by abstract interfaces. This offers more
functionality with less code and also guarantees the maintainability and extensibility of the
framework.

2. • Efficient implementation of these interfaces by generic programming techniques. The static
polymorphism allows the compiler to make further optimizations, especially function
inlining, which in turn allows the interface to have very small functions (implemented by
one or a few machine instructions) without serious performance degradation. Essentially, the
algorithms are parameterized with a specific data structure and the interface is removed at
compile time. Thus, the resulting code is as efficient as if it had been written for the specific
case.
• Reuse of existing finite element packages with great functionality. Especially the finite
element codes UG, ALBERTA and ALUGrid were adapted to the Dune framework. Thus,
parallel and adaptive grids with multiple element types and refinement rules are available.
All these packages can be linked together in an executable file.
Modules.
The framework consists of a number of modules that can be downloaded as separate packages.
There are a number of core modules that are used by most other packages. The core module Dune-
Grid already contains some grid implementations and more grid managers are available as add-on
modules. Main discretization modules, which provide the infrastructure for solving partial
differential equations with Dune, are available as separate modules. The modular structure of Dune
allows to use only a small part of the modules (e.g. only the solver module Dune-istl or the module
Dune-localfunctions with form functions, without using e.g. the Dune-Grid or a Full Discretization
module).
Thank you very much for your visit.