CHANGELOG.md

Master (will become release 2.11)

Release 2.10

• Quadrature point now allows C++ structured bindings so that numerical integrations are less verbose:

  for(auto [position, weight] : Dune::QuadratureRules</*...*/>::rule(/*...*/))
    result += f(position) * weight;

• Dune::Geo::ReferenceElement methods that have returned references, return by value. This affects type(), position(), and integrationOuterNormal().

• Add a meta-geometry type MappedGeometry that represents the chaining of another geometry and a callable.

• AffineGeometry and AxisAlignedGeometry are now default constructible. A default construction results in an "empty"/invalid geometry that can be assigned a valid geometry.

• Add a geometry LocalFiniteElementGeometry parametrized by local finite-element basis functions.

Deprecations and removals

• Dune::Transitional::ReferenceElement is deprecated and will be removed after Dune 2.10. Use Dune::Geo::ReferenceElement directly.

• Remove header deprecated_topology.hh that was introduced for transition.

• Remove deprecated functions factorial() and binomial(). Use the functions from dune-common's math.hh.

Release 2.9

• The Geometry interface was extended by methods jacobian(local) and jacobianInverse(local) and corresponding typedefs Jacobian and JacobianInverse. This is implemented by all geometry implementations provided by dune-geometry. But external implementations need to be adjusted to pass the interface check provided by checkgeometry.hh.

• The Geometry::integrationElement now needs to return the type Volume instead of ctype. Note that this may be different from ctype if the geometry supports typed dimensions. In such case, ctype is a length, and not appropriate for a volume quantity.

Release 2.8

• Python bindings have been moved from the dune-python module which is now obsolete. To activate Python bindings the CMake flag DUNE_ENABLE_PYTHONBINDINGS needs to be turned on (default is off). Furthermore, flags for either shared library or position independent code needs to be used.

• The class AxisAlignedCubeGeometry has always had a constructor taking two arguments FieldVector<ctype,coorddim> lower and FieldVector<ctype,coorddim> upper. This constructor was always to be used in the case dim==coorddim only, but this was never enforced. Starting with version 2.8, compilation fails with an error message if this constructor is used with dim!=coorddim.

• Two new sets of quadrature rules are provided: the left and right Gauss-Radau quadrature rules. These are optimal rules that include only one endpoint of the integration interval (either left or right) and integrate polynomials of order 2n - 2 exactly.

• GeometryType has four new methods: isPrismatic(), isPrismatic(int step) and isConical(),isConical(int step). The versions with an argument return true if the corresponding construction was used in step 0 <= step <=dim-1. The other two assume a default argument of dim-1 (the latest construction step).

• GeometryTypes has two new methods: prismaticExtension(GeometryType gt) and conicalExtension(GeometryType gt). They return an extended GeometryType based on gt via the corresponding construction. For example:

  GeometryType gt = GeometryTypes::line;
  auto square = GeometryTypes::prismaticExtension(gt);
  auto triangle = GeometryTypes::conicalExtension(gt);

Deprecations and removals

• Remove code needed to use reference elements by reference.

• Remove GeometryType's deprecated member functions GeometryType::make...().

• Remove deprecated constructor GeometryType(unsigned dim).

• Remove deprecated CompositeQuadratureRule(QuadratureRule, int). Use CompositeQuadratureRule(QuadratureRule, Dune::refinement{Intervals|Levels}(int)) instead.

• Removed all structs from Impl dealing with the recursive topology construction: TopologyFactory, TopologySingletonFactory, Point, Prism, Pyramid, IsSimplex, IsCube, SimplexTopology, CubeTopology, PyramidTopology, PrismTopology, IfTopology. Deprecated the free function Impl::isTopology. Use the geometries provided by GeometryType and GeometryTypes instead. To simplify the transition you can include the header "dune/geometry/deprecated_topology.hh".

Release 2.7

• 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-c subentities of the subentity (i,codim), e.g., the vertices of an edge. The range also provides the methods size() and contains().
• The methods GeometryType(int) and 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 GeometryType objects.
• Geometry implementations now export a type Volume that is used for the return value of the volume methods. So does the generic ReferenceElement implementation.
• More efficient quadrature rules for simplices are available that need less quadrature points to achieve the same order. For now these have to be explicitly requested:

  auto&& rule = Dune::QuadratureRules<...>::rule(..., Dune::QuadratureType::GaussJacobi_n_0);

  See !127.

Release 2.6

• The enum GeometryType::BasicType is deprecated, and will be removed after Dune 2.6.

• VirtualRefinement and Refinement now support arbitrary refinements, not just powers of two. Wherever you where passing a parameter int levels (now deprecated), you should now pass a parameter RefinementIntervals intervals. There are convenience functions refinementIntervals(int intervals) and refinementLevels(int levels) to construct parameters of type RefinementIntervals.

  See core/dune-geometry!51

• The class GeometryType has been cleaned up in major way:

  See core/dune-geometry!64 and core/dune-geometry!55

  • The class and most of its methods are now constexpr.

  • There are new singletons and factory functions in the namespace Dune::GeometryTypes. These are now the official way to obtain a GeometryType.

  • The constructor taking a GeometryType::BasicType and a dimension has been deprecated and will be removed after the release of DUNE 2.6.

  • The assorted member functions GeometryType::make...() have been deprecated and will be removed after the release of DUNE 2.6.

• The reference element interface has had a substantial overhaul that can break backwards compatibility in some corner cases.

  See core/dune-geometry!52

  • ReferenceElement has value semantics now: You should store instances by value and can freely copy them around. Doing so is not more expensive than storing a const reference.

  • As a consequence of value semantics, ReferenceElement is default constructible now. A default constructed ReferenceElement may only be assigned another ReferenceElement; all other operations cause undefined behavior. Moreover, instances are now comparable and hashable to allow storing them in maps.

  • We have added code that tries to warn you if you are still storing a ReferenceElement by const reference; please update all those occurrences.

  • The meaning of Dune::ReferenceElement has changed. It is not a type anymore, but an alias template that looks up the correct implementation for the given template arguments. For now, there is only a single implementation, but we expect people to come up with additional implementations in the future. For this reason, the syntax Dune::ReferenceElement<ctype,dim> is deprecated and will cause compilation failures in the future. If you still need access to that type, use typename Dune::ReferenceElements<ctype,dim>::ReferenceElement instead.

  • You can now directly obtain a reference element for a given geometry using the free function referenceElement(geometry). This function should be called without any namespace qualifiers to enable ADL and you should normally capture the return value of the function using auto, but if you need to explicitly access the type, this is also available as Dune::ReferenceElement<Geometry>.

    In short: If you can, use the following idiom to obtain a reference element for a geometry:

    auto ref_el = referenceElement(geometry);

    The change to the meaning of Dune::ReferenceElement can break compilation if you have function overloads that partially specialize on it, e.g.

    template<typename ctype, int dim>
    void f(const Dune::ReferenceElement<ctype,dim> ref_el)
    {}

    Normally, you can just simplify this to the following code that also shows how to extract the missing template parameters:

     template<typename RefEl>
     void f(const RefEl ref_el)
     {
       using ctype = typename RefEl::CoordinateField;
       constexpr auto dim = RefEl::dimension;
     }