OONumerics User : |
From: Markus Blatt (Markus.Blatt_at_[hidden])
Date: 2007-12-20 14:43:43
We are pleased to announce the release of Version 1.0 of the
"Distributed and Unified Numerics Environment" (DUNE).
DUNE is a modular toolbox for solving partial differential equations (PDEs)
with grid-based methods. It supports the easy implementation of methods
like Finite Elements (FE), Finite Volumes (FV), and also Finite
Differences (FD).
DUNE is free software licensed under the GPL (version 2) with a
so-called "runtime exception". This licence is similar to the one under
which the libstdc++ libraries are distributed. Thus it is possible to
use DUNE even in proprietary software.
For further information, have a look at our website
http://www.dune-project.org
The underlying idea of DUNE is to create slim interfaces allowing an efficient
use of legacy and/or new libraries. Modern C++ programming techniques
enable very different implementations of the same concept (i.e. grids,
solvers, ...) using a common interface at a very low overhead. Thus
DUNE ensures efficiency in scientific computations and supports
high-performance computing applications.
DUNE is based on the following main principles:
- Separation of data structures and algorithms by abstract interfaces:
This provides more functionality with less code and also ensures
maintainability and extendability of the framework.
- Efficient implementation of these interfaces using generic programming
techniques:
Static polymorphism allows the compiler to do more optimizations, in
particular function inlining, which in turn allows the interface to
have very small functions (implemented by one or few machine
instructions) without a severe performance penalty. In essence the
algorithms are parametrized with a particular data structure and the
interface is removed at compile time. Thus the resulting code is as
efficient as if it would have been written for the special case.
- Reuse of existing finite element packages with a large body of functionality:
In particular the finite element codes UG, ALBERTA, and ALUGrid have
been adapted to the DUNE framework. Thus, parallel and adaptive meshes
with multiple element types and refinement rules are available. All
these packages can be linked together in one executable.
The framework consists of a number of modules which are downloadable
as separate packages. The current core modules are:
dune-common
-----------
contains the basic classes used by all DUNE-modules. It provides some
infrastructural classes for debugging and exception handling as well
as a library to handle dense matrices and vectors.
dune-grid
---------
defines nonconforming, hierarchically
nested, multi-element-type, parallel grids in arbitrary space
dimensions. Graphical output with several packages is available,
e.g. file output to IBM data explorer and VTK (parallel XML format for
unstructured grids). The graphics package Grape has been integrated in
interactive mode.
dune-istl (Iterative Solver Template Library)
---------
provides generic sparse matrix/vector classes and a variety of solvers
based on these classes. A special feature is the use of templates to
exploit the recursive block structure of finite element matrices at
compile time. Available solvers include Krylov methods, (block-)
incomplete decompositions and aggregation-based algebraic multigrid.