DUNE, the Distributed and Unified Numerics Environment supports the easy implementation of methods like Finite Volumes (FV), Finite Elements (FE) and also Finite Differences (FD).
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: is the most mature module. It 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.
Here are some key features of "DUNE":
Grid Implementation:
· SGrid: A structured grid in n space dimensions
· YaspGrid: A structured parallel grid in n space dimensions
· UGGrid: The grid manager of the UG toolbox
· AlbertaGrid: The grid manager of the Alberta toolbox
· OneDGrid: A sequential locally adaptive grid in one space dimension
· ALUSimplexGrid, ALUCubeGrid: A hexahedral, tetrahedral, and triangular grid with nonconforming refinement including parallelization with dynamic load-balancing.
Linear Algebra:
· Abstractions for block matrices (e.g. compressed row storage and block diagonal) and block vectors
· Block structure arbitrarily nestable
· High performance through generic programming
· Expression templates for BLAS1 routines
· Several standard solvers
Quadrature Formulas:
· Quadrature rules for all common element types
· Rules for hypercubes up to order 19, for simplices up to order 12
· Easy access
Shape Functions:
· Lagrangrian shape functions of up to second order
· Monomial shape functions of arbitrary order for Discontinous Galerkin methods
· Orthonormal shape functions of up to eigth order
Input/Output:
· Visualization using GRAPE
· Output in Data Explorer format
· Reading and writing in the AmiraMesh format
· Reading grid files in the grid independent Dune grid format DGF
· Reading simplex grids through DGF constructed using the tools Tetgen and Triangle
· Subsampling of high-order functions
· Write grids and data in the format of the visualization toolkit (vtk)
What's New in This Release: [ read full changelog ]
Build system:
· Fixed test for support of __attribute__((unused))
· Support for automake 1.13 (FS 1243)
· Made dunecontrol faster
· dunecontrol can handle multiple installed dune-common modules (FS 1250)
· dunecontrol has better support for suggestions
· Build system finds ParMETIS 4.0.2 (FS 1163)
· Out-of-source builds of the documentation are supported now.
dune-common:
· Fixed warnings about unused typedefs.
· More standard compliant shared_ptr implementation usable with gcc-4.1.
· More standard compliant nullptr implementation
· Fixed illegal forward declaration of std::pair (FS 1121)
· Fixed infinity norm of NaN matrices (FS 1147)
· The infinity_norm of a DenseVector returns NaN if one of its entries is NaN (FS 1147)
· Improved support for clang compiler
dune-geometry:
· Improved support for clang compiler
· Fixed compilation for zero-dimensional grids
dune-grid:
· Better support for clang
· Detect and support alberta grid configured with -...
Find us on Google+
