dune-pdelab  2.5-dev
gridfunctionspace.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_PDELAB_GRIDFUNCTIONSPACE_GRIDFUNCTIONSPACE_HH
4 #define DUNE_PDELAB_GRIDFUNCTIONSPACE_GRIDFUNCTIONSPACE_HH
5 
6 #include <cstddef>
7 #include <map>
8 #include <ostream>
9 #include <set>
10 #include <vector>
11 
12 #include <dune/common/exceptions.hh>
13 #include <dune/common/shared_ptr.hh>
14 #include <dune/common/stdstreams.hh>
15 #include <dune/common/typetraits.hh>
16 
17 #include <dune/geometry/referenceelements.hh>
18 #include <dune/geometry/type.hh>
19 
20 #include <dune/localfunctions/common/interfaceswitch.hh>
21 #include <dune/localfunctions/common/localkey.hh>
22 
23 #include <dune/typetree/typetree.hh>
24 
27 
28 // we just want the descriptors here, so we temporarily switch off the warning for
29 // directly including ISTL backend headers
30 #define _DUNE_PDELAB_SUPPRESS_ISTL_HH_WARNING
32 #undef _DUNE_PDELAB_SUPPRESS_ISTL_HH_WARNING
33 
43 
44 namespace Dune {
45  namespace PDELab {
46 
50 
51 #ifndef DOXYGEN
52 
53  namespace impl {
54 
55  // Helper structs to avoid compilation failures in the
56  // backwards compatibility mode where users stuff a
57  // GridView into a GridFunctionSpace.
58  // In that case, we cannot extract the GridView type from
59  // the GridView itself, so we use a std::conditional in the
60  // Traits class to pick either one of the following structs
61  // and then use the correct class to do the lookup.
62 
63  struct _lazy_identity
64  {
65  template<typename T>
66  struct evaluate
67  {
68  using type = T;
69  };
70  };
71 
72  struct _lazy_extract_gridview
73  {
74  template<typename T>
75  struct evaluate
76  {
77  using type = typename T::GridView;
78  };
79  };
80 
81  // Returns a GridView, regardless of whether GV_or_ES is a GridView or an EntitySet
82  template<typename GV_or_ES>
83  using GridView = typename std::conditional<
85  impl::_lazy_extract_gridview,
86  impl::_lazy_identity
87  >::type::template evaluate<GV_or_ES>::type;
88 
89 
90  // Returns an EntitySet, regardless of whether GV_or_ES is a GridView or an EntitySet
91  template<typename GV_or_ES>
92  using EntitySet = typename std::conditional<
93  isEntitySet<GV_or_ES>::value,
94  GV_or_ES,
95  AllEntitySet<GV_or_ES>
96  >::type;
97 
98  }
99 
100 #endif // DOXYGEN
101 
102  //=======================================
103  // grid function space : single component case
104  //=======================================
105 
107 
110  template<typename G, typename L, typename C, typename B, typename O>
112  {
114  static const bool isComposite = false;
115 
117  using GridView = impl::GridView<G>;
118 
120  using EntitySet = impl::EntitySet<G>;
121 
123 
125  typedef B BackendType;
126 
127  typedef B Backend;
128 
130  typedef typename B::size_type SizeType;
131 
134 
136  typedef L FiniteElementMap;
137 
139  typedef typename L::Traits::FiniteElementType FiniteElementType;
140 
141  typedef typename L::Traits::FiniteElementType FiniteElement;
142 
144  typedef C ConstraintsType;
145 
147 
151  typedef O OrderingTag;
152 
153  };
154 
167  template<typename GV, typename FEM, typename CE=NoConstraints,
168  typename B=ISTL::VectorBackend<>, typename P=DefaultLeafOrderingTag>
170  : public TypeTree::LeafNode
171  , public GridFunctionSpaceBase<
172  GridFunctionSpace<GV,FEM,CE,B,P>,
173  GridFunctionSpaceTraits<GV,FEM,CE,B,P>
174  >
176  , public DataHandleProvider<GridFunctionSpace<GV,FEM,CE,B,P> >
177  {
178 
179  typedef TypeTree::TransformTree<GridFunctionSpace,gfs_to_ordering<GridFunctionSpace> > ordering_transformation;
180 
181  template<typename,typename>
182  friend class GridFunctionSpaceBase;
183 
184  public:
187 
188  private:
189 
191 
192  public:
193 
194  typedef typename GV::Traits::template Codim<0>::Entity Element;
195  typedef typename GV::Traits::template Codim<0>::Iterator ElementIterator;
196 
197  typedef P SizeTag;
198 
199  typedef P OrderingTag;
200 
202 
203  typedef typename ordering_transformation::Type Ordering;
204 
206  template<typename E>
208  {
209 
211  typedef typename std::conditional<
212  std::is_same<
213  CE,
215  >::value,
218  >::type Type;
219 
220  private:
222  };
223 
224  // ****************************************************************************************************
225  // Construct from GridView
226  // ****************************************************************************************************
227 
229  GridFunctionSpace (const typename Traits::GridView& gridview, const FEM& fem, const CE& ce, const B& backend = B(), const OrderingTag& ordering_tag = OrderingTag())
230  : BaseT(backend,ordering_tag)
231  , _es(gridview)
232  , pfem(stackobject_to_shared_ptr(fem))
233  , _pce(stackobject_to_shared_ptr(ce))
234  {
235  }
236 
238  GridFunctionSpace (const typename Traits::GridView& gridview, const std::shared_ptr<const FEM>& fem, const std::shared_ptr<const CE>& ce, const B& backend = B(), const OrderingTag& ordering_tag = OrderingTag())
239  : BaseT(backend,ordering_tag)
240  , _es(gridview)
241  , pfem(fem)
242  , _pce(ce)
243  {}
244 
246  GridFunctionSpace (const typename Traits::GridView& gridview, const FEM& fem, const B& backend = B(), const OrderingTag& ordering_tag = OrderingTag())
247  : BaseT(backend,ordering_tag)
248  , _es(gridview)
249  , pfem(stackobject_to_shared_ptr(fem))
250  , _pce(std::make_shared<CE>())
251  {}
252 
254  GridFunctionSpace (const typename Traits::GridView& gridview, const std::shared_ptr<const FEM>& fem, const B& backend = B(), const OrderingTag& ordering_tag = OrderingTag())
255  : BaseT(backend,ordering_tag)
256  , _es(gridview)
257  , pfem(fem)
258  , _pce(std::make_shared<CE>())
259  {}
260 
261 
262  // ****************************************************************************************************
263  // Construct from EntitySet
264  // ****************************************************************************************************
265 
266 
268  GridFunctionSpace (const typename Traits::EntitySet& entitySet, const FEM& fem, const CE& ce, const B& backend = B(), const OrderingTag& ordering_tag = OrderingTag())
269  : BaseT(backend,ordering_tag)
270  , _es(entitySet)
271  , pfem(stackobject_to_shared_ptr(fem))
272  , _pce(stackobject_to_shared_ptr(ce))
273  {
274  }
275 
277  GridFunctionSpace (const typename Traits::EntitySet& entitySet, const std::shared_ptr<const FEM>& fem, const std::shared_ptr<const CE>& ce, const B& backend = B(), const OrderingTag& ordering_tag = OrderingTag())
278  : BaseT(backend,ordering_tag)
279  , _es(entitySet)
280  , pfem(fem)
281  , _pce(ce)
282  {}
283 
285  GridFunctionSpace (const typename Traits::EntitySet& entitySet, const FEM& fem, const B& backend = B(), const OrderingTag& ordering_tag = OrderingTag())
286  : BaseT(backend,ordering_tag)
287  , _es(entitySet)
288  , pfem(stackobject_to_shared_ptr(fem))
289  , _pce(std::make_shared<CE>())
290  {}
291 
293  GridFunctionSpace (const typename Traits::EntitySet& entitySet, const std::shared_ptr<const FEM>& fem, const B& backend = B(), const OrderingTag& ordering_tag = OrderingTag())
294  : BaseT(backend,ordering_tag)
295  , _es(entitySet)
296  , pfem(fem)
297  , _pce(std::make_shared<CE>())
298  {}
299 
300 
302  const typename Traits::GridView& gridView () const
303  {
304  return _es.gridView();
305  }
306 
308  const typename Traits::EntitySet& entitySet () const
309  {
310  return _es;
311  }
312 
314  const FEM& finiteElementMap () const
315  {
316  return *pfem;
317  }
318 
320  std::shared_ptr<const FEM> finiteElementMapStorage () const
321  {
322  return pfem;
323  }
324 
326  const typename Traits::ConstraintsType& constraints () const
327  {
328  return *_pce;
329  }
330 
332  std::shared_ptr<const CE> constraintsStorage () const
333  {
334  return _pce;
335  }
336 
337  //------------------------------
338 
340  const Ordering &ordering() const
341  {
342  if (!this->isRootSpace())
343  {
345  "Ordering can only be obtained for root space in GridFunctionSpace tree.");
346  }
347  if (!_ordering)
348  {
349  create_ordering();
350  this->update(*_ordering);
351  }
352  return *_ordering;
353  }
354 
356  Ordering &ordering()
357  {
358  if (!this->isRootSpace())
359  {
361  "Ordering can only be obtained for root space in GridFunctionSpace tree.");
362  }
363  if (!_ordering)
364  {
365  create_ordering();
366  this->update(*_ordering);
367  }
368  return *_ordering;
369  }
370 
372  std::shared_ptr<const Ordering> orderingStorage() const
373  {
374  if (!this->isRootSpace())
375  {
377  "Ordering can only be obtained for root space in GridFunctionSpace tree.");
378  }
379  if (!_ordering)
380  {
381  create_ordering();
382  this->update(*_ordering);
383  }
384  return _ordering;
385  }
386 
388  std::shared_ptr<Ordering> orderingStorage()
389  {
390  if (!this->isRootSpace())
391  {
393  "Ordering can only be obtained for root space in GridFunctionSpace tree.");
394  }
395  if (!_ordering)
396  {
397  create_ordering();
398  this->update(*_ordering);
399  }
400  return _ordering;
401  }
402 
403  private:
404 
405  // This method here is to avoid a double update of the Ordering when the user calls
406  // GFS::update() before GFS::ordering().
407  void create_ordering() const
408  {
409  _ordering = std::make_shared<Ordering>(ordering_transformation::transform(*this));
410  }
411 
412  typename Traits::EntitySet _es;
413  std::shared_ptr<FEM const> pfem;
414  std::shared_ptr<CE const> _pce;
415 
416  mutable std::shared_ptr<Ordering> _ordering;
417  };
418 
419 
420  } // namespace PDELab
421 } // namespace Dune
422 
423 #endif // DUNE_PDELAB_GRIDFUNCTIONSPACE_GRIDFUNCTIONSPACE_HH
const FEM & finiteElementMap() const
get finite element map
Definition: gridfunctionspace.hh:314
P OrderingTag
Definition: gridfunctionspace.hh:199
const Traits::ConstraintsType & constraints() const
return constraints engine
Definition: gridfunctionspace.hh:326
GridFunctionSpace(const typename Traits::EntitySet &entitySet, const std::shared_ptr< const FEM > &fem, const std::shared_ptr< const CE > &ce, const B &backend=B(), const OrderingTag &ordering_tag=OrderingTag())
constructor
Definition: gridfunctionspace.hh:277
const Traits::GridView & gridView() const
get grid view
Definition: gridfunctionspace.hh:302
P SizeTag
Definition: gridfunctionspace.hh:197
Definition: istl/descriptors.hh:50
GridFunctionSpace(const typename Traits::EntitySet &entitySet, const FEM &fem, const B &backend=B(), const OrderingTag &ordering_tag=OrderingTag())
constructor
Definition: gridfunctionspace.hh:285
O OrderingTag
tag describing the ordering.
Definition: gridfunctionspace.hh:151
L::Traits::FiniteElementType FiniteElement
Definition: gridfunctionspace.hh:141
extract type for storing constraints
Definition: gridfunctionspace.hh:207
B BackendType
vector backend
Definition: gridfunctionspace.hh:125
For backward compatibility – Do not use this!
Definition: adaptivity.hh:27
L FiniteElementMap
finite element map
Definition: gridfunctionspace.hh:136
Tag indicating a standard ordering for a leaf GridfunctionSpace.
Definition: gridfunctionspace/tags.hh:183
GridFunctionSpace(const typename Traits::GridView &gridview, const std::shared_ptr< const FEM > &fem, const B &backend=B(), const OrderingTag &ordering_tag=OrderingTag())
constructor
Definition: gridfunctionspace.hh:254
std::shared_ptr< const Ordering > orderingStorage() const
Direct access to the storage of the DOF ordering.
Definition: gridfunctionspace.hh:372
ordering_transformation::Type Ordering
Definition: gridfunctionspace.hh:203
GridFunctionSpace(const typename Traits::GridView &gridview, const FEM &fem, const CE &ce, const B &backend=B(), const OrderingTag &ordering_tag=OrderingTag())
constructor
Definition: gridfunctionspace.hh:229
static const unsigned int value
Definition: gridfunctionspace/tags.hh:139
LeafGridFunctionSpaceTag ImplementationTag
Definition: gridfunctionspace.hh:201
A grid function space.
Definition: gridfunctionspace.hh:169
GridView GridViewType
Definition: gridfunctionspace.hh:122
Definition: datahandleprovider.hh:187
const Traits::EntitySet & entitySet() const
get EntitySet
Definition: gridfunctionspace.hh:308
B::size_type SizeType
short cut for size type exported by Backend
Definition: gridfunctionspace.hh:130
GridFunctionSpace(const typename Traits::EntitySet &entitySet, const std::shared_ptr< const FEM > &fem, const B &backend=B(), const OrderingTag &ordering_tag=OrderingTag())
constructor
Definition: gridfunctionspace.hh:293
Definition: gridfunctionspacebase.hh:134
Mixin base class for specifying output hints to I/O routines like VTK.
Definition: function.hh:123
STL namespace.
Ordering & ordering()
Direct access to the DOF ordering.
Definition: gridfunctionspace.hh:356
Definition: noconstraints.hh:16
collect types exported by a leaf grid function space
Definition: gridfunctionspace.hh:111
B Backend
Definition: gridfunctionspace.hh:127
a class holding transformation for constrained spaces
Definition: constraintstransformation.hh:18
impl::GridView< G > GridView
the grid view where grid function is defined upon
Definition: gridfunctionspace.hh:117
GV::Traits::template Codim< 0 >::Entity Element
Definition: gridfunctionspace.hh:194
GridFunctionSpace(const typename Traits::GridView &gridview, const FEM &fem, const B &backend=B(), const OrderingTag &ordering_tag=OrderingTag())
constructor
Definition: gridfunctionspace.hh:246
Definition: gridfunctionspace/tags.hh:32
GV::Traits::template Codim< 0 >::Iterator ElementIterator
Definition: gridfunctionspace.hh:195
GridFunctionSpace(const typename Traits::GridView &gridview, const std::shared_ptr< const FEM > &fem, const std::shared_ptr< const CE > &ce, const B &backend=B(), const OrderingTag &ordering_tag=OrderingTag())
constructor
Definition: gridfunctionspace.hh:238
const Ordering & ordering() const
Direct access to the DOF ordering.
Definition: gridfunctionspace.hh:340
std::shared_ptr< const CE > constraintsStorage() const
return storage of constraints engine
Definition: gridfunctionspace.hh:332
L::Traits::FiniteElementType FiniteElementType
finite element
Definition: gridfunctionspace.hh:139
GridFunctionSpaceTraits< GV, FEM, CE, B, P > Traits
export Traits class
Definition: gridfunctionspace.hh:186
Definition: constraintstransformation.hh:111
std::shared_ptr< Ordering > orderingStorage()
Direct access to the storage of the DOF ordering.
Definition: gridfunctionspace.hh:388
std::conditional< std::is_same< CE, NoConstraints >::value, EmptyTransformation, ConstraintsTransformation< typename Ordering::Traits::DOFIndex, typename Ordering::Traits::ContainerIndex, E > >::type Type
define Type as the Type of a container of E&#39;s
Definition: gridfunctionspace.hh:218
impl::EntitySet< G > EntitySet
the entity set of this function space.
Definition: gridfunctionspace.hh:120
C ConstraintsType
type representing constraints
Definition: gridfunctionspace.hh:144
std::shared_ptr< const FEM > finiteElementMapStorage() const
get finite element map
Definition: gridfunctionspace.hh:320
GridFunctionSpace(const typename Traits::EntitySet &entitySet, const FEM &fem, const CE &ce, const B &backend=B(), const OrderingTag &ordering_tag=OrderingTag())
constructor
Definition: gridfunctionspace.hh:268
L FiniteElementMapType
finite element map
Definition: gridfunctionspace.hh:133