dune-functions  2.9.0
rannacherturekbasis.hh
Go to the documentation of this file.
1 // -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 // vi: set et ts=4 sw=2 sts=2:
3 #ifndef DUNE_FUNCTIONS_FUNCTIONSPACEBASES_RANNACHERTUREKBASIS_HH
4 #define DUNE_FUNCTIONS_FUNCTIONSPACEBASES_RANNACHERTUREKBASIS_HH
5 
6 #include <dune/common/exceptions.hh>
7 
8 #include <dune/grid/common/capabilities.hh>
9 
10 #include <dune/localfunctions/common/localfiniteelementvariant.hh>
11 #include <dune/localfunctions/rannacherturek.hh>
12 #include <dune/localfunctions/crouzeixraviart.hh>
13 
16 
17 
18 namespace Dune {
19 namespace Functions {
20 
21 // *****************************************************************************
22 // This is the reusable part of the basis. It contains
23 //
24 // RannacherTurekPreBasis
25 // RannacherTurekNode
26 //
27 // The pre-basis allows to create the others and is the owner of possible shared
28 // state. These components do _not_ depend on the global basis and local view
29 // and can be used without a global basis.
30 // *****************************************************************************
31 
32 template<typename GV>
33 class RannacherTurekNode;
34 
35 template<typename GV>
36 class RannacherTurekPreBasis;
37 
50 template<typename GV>
52 {
53  static const int dim = GV::dimension;
54 
55 public:
56 
58  using GridView = GV;
59 
61  using size_type = std::size_t;
62 
65 
66  static constexpr size_type maxMultiIndexSize = 1;
67  static constexpr size_type minMultiIndexSize = 1;
68  static constexpr size_type multiIndexBufferSize = 1;
69 
72  gridView_(gv)
73  {
74  for(auto type : gv.indexSet().types(0))
75  if (!type.isSimplex() && !type.isCube())
76  DUNE_THROW(Dune::NotImplemented, "Rannacher-Turek or Crouzeix-Raviart elements are only implemented for grids with simplex or cube elements.");
77  }
78 
81  {}
82 
84  const GridView& gridView() const
85  {
86  return gridView_;
87  }
88 
90  void update (const GridView& gv)
91  {
92  gridView_ = gv;
93  }
94 
98  Node makeNode() const
99  {
100  return Node{};
101  }
102 
104  size_type size() const
105  {
106  return (size_type)(gridView_.size(1));
107  }
108 
110  template<class SizePrefix>
111  size_type size(const SizePrefix prefix) const
112  {
113  assert(prefix.size() == 0 || prefix.size() == 1);
114  return (prefix.size() == 0) ? size() : 0;
115  }
116 
119  {
120  return size();
121  }
122 
125  {
126  return 2*GV::dimension;
127  }
128 
129  template<typename It>
130  It indices(const Node& node, It it) const
131  {
132  for (size_type i = 0, end = node.size() ; i < end ; ++i, ++it)
133  {
134  Dune::LocalKey localKey = node.finiteElement().localCoefficients().localKey(i);
135  const auto& gridIndexSet = gridView().indexSet();
136  const auto& element = node.element();
137 
138  *it = {{ (size_type)(gridIndexSet.subIndex(element,localKey.subEntity(),1)) }};
139  }
140  return it;
141  }
142 
143 protected:
145 };
146 
147 
148 
149 template<typename GV>
151  public LeafBasisNode
152 {
153  static const int dim = GV::dimension;
154  static const int maxSize = 2*dim;
155 
156  constexpr static bool hasFixedElementType = Capabilities::hasSingleGeometryType<typename GV::Grid>::v;
157 
158  using CubeFiniteElement = RannacherTurekLocalFiniteElement<typename GV::ctype,double,dim>;
159  using SimplexFiniteElement = CrouzeixRaviartLocalFiniteElement<typename GV::ctype,double,dim>;
160 
161  constexpr static unsigned int topologyId = Capabilities::hasSingleGeometryType<typename GV::Grid>::topologyId; // meaningless if hasFixedElementType is false
162  constexpr static GeometryType type = GeometryType(topologyId, GV::dimension);
163 
164 public:
165 
166  using size_type = std::size_t;
167  using Element = typename GV::template Codim<0>::Entity;
168  using FiniteElement = std::conditional_t<hasFixedElementType,
169  std::conditional_t<type.isCube(),CubeFiniteElement,SimplexFiniteElement>,
170  LocalFiniteElementVariant<CubeFiniteElement, SimplexFiniteElement> >;
171 
173  finiteElement_(),
174  element_(nullptr)
175  {}
176 
178  const Element& element() const
179  {
180  return *element_;
181  }
182 
188  {
189  return finiteElement_;
190  }
191 
193  void bind(const Element& e)
194  {
195  element_ = &e;
196  if constexpr (!hasFixedElementType)
197  finiteElement_ = e.type().isCube() ? static_cast<FiniteElement>(CubeFiniteElement())
198  : static_cast<FiniteElement>(SimplexFiniteElement()) ;
199  this->setSize(finiteElement_.size());
200  }
201 
202 protected:
203 
206 };
207 
208 
209 
210 namespace BasisFactory {
211 
217 template<class Dummy=void>
219 {
220  return [](const auto& gridView) {
221  return RannacherTurekPreBasis<std::decay_t<decltype(gridView)>>(gridView);
222  };
223 }
224 
225 } // end namespace BasisFactory
226 
227 
228 
229 
241 template<typename GV>
243 
244 } // end namespace Functions
245 } // end namespace Dune
246 
247 #endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_RANNACHERTUREKBASIS_HH
auto rannacherTurek()
Create a pre-basis factory that can create a Rannacher-Turek pre-basis.
Definition: rannacherturekbasis.hh:218
Definition: polynomial.hh:10
Global basis for given pre-basis.
Definition: defaultglobalbasis.hh:46
size_type size() const
Definition: nodes.hh:142
std::size_t size_type
Definition: nodes.hh:128
void setSize(const size_type size)
Definition: nodes.hh:164
Definition: nodes.hh:186
Definition: rannacherturekbasis.hh:152
std::conditional_t< hasFixedElementType, std::conditional_t< type.isCube(), CubeFiniteElement, SimplexFiniteElement >, LocalFiniteElementVariant< CubeFiniteElement, SimplexFiniteElement > > FiniteElement
Definition: rannacherturekbasis.hh:170
void bind(const Element &e)
Bind to element.
Definition: rannacherturekbasis.hh:193
FiniteElement finiteElement_
Definition: rannacherturekbasis.hh:204
const Element & element() const
Return current element, throw if unbound.
Definition: rannacherturekbasis.hh:178
typename GV::template Codim< 0 >::Entity Element
Definition: rannacherturekbasis.hh:167
RannacherTurekNode()
Definition: rannacherturekbasis.hh:172
const Element * element_
Definition: rannacherturekbasis.hh:205
const FiniteElement & finiteElement() const
Return the LocalFiniteElement for the element we are bound to.
Definition: rannacherturekbasis.hh:187
Pre-basis for a Rannacher-Turek basis.
Definition: rannacherturekbasis.hh:52
static constexpr size_type multiIndexBufferSize
Definition: rannacherturekbasis.hh:68
void initializeIndices()
Initialize the global indices.
Definition: rannacherturekbasis.hh:80
static constexpr size_type maxMultiIndexSize
Definition: rannacherturekbasis.hh:66
static constexpr size_type minMultiIndexSize
Definition: rannacherturekbasis.hh:67
size_type size(const SizePrefix prefix) const
Return number of possible values for next position in multi index.
Definition: rannacherturekbasis.hh:111
std::size_t size_type
Type used for indices and size information.
Definition: rannacherturekbasis.hh:61
Node makeNode() const
Create tree node.
Definition: rannacherturekbasis.hh:98
void update(const GridView &gv)
Update the stored grid view, to be called if the grid has changed.
Definition: rannacherturekbasis.hh:90
It indices(const Node &node, It it) const
Definition: rannacherturekbasis.hh:130
GV GridView
The grid view that the FE basis is defined on.
Definition: rannacherturekbasis.hh:58
size_type dimension() const
Get the total dimension of the space spanned by this basis.
Definition: rannacherturekbasis.hh:118
RannacherTurekPreBasis(const GridView &gv)
Constructor for a given grid view object.
Definition: rannacherturekbasis.hh:71
size_type size() const
Same as size(prefix) with empty prefix.
Definition: rannacherturekbasis.hh:104
const GridView & gridView() const
Obtain the grid view that the basis is defined on.
Definition: rannacherturekbasis.hh:84
size_type maxNodeSize() const
Get the maximal number of DOFs associated to node for any element.
Definition: rannacherturekbasis.hh:124
GridView gridView_
Definition: rannacherturekbasis.hh:144