1. 26 Jun, 2018 1 commit
  2. 14 Jun, 2018 2 commits
    • Carsten Gräser's avatar
      Switch default node-to-range-map to HierarchicNodeToRangeMap · 7a17f787
      Carsten Gräser authored
      This is a non-compatible interface change. If you used a range
      on a nontrivial (depth>1) tree, this will not work as before,
      because the range entries are lo nonger accessed using a flat
      index. (But this is very unlikely.)
      As long as you only used power<...> or composite<...> in a non-nested
      way, the behaviour should still be the same.
    • Carsten Gräser's avatar
      Pass treepath to node to range map · db863cea
      Carsten Gräser authored
      In general using the treepath is more natural here.
      While the node stores its treepath this is very likely
      to be removed soon, since in any place where you need
      the treepath it's available by other means (e.g. during
      tree traversal).
      Notice that this is an interface change! If you have
      implemented your own node-to-range map, you will have
      to add the additional parameter to operator().
      At a later stage one may also want to drop the node argument.
      However, it's not totally clear if this is needed in custom
  3. 07 Jun, 2018 1 commit
  4. 27 Apr, 2018 1 commit
  5. 25 Apr, 2018 1 commit
  6. 18 Apr, 2018 1 commit
  7. 17 Apr, 2018 1 commit
  8. 22 Mar, 2018 1 commit
    • Carsten Gräser's avatar
      [cleanup] Get rid of compiler warnings · 417f8be3
      Carsten Gräser authored
      * Remove some unused local typedefs
      * Mark unused values/typedefs in tests by DUNE_UNUSED
      * Use double braces {{ }} in array initialization to
        calm down clang (altough { } is correct here in c++11 and c++14).
  9. 07 Mar, 2018 1 commit
    • Carsten Gräser's avatar
      [cleanup] Hide FlatVectorBackend in favour of flatVectorView() · a30be1c8
      Carsten Gräser authored
      * Hide the old implementation class FlatVectorBackend in
        namespace Impl::. It was never documented anyway.
      * Add a new class FlatVectorView. In contrast to the old one,
        this behaves like a (view-) value providing a very slim
        flat-vector-like interface instead of odd static methods.
      * To be flexible FlatVectorView is also hidden in Impl::
        Instead we only expose factory methods:
      * Add factory methods flatVectorView() creating the view
        objects. When passing a const/mutable l-value reference
        the returned object will store a pointer to the underlying
        container. If the passed container is an r-value reference
        the object will be stored by value inside of the view.
        This is necessary to support proxy objects.
  10. 08 Sep, 2017 1 commit
  11. 07 Sep, 2017 1 commit
    • Carsten Gräser's avatar
      Forbid creation of LocalFunction from temporary · 1871381c
      Carsten Gräser authored
      Since the LocalFunction stores a pointer to the
      DiscreteGlobalBasisFunction, calling localFunction(...)
      with a temporary leads to a dangling reference.
      This happens, e.g., when passing a temporary
      DiscreteGlobalBasisFunction to VTKWriter::addVertexData(...)
      because the latter does not store its argument, but
      only the obtained LocalFunction.
      Thanks to @max.kahnt for pointing out the issue.
  12. 06 Sep, 2017 2 commits
  13. 10 Nov, 2016 1 commit
  14. 02 Apr, 2016 1 commit
  15. 01 Apr, 2016 1 commit
    • Carsten Gräser's avatar
      Generalize makeDiscreteGlobalBasisFunctional() · d23668a9
      Carsten Gräser authored
      Using the new Dune::wrap_or_move() we can uniformly pass
      R- or L-value references for the basis or the vector. As
      a consequence you can now also pass a temporary basis
      (e.g. the result of subspaceBasis())
  16. 03 Mar, 2016 2 commits
  17. 09 Oct, 2015 1 commit
    • Carsten Gräser's avatar
      [doc] Improve doc · 4a53c5a3
      Carsten Gräser authored
      Tag classes for doc-modules, hide default unused default implemantion,
      fix doc text
  18. 07 Oct, 2015 1 commit
  19. 21 Sep, 2015 1 commit
  20. 18 Sep, 2015 1 commit
  21. 16 Sep, 2015 1 commit
    • Carsten Gräser's avatar
      Add DiscreteGlobalBasisFunction · 6130018e
      Carsten Gräser authored
      This now supports multicomponent functions in different flavors
      * nontrivial subtrees representing e.g. vector fields
      * implicit product spaces induced by vector-valued coefficients
      * vector-valued ansatz functions
      Of course combinations of those are also possible, as long as
      this can be mapped to the vector backend. Due to this flexibility
      the range type has to be specified explicitly because there is
      no longer a 'natural' one.
      This class requires that the vector type accepts multi-indices.
      For simple bases using FlatMultiIndex a simple BlockVector already
      does this. For more complicated cases with nested indices you may
      have to use a HierarchicVectorWrapper.
      To simplify creation of such functions there is a free function
      to be used like this
        auto f = makeDiscreteGlobalBasisFunction<Range>(basis, treePath, vector);
      Notice that it will capture r-value references for vector
      such that you can use
        auto f = makeDiscreteGlobalBasisFunction<Range>(basis, treePath, hierarchicVector(vector));
      if you need a HierarchicVectorWrapper due to nested indices.
      The only difference to DiscreteScalarGlobalBasisFunction
      is that you must specify the range type manually. However,
      in simple   cases (scalar function) this is as easy as
      adding <double> to the factory function call.
      Things to be done:
      * Swap the order of treePath and vector argument and
        provide an empty treePath as default.
      * Optimize implementation
        * Don't allocate result vectors for localBasis::evaluate
          on each evaluation, but store preallocated ones per node.
        * Don't collect coefficients on each evaluation but
          copy them once on bind and cache them.
      * Drop DiscreteScalarGlobalBasisFunction