Download the Dune 2.7.0 module sources
- dune-common [ tarball: dune-common-2.7.0.tar.gz , signature: dune-common-2.7.0.tar.gz.asc ]
- dune-geometry [ tarball: dune-geometry-2.7.0.tar.gz , signature: dune-geometry-2.7.0.tar.gz.asc ]
- dune-grid [ tarball: dune-grid-2.7.0.tar.gz , signature: dune-grid-2.7.0.tar.gz.asc ]
- dune-grid-howto [ tarball: dune-grid-howto-2.7.0.tar.gz , signature: dune-grid-howto-2.7.0.tar.gz.asc ]
- dune-istl [ tarball: dune-istl-2.7.0.tar.gz , signature: dune-istl-2.7.0.tar.gz.asc ]
- dune-localfunctions [ tarball: dune-localfunctions-2.7.0.tar.gz , signature: dune-localfunctions-2.7.0.tar.gz.asc ]
DUNE 2.7 - Release Notes
Added fallback implementation to C++20 feature:
A helper class
TransformedRangeViewwas added representing a transformed version of a given range using an unary transformation function. The transformation is done on the fly leaving the wrapped range unchanged.
dune-commonnow provides an implementation of
std::variantfor all compilers that support C++14. It is contained in the file
dune/common/std/variant.hh, in the namespace
Dune::Std::. If your compiler does support C++17 the implementation in
dune-commonis automatically disabled, and the official implementation from the standard library is used instead.
By popular demand, dense vectors and matrices like
FieldMatrixnow have additional operators. In particular, there are
- Vector = - Vector
- Matrix = - Matrix
While these two work for any vector or matrix class that inherits from
DenseMatrix, the following additional methods only work for
- Vector = Scalar * Vector
- Vector = Vector * Scalar
- Vector = Vector / Scalar
FieldMatrixclass now has
- Matrix = Matrix + Matrix
- Matrix = Matrix - Matrix
- Matrix = Scalar * Matrix
- Matrix = Matrix * Scalar
- Matrix = Matrix / Scalar
- Matrix = Matrix * Matrix Note that the operators
- Vector = Vector + Vector
- Vector = Vector - Vector have been introduced earlier.
There is now (finally!) a method
powerin the file
math.hhthat computes powers with an integer exponent, and is usable in compile-time expressions. The use of the old power methods in
power.hhis henceforth discouraged.
FieldVectorare now trivially copyable types if the underlying field type is trivially copyable.
As a consequence the copy assignment operator of the
DenseVectorclass can no longer be used; just avoid going through
DenseVectorand use the real vector type instead (e.g.
Deprecations and removals
VectorSizehelper has been deprecated. The
size()method of vectors should be called directly instead.
Drop support for Python 2. Only Python 3 works with Dune 2.7.
Support for older version than METIS 5.x and ParMETIS 4.x is deprecated and will be removed after Dune 2.7.
dune/common/parallel/collectivecommunication.hhwhich will be removed after Dune 2.7. Use dune/common/parallel/communication.hh instead!
dune/common/parallel/mpicollectivecommunication.hhwhich will be removed after Dune 2.7. Use dune/common/parallel/mpicommunication.hh instead!
When run with an absolute build directory,
dunecontrolnow exposes the root build directory to CMake in the variable
dune_symlink_to_sources_filesCMake function now has a
Dune no longer applies architecture flags detected by the Vc library automatically. This applies to all targets that link to Vc explicitly (with
add_dune_vc_flags()) or implicitly (with
dune_enable_all_packages()). If you do want to make use of extended architecture features, set the architecture explicitly in the compiler options, e.g. by specifying
in your opts-file. Vc also sets compiler options to select a particular C++ abi (
-fabi-compat-version), these continue to be applied automatically.
FindParMETIS.cmakeassumes METIS was found first using
FindMETIS.cmakeand does not longer try to find METIS itself.
inkscape_generate_png_from_svgCMake function is deprecated and will be removed after 2.7.
LaTeX documents can now be built using
latexmkwith the help of UseLatexmk.cmake’s
dune_add_latex_documentwill use the new way of calling LaTeX when the first argument is
SOURCE. As a side effect, in-source builds are supported, too. The old function call and UseLATEX.cmake are deprecated and will be removed after 2.7.
The build system has learned some new tricks when creating or looking for the Python virtualenv: When using an absolute build directory with
dunecontrol, the virtualenv will now be placed directly inside the root of the build directory hierarchy in the directory
dune-python-env. This should make it much easier to actually find the virtualenv and also avoids some corner cases where the build system would create multiple virtualenvs that did not know about each other. This behavior can be disabled by setting
DUNE_PYTHON_EXTERNAL_VIRTUALENV_FOR_ABSOLUTE_BUILDDIR=0. If you need even more precise control about the location of the virtualenv, you can now also directly set the CMake variable
DUNE_PYTHON_VIRTUALENV_PATHto the directory in which to create the virtualenv.
The reference elements have a new method
subEntities. The result of
referenceELement.subEntities(i,codim, c)is an iterable range containing the indices of all codim-
csubentities of the subentity
(i,codim), e.g., the vertices of an edge. The range also provides the methods
GeometryType(unsigned int)have been deprecated and will be removed after the release of dune-geometry 2.7. Instead, please now use
GeometryTypes::cube(dim)to construct one- or two-dimensional
Geometry implementations now export a type
Volumethat is used for the return value of the
volumemethods. So does the generic
More efficient quadrature rules for simplices are available that need less quadrature points to achive the same order. For now these have to be explicitly requested:
auto&& rule = Dune::QuadratureRules<...>::rule(..., Dune::QuadratureType::GaussJacobi_n_0);
YaspGridclass has a new constructor that takes a
Coordinatesobject as its first argument. This object can be of type
TensorProductCoordinates, and encapsulates the domain and element sizes. Previously, this data was given directly to different constructors of
YaspGrid, and the constructor had to match the
Coordinatesobject used as the second template argument of the
YaspGridclass. The new constructor subsumes the previous three, and makes sure by design that the correct information is passed at
GridFactoryexports the type
Communicationand corresponding object
comm()that is used to create the grid. In the
GridFactoryInterface, this defaults to the Communication induced by the process-local communicator
UGGrid's factory returns the Communication of the grid. This can be used to steer the grid creation process, see
dune/grid/io/file/gmshreader.hhfor an example.
The number type used by a
BoundarySegmentis not hard-wired to
Grid::getRealImplementationmember function has been deprecated. Use the
impl()member function of the facade classes directly instead.
AlbertaGrid::getRealIntersectionmember function has been deprecated. Use the
impl()member function of the intersection class directly instead.
The return type of all file reader methods that return a grid has been changed from a plain C pointer to the custom pointer class
dune-commonmodule). Values of this pointer class cast to C pointers (but with a deprecation warning), to
std::unique_ptr, and to
std::shared_ptr. This marks the beginning of a transition period. In the long run, the methods are planned to return objects of type
std::unique_ptr, to make it obvious that the calling code receives the ownership of the grid object. For the time being the calling code can still store the return value in a C pointer, but that possibility will go away.
Likewise, the return type of the
GridFactory::createGridmethod has been changed from a plain C pointer to the custom pointer class
ToUniquePtr<Grid>. In the long run, the method is planned to return objects of type
std::unique_ptr, to make it obvious that the calling code receives the ownership of the grid object. For the time being the calling code can still store the return value in a C pointer, but that possibility will go away. While this procedure allows full backward compatibility for code that calls
GridFactory::createGrid, implementors or third-party grid implementations will need to update their implementations of
VTKWriters now support custom output data precision for functions (via the provided
VTKFunctions (via a new virtual interface method
precision()), and coordinates (via an argument to the writer’s constructor) that can be chosen at runtime. Any field can now choose between VTK’s
UInt32, represented as
DataArrayWriterselects the correct type at runtime. The default for functions and coordinate is
VTKWriternow supports writing functions that can only be evaluated globally, i.e., functions that are not defined with respect to the grid. Such functions will be sampled on the grid vertices (
addVertexData) or grid element centers (
hasBackupRestoreFacilities<GeometryGrid<HG, CoordFunction>>now returns
falsein case the
CoordFunctionis not default-constructible.
Geometryinterface now provides the type
Volumefor the return value of the method of the same name. Note that this may be different from
ctypeif you care about dimensions. In that case
ctypeis a length, and not appropriate for a quantity that is a volume.
VTKWriterwriter now truncates subnormal floating point values to 0 when writing ASCII files (
DUNE::VTK::ascii). This avoids Paraview crashes on macOS. For this reasons, most VTK files written by DUNE 2.7 will differ from the same file written in DUNE 2.6. If you are using VTK files for testing results, make sure to use fuzzy float comparisons!
VTKSequenceWriternow exposes the function
clear()of the associated
VTKSequenceWriterallows to get and set the time steps storage, which enables serialization of a sequence writer. The feature can be used to restart a sequence.
UG 3.x is no longer supported. Use dune-uggrid instead.
SolverFactoryfor generating sequential direct or iterative solvers and preconditioners from a
BDMatrixobjects now have the method
solve, which implements that canonical way to solve block-diagonal linear systems.
VariableBlockVector::CreateIteratoris a true STL output iterator now. This means that you can use STL algorithms like
std::copyto set the block sizes.
MultiTypeBlockVector<Args...>now inherits the constructors from its parent type (
std::tuple<Args...>). This means you can now also construct
MultiTypeBlockVectors from values or references of BlockVectors.
All matrix and vector classes can now be instantiated with number types directly (A number type is any type for which
Dune::IsNumber<T>::valueis true). For example, you can now use
BlockVector<double>instead of the more cumbersome
BlockVector<FieldVector<double,1> >. Similarly, you can use
BCRSMatrix<FieldMatrix<double,1,1>>. The old forms still work, and
FieldMatrixtypes with a single entry can still be cast to their
field_type. Therefore, the change is completely backward-compatible.
Added a right-preconditioned flexible restarted GMRes solver
The UMFPack binding use the long int functions to compute larger systems. With the *dl* versions instead of the *di* versions UMFPACK will not have a memory limit of just 2 GiB.
Support for SuiteSparse’s CHOLMOD providing a sparse Cholesky factorization.
The interface methods
norm()of ScalarProduct are now
const. You will have to adjust the method signatures in your own scalar product implementations.
MultiTypeBlockVectornow implements the interface method
N(), which returns the number of vector entries.
MultiTypeBlockVectornow implements the interface method
dim(), which returns the number of scalar vector entries.
SeqILUcan now be used with SIMD data types.
Deprecations and removals
Deprecated support for SuperLU 4.x. It will be removed after Dune 2.7.
Deprecated the preconditioner implementations
SeqILUinstead, which implements incomplete LU decomposition of any order.
OwnerOverlapCopyCommunicationis deprecated and will be removed after Dune 2.7. The solver category can only be set in the constructor.
MultiTypeBlockVector::count()has been deprecated, because its name is inconsistent with the name mandated by the
MultiTypeBlockMatrix::size()has been deprecated, because its name is inconsistent with the name mandated by the
lagrange.hhnow includes all headers of all Lagrange implementations, not just the ones with run-time order.
Introduce a run-time polymorphic container
LocalFiniteElementVariant. Much like
std::variant, it implements a type-safe union of different
LocalFiniteElementimplementations. Elements of type
LocalFiniteElementVariantcan hold one object from a list of types given as template parameters. These types must be implementations of the
LocalFiniteElementinterface, and the container will in turn implement this interface.
variant-based polymorphism is not as flexible as full type erasure, but it is much easier to implement. What is more, it is believed that in many situations the restriction to a fixed set of implementation types is not a problem.
Add support for
interpolate()implementations now support functions
fthat either support
y = f(x).
Add an implementation of the Crouzeix-Raviart element.
Add an implementation of the Brezzi-Douglas-Fortin-Marini element. The coefficients and interpolation are implemented for arbitrary dimension (>1) and order (>0). The actual basis is only implemented for dim=2 and order=1,2,3.
See core/dune-localfunctions!105 and core/dune-localfunctions!145
Introduce a convenience header
hierarchical.hhthat includes all hierarchical FE implementations.
Introduce a new class
LagrangeSimplexLocalFiniteElement, which implements Lagrange finite elements on simplices with compile-time dimension and order. It currently does not cover more general dimension/order situations than what is already available in dune-localfunctions, but it gathers the plethora of different Pk3DNodal, PkNodal, P1Nodal, etc implementations under one single name.
Introduce new class
BrezziDouglasMariniSimplexLocalFiniteElement(and the same for cubes) that subsumes all currently existing simplex BDM element implementations under a single name. Domain dimension and polynomial order are template parameters now.
Introduce a convenience header
dune/localfunctions/brezzidouglasmarini.hhthat includes all BDM implementations.