ConstantGridFunction.hpp 4.99 KB
Newer Older
Praetorius, Simon's avatar
Praetorius, Simon committed
1
2
3
4
5
6
7
8
9
10
#pragma once

#include <functional>
#include <type_traits>

#include <dune/common/diagonalmatrix.hh>
#include <dune/common/fmatrix.hh>
#include <dune/common/fvector.hh>
#include <dune/functions/common/defaultderivativetraits.hh>

11
12
13
#include <amdis/common/Utility.hpp>
#include <amdis/gridfunctions/AnalyticGridFunction.hpp>
#include <amdis/gridfunctions/GridFunctionConcepts.hpp>
Praetorius, Simon's avatar
Praetorius, Simon committed
14
15
16

namespace AMDiS
{
17
  /// \brief LocalFunction of a Gridfunction returning a constant value.
18
19
20
21
22
  template <class Signature, class LocalContext, class Function>
  class ConstantLocalFunction;

  template <class R, class D, class LocalContext, class T>
  class ConstantLocalFunction<R(D), LocalContext, T>
Praetorius, Simon's avatar
Praetorius, Simon committed
23
  {
24
25
26
27
28
29
  public:
    using Range = R;
    using Domain = D; // LocalDomain

    using Geometry = typename LocalContext::Geometry;

30
31
    enum { hasDerivative = true };

32
33
34
35
36
37
38
39
40
41
42
43
44
45
  public:
    ConstantLocalFunction(T const& value)
      : value_(value)
    {}

    void bind(LocalContext const& /*element*/) {}

    void unbind() {}

    Range const& operator()(Domain const& /*local*/) const
    {
      return value_;
    }

46
47
48
49
50
51
52
53
54
    auto derivative() const
    {
      using RawSignature = typename Dune::Functions::SignatureTraits<R(D)>::RawSignature;
      using DerivativeRange = typename Dune::Functions::DefaultDerivativeTraits<RawSignature>::Range;
      DerivativeRange diff(0);
      return ConstantLocalFunction<DerivativeRange(D),LocalContext,DerivativeRange>{diff};
    }

    int order() const
55
56
57
58
59
60
61
62
    {
      return 0;
    }

  private:
    T value_;
  };

63
64
65
66
  /// \relates ConstantLocalFunction
  template <class R, class D, class LocalContext, class T>
  auto derivative(ConstantLocalFunction<R(D), LocalContext, T> const& lf)
  {
67
    return lf.derivative();
68
69
  }

70
71
72
73
74
75
76
77
  /// \relates ConstantLocalFunction
  template <class R, class D, class LocalContext, class T>
  int order(ConstantLocalFunction<R(D), LocalContext, T> const& lf)
  {
    return lf.order();
  }


78

79
80
81
82
83
84
85
86
87
88
89
90
  /**
    * \addtogroup GridFunctions
    * @{
    **/

  /// \brief Gridfunction returning a constant value.
  /**
   * A stored constant is return in global and local evaluation of this functor.
   * May be used with arithmetic types and vectors/matrices of arithmetic types.
   * It is also allowed to pass a \ref std::reference_wrapper to allow to
   * modify the value after construction.
   **/
91
92
93
94
95
96
97
98
99
  template <class T, class GridView>
  class ConstantGridFunction
  {
  public:
    using EntitySet = Dune::Functions::GridViewEntitySet<GridView, 0>;
    using Element = typename EntitySet::Element;

    using Domain = typename EntitySet::GlobalCoordinate;
    using LocalDomain = typename EntitySet::LocalCoordinate;
Praetorius, Simon's avatar
Praetorius, Simon committed
100
101
    using Range = Underlying_t<T>;

102
103
    enum { hasDerivative = false };

104
105
  public:
    using LocalFunction = ConstantLocalFunction<Range(LocalDomain), Element, T>;
Praetorius, Simon's avatar
Praetorius, Simon committed
106

107
108
109
  public:
    /// Constructor. Stores the function `fct` and creates an `EntitySet`.
    ConstantGridFunction(T const& value, GridView const& gridView)
Praetorius, Simon's avatar
Praetorius, Simon committed
110
      : value_(value)
111
      , entitySet_(gridView)
Praetorius, Simon's avatar
Praetorius, Simon committed
112
113
    {}

114
115
    /// Return the evaluated functor at global coordinates
    Range const& operator()(Domain const& /*x*/) const
Praetorius, Simon's avatar
Praetorius, Simon committed
116
117
118
119
    {
      return value_;
    }

120
    EntitySet const& entitySet() const
Praetorius, Simon's avatar
Praetorius, Simon committed
121
    {
122
      return entitySet_;
Praetorius, Simon's avatar
Praetorius, Simon committed
123
124
    }

125
126
127
128
    LocalFunction localFunction() const
    {
      return {value_};
    }
129

Praetorius, Simon's avatar
Praetorius, Simon committed
130
131
  private:
    T value_;
132
    EntitySet entitySet_;
Praetorius, Simon's avatar
Praetorius, Simon committed
133
134
  };

135
136
  /// Return the LocalFunction of the \ref ConstantGridFunction. \relates ConstantGridFunction
  template <class T, class GV>
137
  auto localFunction(ConstantGridFunction<T,GV> const& gf)
138
  {
139
    return gf.localFunction();
140
141
  }

Praetorius, Simon's avatar
Praetorius, Simon committed
142
143
  /** @} **/

144

Praetorius, Simon's avatar
Praetorius, Simon committed
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
  namespace Concepts
  {
    /** \addtogroup Concepts
     *  @{
     **/

    namespace Definition
    {
      template <class T>
      struct ConstantToGridFunction
        : std::is_arithmetic<T> {};

      template <class T>
      struct ConstantToGridFunction<std::reference_wrapper<T>>
        : ConstantToGridFunction<T> {};

      template <class T, int N>
      struct ConstantToGridFunction<Dune::FieldVector<T, N>>
        : ConstantToGridFunction<T> {};

      template <class T, int N, int M>
      struct ConstantToGridFunction<Dune::FieldMatrix<T, N, M>>
        : ConstantToGridFunction<T> {};

      template <class T, int N>
      struct ConstantToGridFunction<Dune::DiagonalMatrix<T, N>>
        : ConstantToGridFunction<T> {};

    } // end namespace Definition


Praetorius, Simon's avatar
Praetorius, Simon committed
176
177
178
    /// \brief Concepts that is true for all ''simple'' types that can be
    /// converted automatically to a GridFunction, e.g. arithmetic types,
    /// FieldVectors, and `std::reference_wrapper`.
Praetorius, Simon's avatar
Praetorius, Simon committed
179
180
181
182
183
184
185
186
    template <class T>
    constexpr bool ConstantToGridFunction =
      Definition::ConstantToGridFunction<T>::value;

    /** @} **/

  } // end namespace Concepts

187

188
189
  template <class Value>
  struct GridFunctionCreator<Value, std::enable_if_t<Concepts::ConstantToGridFunction<Value>>>
Praetorius, Simon's avatar
Praetorius, Simon committed
190
  {
191
192
    template <class GridView>
    static auto create(Value const& value, GridView const& gridView)
193
    {
194
      return ConstantGridFunction<Value,GridView>{value, gridView};
195
    }
196
  };
Praetorius, Simon's avatar
Praetorius, Simon committed
197
198

} // end namespace AMDiS