1# Release 2.8 2 3* Passing functions that support `f.evaluate(x,y)` to `interpolate()` 4 is deprecated. Instead the functions should now provide `operator()`. 5 Passing functions providing the old interface is still supported in 2.8. 6 * `LocalFiniteElementFunctionBase` is deprecated. You can rely 7 on duck-typing when passing functions with the new interface. 8 * The virtual interface for interpolating functions in `LocalFiniteElementVirtualInterface` 9 now uses `std::function` instead of the deprecated `VirtualFunction` 10 for the passed function. 11 * The virtual interface wrapper `LocalFiniteElementVirtualImp` now 12 requires that the wrapped `LocalFiniteElement` implementation 13 supports the new `operator()` based interpolation interface. 14 15* Add an implementation of the Nédélec element of the first kind, 16 as introduced in "Nédélec, Mixed finite elements in R^3, 1980, 17 DOI: http://dx.doi.org/10.1007/BF01396415". 18 Only the first-order case for triangles, tetrahedra, squares and cubes is implemented. 19 20* Fix a bug in a shape function of the second-order Lagrange element 21 on the three-dimensional pyramid. 22 23* Add an implementation of the Raviart-Thomas element for tetrehedra with order 0. 24 25* Remove deprecated `GenericLocalFiniteElement::topologyId()`, use 26 `type().id()` instead. 27 28* Imported the Python bindings from the 2.7 branch of dune-python. 29 30* Replaced the combination of function arguments `topologyId` and `dim` with a single `GeometryType` argument. 31 Tagged the old versions of: `numLagrangePoints`, `equidistantLagrangePoints`, `RTL2InterpolationBuilder::topologyId()`, 32 `VirtualMonomialBasis(topologyId)`, `VirtualMonomialBasis::topologyId()` as deprecated. 33 34* Add a construction algorithm for high order Nédélec elements on triangles and tetrahedra. 35 36# Release 2.7 37 38* The header `lagrange.hh` now includes all headers of all Lagrange implementations, 39 not just the ones with run-time order. 40 41* Introduce a run-time polymorphic container `LocalFiniteElementVariant`. 42 Much like `std::variant`, it implements a type-safe 43 union of different `LocalFiniteElement` implementations. Elements of type 44 `LocalFiniteElementVariant` can hold one object from a list of types 45 given as template parameters. These types must be implementations of 46 the `LocalFiniteElement` interface, and the container will in turn 47 implement this interface. 48 49 Such a `variant`-based polymorphism is not as flexible as full type erasure, 50 but it is much easier to implement. What is more, it is believed that in 51 many situations the restriction to a fixed set of implementation types 52 is not a problem. 53 54* Add support for `operator()` syntax to `interpolate()`. All `interpolate()` 55 implementations now support functions `f` that either support `f.evaluate(x,y)` 56 or `y = f(x)`. 57 58* Add an implementation of the Crouzeix-Raviart element. 59 60* Add an implementation of the Brezzi-Douglas-Fortin-Marini element. 61 The coefficients and interpolation are implemented for arbitrary 62 dimension (>1) and order (>0). The actual basis is only implemented 63 for dim=2 and order=1,2,3. 64 65 See core/dune-localfunctions!105 and core/dune-localfunctions!145 66 67* Introduce a convenience header `hierarchical.hh` that includes 68 all hierarchical FE implementations. 69 70* Introduce a new class `LagrangeSimplexLocalFiniteElement`, which implements 71 Lagrange finite elements on simplices with compile-time dimension and order. 72 It currently does not cover more general dimension/order situations than 73 what is already available in dune-localfunctions, but it gathers the 74 plethora of different Pk3DNodal, PkNodal, P1Nodal, etc implementations 75 under one single name. 76 77* Introduce new class `BrezziDouglasMariniSimplexLocalFiniteElement` 78 (and the same for cubes) that subsumes all currently existing simplex 79 BDM element implementations under a single name. Domain dimension and 80 polynomial order are template parameters now. 81 82* Introduce a convenience header `dune/localfunctions/brezzidouglasmarini.hh` 83 that includes all BDM implementations. 84 85# Release 2.6 86 87* The `diffOrder` value has disappeared from the `LocalBasisTraits` class. 88 This value encoded the highest partial derivative order implemented by 89 a local basis. Encoding this value as a compile-time parameter led to 90 various problems related to the dynamic interface, mainly because it 91 became part of the type of the local finite element. At the same time, 92 it was suspected that very few people ever actually used the parameter. 93 94 More practically, two things have disappeared: the `diffOrder` member 95 of the `LocalBasisTraits` class, and the 8th template parameter `dorder` 96 of that class. There is no replacement, and if you have used `diffOrder` 97 then you currently have to find a way to live without it. As mentioned 98 we believe that this concerns only a very small number of people. 99 100 If you do use `diffOrder` and you absolutely need it or something similar, 101 then we'd like to hear from you. One of the reasons why there is no 102 replacement is that we couldn't really think of a good use case to begin with. 103 104* The `QkLocalFiniteElement` class implements second partial derivatives 105 of shape functions now. 106 107* The `clone()` method was removed from the raw (non-virtual) `LocalFiniteElement` 108 implementations. If you want to copy a `LocalFiniteElement` in a portable 109 way which works for raw implementations as well as for the virtual interface 110 class, you have to replace `lfe.clone()` by 111 `Dune::LocalFiniteElementCloneFactory<LFEType>::clone(lfe)`. 112