1. 06 Jul, 2022 1 commit
  2. 30 Jun, 2022 1 commit
  3. 23 Jun, 2022 3 commits
    • Carsten Gräser's avatar
      Improve multi index in global basis · c3c3c2e9
      Carsten Gräser authored
      * We now separate the stored and exported multi index type
        `MultiIndexStorage` and `MultiIndex` in the `LocalView`.
      * `MultiIndexStorage` will always have dynamic size and may need
        a larger capacity compared to `MultiIndex`s size.
      * If it is clear that the multi indices generated by the `PreBasis`
        have a static length, the`MultiIndex` has static size, while
        the `MultiIndexStorage` is an `OverflowArray<MultiIndex, ...>`.
        Otherwise the `MultiIndex` is a `ReservedVector`.
      * If the size of multi indices is guaranteed to be one, then the
        `MultiIndex` can be cast to the plain index to avoid using `[0]`
        in simple cases.
    • Carsten Gräser's avatar
      Add StaticMultiIndex · 0dfb9269
      Carsten Gräser authored
      This represents a statically sized multiindex.
      It adds a static `size()` methods and a cast to the first
      entry for `size()==1`.
      `FlatMultiIndex<T>` is now an alias for `StaticMultiIndex<T,1>`.
    • Carsten Gräser's avatar
      Add OverflowArray · 350e74f9
      Carsten Gräser authored
      It mostly behaves like `Dune::ReservedVector` but derives from a statically
      sized array base class. This allows to have temporary dynamic size but cast
      to the result to the statically sized base class.
  4. 15 Jun, 2022 1 commit
  5. 22 Feb, 2022 1 commit
  6. 08 Nov, 2021 1 commit
    • Carsten Gräser's avatar
      Add FaceNormalGridFunction · 10f694c7
      Carsten Gräser authored
      This implements element normals as (discontinuous) grid function.
      When evaluated at a point `x` of an element `e`, it computes the
      unit outward normal of the 'closest face' of this element.
      * The 'closes face' is determined in local coordinates within the
        reference elements.
      * The implementation also works for curved faces, since the normal
        of the real element is computed using the (potentially non-constant)
        covariant Piola transformation of the (constante) normal in the
        reference element.
      * Notice that the function is an L^2 function in general. It is
        defined piecewise with non-unique value on intersections.
        On elements, with affine geometries, it is piecewise constant.
      * This also adds a test checking for consistency with
        `intersection.unitOuterNormal()` when restricting the function
        to `intersection`. A grid with distorted cubes serves as test case
        for non-constant normals.
      * This satisfied the standard grid function interface. Extending this
        to an interface for skeleton functions to be bound on intersections
        may be interesting. But such an interface was not defined so far.
  7. 31 Oct, 2021 1 commit
    • Carsten Gräser's avatar
      Avoid nesting of SubspaceBasis by resolving nested ones · 0af75344
      Carsten Gräser authored
      While it was technically allowed and possible to construct a nested
      `SubspaceBasis` this is often not intended. This patch avoids such
      nesting by joining the inner and outer `prefixPath` and applying it
      to the root of the root.
      This also adds deduction guids such that subspaceBasis() and
      SubspaceBasis() yield the same result.
  8. 12 Oct, 2021 1 commit
  9. 05 Oct, 2021 1 commit
  10. 16 Sep, 2021 1 commit
  11. 31 Aug, 2021 2 commits
  12. 13 Aug, 2021 1 commit
  13. 15 Jul, 2021 1 commit
  14. 13 Jul, 2021 1 commit
  15. 09 Jul, 2021 1 commit
    • Oliver Sander's avatar
      Introduce PeriodicBasis · 3ae8ae10
      Oliver Sander authored
      PeriodicBasis is a meta basis---a basis that is parametrized
      with another basis.  In a PeriodicBasis, global degrees of freedom
      of the host basis can be grouped into equivalence classes,
      which are then treated as single global degrees of freedom by the
      PeriodicBasis.  This allows, in particular, to implement periodic
      boundary conditions for discretizations without intersection
      As there was some controversy about whether such a basis is really
      needed the implementation is in the namespace
      Dune::Functions::Experimental for now.  That will the code some
      more exposure.
      Thanks go to Carsten Gräser, who wrote a lot of code in this commit.
  16. 30 Apr, 2021 1 commit
  17. 29 Mar, 2021 1 commit
  18. 11 Mar, 2021 1 commit
  19. 12 Feb, 2021 1 commit
  20. 06 Dec, 2020 1 commit
  21. 13 Oct, 2020 1 commit
    • Oliver Sander's avatar
      Implement a Nedelec basis (of the first kind) · a6a0c1e9
      Oliver Sander authored
      This patch adds the implementation of a Nedelec basis.  The interface
      allows bases of any order, grids in 2d and 3d, and with simplex and cube elements.
      However, this initial implementation can only do the first-order basis
      on triangle grids.
      There are two types of Nedelec bases, known as the Nedelec bases of the
      first and second kind.  The implementation in this patch has the 'kind'
      as a template parameter, which can have values 1 or 2.  However, only
      the case kind==1 is implemented right now.
  22. 09 Oct, 2020 2 commits
  23. 13 Apr, 2020 2 commits
    • Oliver Sander's avatar
    • Oliver Sander's avatar
      Make the Raviart-Thomas basis apply the Piola transform · df4cf203
      Oliver Sander authored
      We do this by introducing a new LocalFiniteElement implementation
      called GlobalValuedLocalFiniteElement.  This new implementation wraps
      existing LocalFiniteElement implementations, but applies a
      transformation to the evaluated shape function values (and
      derivatives etc.).  The transformation is a template parameter
      and can be replaced.  Currently only the contravariant Piola transform
      (for H(div) spaces) is implemented.
      Note that while this patch updates the poisson-mfem example,
      the example nevertheless produces a slightly different result now.
      The reason is that the example uses the 'interpolate' method,
      which did not return the correct values for Raviart-Thomas elements
      before this patch.
  24. 20 Dec, 2019 1 commit
  25. 07 Sep, 2019 1 commit
  26. 14 Mar, 2019 1 commit
    • Oliver Sander's avatar
      Implement LagrangeBasis with run-time order · 76ba7a1a
      Oliver Sander authored
      This patch extends the LagrangeBasis class to also allow to select
      the polynomial order at run-time.  For this, the integer template
      parameter 'k' (the order) is made optional, with a default value of -1.
      If k is explicitly set to something non-negative, then the basis
      implementation behaves as before.  If k is indeed -1 then the basis
      object needs to be constructed by a new constructor that accepts
      a run-time order.
      The changes to LagrangeBasis are completely backward-compatible.
      I did not do any measurements of the performance, but as the switch
      between run-time and compile-time order is based on a simple
      compile-time criterion I expect decent compilers to optimize away
      all new code if a compile-time order is selected.
  27. 01 Oct, 2018 2 commits
  28. 18 Jun, 2018 1 commit
  29. 01 May, 2018 3 commits
  30. 12 Apr, 2018 1 commit
  31. 08 Mar, 2018 2 commits
    • Carsten Gräser's avatar
      Update module information · 879248fa
      Carsten Gräser authored
      * Bump version to 2.7-git
      * Bump required core module requirements to corresponding version
      * Explicitly list dune-geometry dependence with version.
        Otherwise we may end up with an outdated version due
        to the sloppy dune-grid requirements.
      * Depend on dune-istl. Its used in the tests for some time.
      * Update changelog and adjust its layout
      * Use dune-functions mailing list as maintainer information
    • Carsten Gräser's avatar