dune-functions  2.5-dev
concepts.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_CONCEPTS_HH
4 #define DUNE_FUNCTIONS_FUNCTIONSPACEBASES_CONCEPTS_HH
5 
6 
7 #include <dune/common/concept.hh>
8 
10 
12 
13 
14 namespace Dune {
15 namespace Functions {
16 namespace Concept {
17 
18 using namespace Dune::Concept;
19 
20 
21 struct HasResize
22 {
23  template<class C>
24  auto require(C&& c) -> decltype(
25  c.resize(0)
26  );
27 };
28 
29 
30 
32 {
33  template<class C>
34  auto require(C&& c) -> decltype(
35  c.size()
36  );
37 };
38 
39 
40 
42 {
43  template<class C, class I>
44  auto require(C&& c, I&& i) -> decltype(
45  c[i]
46  );
47 };
48 
49 
50 // Concept for a BasisNode in a local ansatz tree
51 struct BasisNode
52 {
53  template<class N>
54  auto require(const N& node) -> decltype(
55  requireType<typename N::size_type>(),
56  requireType<typename N::TreePath>(),
57  requireConvertible<typename N::size_type>(node.size()),
58  requireConvertible<typename N::size_type>(node.offset()),
59  requireConvertible<typename N::size_type>(node.localIndex(std::declval<typename N::size_type>())),
60  requireConvertible<typename N::size_type>(node.treeIndex()),
61  requireConvertible<typename N::TreePath>(node.treePath()),
62  requireBaseOf<BasisNodeMixin<typename N::TreePath>, N>()
63  );
64 };
65 
66 
67 
68 // Concept for a LeafBasisNode in a local ansatz tree
69 template<class GridView>
70 struct LeafBasisNode : Refines<BasisNode>
71 {
72  template<class N>
73  auto require(const N& node) -> decltype(
74  requireType<typename N::Element>(),
75  requireType<typename N::FiniteElement>(),
76  requireConvertible<typename N::Element>(node.element()),
77  requireConvertible<const typename N::FiniteElement&>(node.finiteElement()),
78  requireConvertible<typename N::Element>(*(std::declval<GridView>().template begin<0>())),
80  );
81 };
82 
83 
84 template<class GridView>
85 struct BasisTree;
86 
87 // Concept for a PowerBasisNode in a local ansatz tree
88 template<class GridView>
89 struct PowerBasisNode : Refines<BasisNode>
90 {
91  template<class N>
92  auto require(const N& node) -> decltype(
94  requireConcept<BasisTree<GridView>, typename N::ChildType>()
95  );
96 };
97 
98 
99 // Concept for a CompositeBasisNode in a local ansatz tree
100 template<class GridView>
101 struct CompositeBasisNode : Refines<BasisNode>
102 {
103  template<class ST, class TP>
104  struct FixArgs
105  {
106  template<class...T>
108  };
109 
110  template<class N>
111  auto require(const N& node) -> decltype(
113  requireConceptForTupleEntries<BasisTree<GridView>, typename N::ChildTypes>()
114  );
115 };
116 
117 
118 // Concept for a full local BasisTree
119 template<class GridView>
120 struct BasisTree : Refines<BasisNode>
121 {
122  template<class N>
123  auto require(const N& node) -> decltype(
124  requireConcept<typename std::conditional< N::isLeaf, LeafBasisNode<GridView>, BasisNode>::type, N>(),
125  requireConcept<typename std::conditional< N::isPower, PowerBasisNode<GridView>, BasisNode>::type, N>(),
126  requireConcept<typename std::conditional< N::isComposite, CompositeBasisNode<GridView>, BasisNode>::type, N>()
127  );
128 };
129 
130 
131 // Concept for a NodeIndexSet
132 template<class NodeFactory>
134 {
135  template<class I>
136  auto require(const I& indexSet) -> decltype(
137  requireType<typename I::size_type>(),
138  requireType<typename I::MultiIndex>(),
139  requireType<typename I::NodeFactory>(),
140  requireType<typename I::Node>(),
141  requireSameType<typename I::NodeFactory, NodeFactory>(),
142  const_cast<I&>(indexSet).bind(std::declval<typename I::Node>()),
143  const_cast<I&>(indexSet).unbind(),
144  requireConvertible<typename I::size_type>(indexSet.size()),
145  requireConvertible<typename I::MultiIndex>(indexSet.index(std::declval<typename I::size_type>()))
146  );
147 };
148 
149 
150 // Concept for a NodeFactory
151 template<class GridView>
153 {
154  using RootTreePath = decltype(TypeTree::hybridTreePath());
155 
156  template<class F>
157  auto require(const F& factory) -> decltype(
158  requireType<typename F::GridView>(),
159  requireType<typename F::size_type>(),
160  requireType<typename F::MultiIndex>(),
161  requireType<typename F::SizePrefix>(),
162  requireType<typename F::template Node<RootTreePath>>(),
163  requireType<typename F::template IndexSet<RootTreePath>>(),
164  requireSameType<typename F::GridView, GridView>(),
165  const_cast<F&>(factory).initializeIndices(),
166  requireConvertible<typename F::GridView>(factory.gridView()),
167  requireConvertible<typename F::template Node<RootTreePath>>(factory.node(RootTreePath())),
168  requireConvertible<typename F::template IndexSet<RootTreePath>>(factory.template indexSet<RootTreePath>()),
169  requireConvertible<typename F::size_type>(factory.size()),
170  requireConvertible<typename F::size_type>(factory.size(std::declval<typename F::SizePrefix>())),
171  requireConvertible<typename F::size_type>(factory.dimension()),
172  requireConvertible<typename F::size_type>(factory.maxNodeSize()),
173  requireConcept<BasisTree<typename F::GridView>>(factory.node(RootTreePath())),
174  requireConcept<NodeIndexSet<F>>(factory.template indexSet<RootTreePath>())
175  );
176 };
177 
178 
179 
180 // Concept for a LocalView
181 template<class GlobalBasis>
182 struct LocalView
183 {
184  template<class V>
185  auto require(const V& localView) -> decltype(
186  requireType<typename V::size_type>(),
187  requireType<typename V::GlobalBasis>(),
188  requireType<typename V::Tree>(),
189  requireType<typename V::GridView>(),
190  requireType<typename V::Element>(),
191  requireSameType<typename V::GlobalBasis, GlobalBasis>(),
192  requireSameType<typename V::GridView, typename GlobalBasis::GridView>(),
193  requireSameType<typename V::size_type, typename GlobalBasis::size_type>(),
194  requireSameType<typename V::Element, typename GlobalBasis::GridView::template Codim<0>::Entity>(),
195  const_cast<V&>(localView).bind(std::declval<typename V::Element>()),
196  const_cast<V&>(localView).unbind(),
197  requireConvertible<typename V::Tree>(localView.tree()),
198  requireConvertible<typename V::size_type>(localView.size()),
199  requireConvertible<typename V::size_type>(localView.maxSize()),
200  requireConvertible<typename V::GlobalBasis>(localView.globalBasis()),
201  requireConcept<BasisTree<typename V::GridView>>(localView.tree()),
202  0
203  );
204 };
205 
206 
207 
208 // Concept for a LocalIndexSet
209 template<class LocalView>
211 {
212  template<class I>
213  auto require(const I& indexSet) -> decltype(
214  requireType<typename I::size_type>(),
215  requireType<typename I::MultiIndex>(),
216  requireType<typename I::LocalView>(),
217  requireSameType<typename I::LocalView, LocalView>(),
218  const_cast<I&>(indexSet).bind(std::declval<typename I::LocalView>()),
219  const_cast<I&>(indexSet).unbind(),
220  requireConvertible<typename I::size_type>(indexSet.size()),
221  requireConvertible<typename I::MultiIndex>(indexSet.index(std::declval<typename I::size_type>())),
222  requireConvertible<typename I::LocalView>(indexSet.localView())
223  );
224 };
225 
226 
227 
228 // Concept for a GlobalBasis
229 template<class GridView>
231 {
232  template<class B>
233  auto require(const B& basis) -> decltype(
234  requireType<typename B::GridView>(),
235  requireType<typename B::size_type>(),
236  requireType<typename B::MultiIndex>(),
237  requireType<typename B::SizePrefix>(),
238  requireType<typename B::LocalIndexSet>(),
239  requireType<typename B::LocalView>(),
240  requireSameType<typename B::GridView, GridView>(),
241  requireConvertible<typename B::GridView>(basis.gridView()),
242  requireConvertible<typename B::LocalIndexSet>(basis.localIndexSet()),
243  requireConvertible<typename B::LocalView>(basis.localView()),
244  requireConvertible<typename B::size_type>(basis.size()),
245  requireConvertible<typename B::size_type>(basis.size(std::declval<typename B::SizePrefix>())),
246  requireConvertible<typename B::size_type>(basis.dimension()),
247  requireConcept<LocalIndexSet<typename B::LocalView>>(basis.localIndexSet()),
248  requireConcept<LocalView<B>>(basis.localView())
249  );
250 };
251 
252 } // namespace Dune::Functions::Concept
253 } // namespace Dune::Functions
254 } // namespace Dune
255 
256 
257 #endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_CONCEPTS_HH
Definition: nodes.hh:209
Definition: concepts.hh:210
Definition: concepts.hh:70
Definition: concepts.hh:31
decltype(TypeTree::hybridTreePath()) RootTreePath
Definition: concepts.hh:154
Definition: concepts.hh:133
Definition: concepts.hh:51
Definition: polynomial.hh:7
Definition: nodes.hh:189
Definition: concepts.hh:182
Definition: nodes.hh:232
Definition: concepts.hh:230
typename Dune::Functions::CompositeBasisNode< ST, TP, T... > CompositeBasisNode
Definition: concepts.hh:107
typename Imp::ExpandTupleHelper< T, ArgTuple >::Type ExpandTuple
Expand tuple arguments as template arguments.
Definition: utility.hh:91
Definition: concepts.hh:21
Definition: concepts.hh:85
Definition: nodes.hh:112
Definition: concepts.hh:152